浅谈Springboot实现拦截器的两种方式

• • 1、配置handlerinterceptor
• • 1、实现filter接口

实现过滤请求有两种方式：

一种就是用拦截器，一种就是过滤器

拦截器相对来说比较专业，而过滤器虽然不专业但是也能完成基本的拦截请求要求。

一、拦截器方式

1、配置handlerinterceptor

下面这个也是我们公司项目拦截器的写法，总体来说感觉还不错，我就记录了下来。
利用了一个静态pattern变量存储不走拦截器的路径，然后在prehandle方法当中进行过滤，让他返回true。

@component
public class logininterceptor implements handlerinterceptor{
	
	private static final pattern should_not_filter_url_pattern;
	
	static {
		list<string> urllist = new arraylist<>();
		// 将不走拦截器的请求存放到pattern
		urllist.add("(socket/.*)");
		urllist.add("(user/finduserlist)");
		stringbuilder sb = new stringbuilder();
		for (string url : urllist) {
			sb.append(url);
			sb.append("|");
		}
		sb.setlength(sb.length() - 1);
		should_not_filter_url_pattern = pattern.compile(sb.tostring());
	}
	
	/**
	 * 在请求处理之前进行调用（controller方法调用之前）
	 */
	@override
	public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler)
			throws exception {
		
		httpsession session = request.getsession();
		// 获取访问的url
 		string servletpath = request.getservletpath();
		// 排除特定请求
		if (should_not_filter_url_pattern.matcher(servletpath).find()) {
			return true;
		}
		if (session.getattribute("user") != null) {
			// 可能有的项目在校验完session，还会校验token
			string token = request.getheader("access_token");
			// 此处业务省略。。。
			return true;
		}
		return false;
	}

	/**
	 * 请求处理之后进行调用，但是在视图被渲染之前（controller方法调用之后）
	 */
	@override
	public void posthandle(httpservletrequest request, httpservletresponse response, object handler,
			modelandview modelandview) throws exception {
		// todo auto-generated method stub
		
	}

	/**
	 * 在整个请求结束之后被调用，也就是在dispatcherservlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）
	 */
	@override
	public void aftercompletion(httpservletrequest request, httpservletresponse response, object handler, exception ex)
			throws exception {
		// todo auto-generated method stub
		
	}
}

2、注册拦截器

配置完上面的拦截器还需要注册拦截器。

webmvcconfigureradapter类是 spring内部的一种配置方式
采用javabean的形式来代替传统的xml配置文件形式进行针对框架个性化定制

@configuration
public class mywebappconfigurer extends webmvcconfigureradapter {
	
	@autowired
    private logininterceptor logininterceptor;
	

	@override
	public void addinterceptors(interceptorregistry registry) {
		// 多个拦截器组成一个拦截器链
		// addpathpatterns 用于添加拦截规则
		// excludepathpatterns 用户排除拦截
		registry.addinterceptor(logininterceptor).addpathpatterns("/**");
		super.addinterceptors(registry);
	}
}

3、使用拦截器的坑

继承webmvcconfigureradapter 重写addinterceptors方法的时候，一定要使用注入方式，将logininterceptor注入到变量当中，要么就使用@bean注解的方式，将logininterceptor（拦截器）注入到容器。

之所以这么搞是因为拦截器在 bean 初始化之前进行，所以在拦截器中无法像这样注入 bean。
就算加了@component，他是存放于容器当中了，但是他存放容器当中的对象属性，是空属性。

在webmvcconfigureradapter 使用@autowired注入了一遍拦截器，属性就有值了。

说白了不管采用哪种方案，目的只有一个，让对象的属性有值，因为拦截器比其他对象初始化早，导致属性为空，想让他有值，就想办法让他重新走一遍spring注入容器，也可以采用这种方式：

@configuration
public class mywebappconfigurer extends webmvcconfigureradapter {
	
	// 这么写的目的是为了在sessioninterceptor中能注入spring中的service
	@bean
	logininterceptor logininterceptor() {
		return new logininterceptor();
	}

	@override
	public void addinterceptors(interceptorregistry registry) {
		// 多个拦截器组成一个拦截器链
		// addpathpatterns 用于添加拦截规则
		// excludepathpatterns 用户排除拦截
		registry.addinterceptor(logininterceptor()).addpathpatterns("/**");
		super.addinterceptors(registry);
	}
}

二、过滤器方式

本人这一篇博客写了关于filter的一些知识：

1、实现filter接口

import java.io.ioexception;
import java.util.arraylist;
import java.util.list;
import java.util.regex.pattern;
import javax.servlet.filter;
import javax.servlet.filterchain;
import javax.servlet.filterconfig;
import javax.servlet.servletexception;
import javax.servlet.servletrequest;
import javax.servlet.servletresponse;
import javax.servlet.annotation.webfilter;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpsession;
import org.springframework.stereotype.component;

@component
@webfilter(filtername = "requestparamfilter",urlpatterns = "/*")
public class requestparamfilter implements filter {

	private static final pattern should_not_filter_url_pattern;
	
	static {
		list<string> urllist = new arraylist<>();
		// 将不走拦截器的请求存放到pattern
		urllist.add("(socket/.*)");
		urllist.add("(user/finduserlist)");
		stringbuilder sb = new stringbuilder();
		for (string url : urllist) {
			sb.append(url);
			sb.append("|");
		}
		sb.setlength(sb.length() - 1);
		should_not_filter_url_pattern = pattern.compile(sb.tostring());
	}

    @override
    public void init(filterconfig filterconfig) throws servletexception {

    }
	
	// 发送请求会执行这个方法
    // 一个dofilter相当于拦截器的执行前和执行后
    // filterchain.dofilter后面的内容就是执行后的内容，假如不执行filterchain.dofilter方法相当于方法被拦截
    @override
    public void dofilter(servletrequest servletrequest, servletresponse servletresponse,
                         filterchain filterchain) throws ioexception, servletexception {
        system.out.println("sunhan---请求参数过滤器！---test1");
        httpservletrequest request = (httpservletrequest)servletrequest;
        httpsession session = request.getsession();
		// 获取访问的url
 		string servletpath = request.getservletpath();
		// 排除特定请求
		if (should_not_filter_url_pattern.matcher(servletpath).find()) {
			filterchain.dofilter(servletrequest,servletresponse);
		}
        system.out.println("开始拦截了................");
        //业务代码
    }

    @override
    public void destroy() {

    }
}

2、使用过滤器需要注意的

拦截器可以获取ioc容器中的各个bean，而过滤器就不行，这点很重要，在拦截器里注入一个service，可以调用业务逻辑

执行顺序如下：

到此这篇关于浅谈springboot实现拦截器的两种方式的文章就介绍到这了,更多相关springboot 拦截器内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！