服务器之家:专注于服务器技术及软件下载分享
分类导航

PHP教程|ASP.NET教程|Java教程|ASP教程|编程技术|正则表达式|C/C++|IOS|C#|Swift|Android|JavaScript|易语言|

服务器之家 - 编程语言 - Java教程 - spring boot设置过滤器、监听器及拦截器的方法

spring boot设置过滤器、监听器及拦截器的方法

2021-07-29 11:17快乐的小乐 Java教程

这篇文章主要给大家介绍了关于spring boot设置过滤器、监听器及拦截器的相关资料,文中通过示例代码介绍的非常详细,对大家学习或者使用spring boot具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧

前言

其实这篇文章算不上是springboot的东西,我们在spring普通项目中也是可以直接使用的

设置过滤器:

以前在普通项目中我们要在web.xml中进行filter的配置,但是只从servlet 3.0后,我们就可以在直接在项目中进行filter的设置,因为她提供了一个注解@webfilter(在javax.servlet.annotation包下),使用这个注解我们就可以进行filter的设置了,同时也解决了我们使用springboot项目没有web.xml的尴尬,使用方法如下所示

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
@webfilter(urlpatterns="/*",filtername="corsfilter", asyncsupported = true)
public class corsfilter implements filter{
 
 @override
 public void init(filterconfig filterconfig) throws servletexception {
 
 }
 
 @override
 public void dofilter(servletrequest servletrequest, servletresponse servletresponse,
   filterchain chain) throws ioexception, servletexception {
  httpservletresponse response = (httpservletresponse)servletresponse;
  httpservletrequest request = (httpservletrequest)servletrequest;
  chain.dofilter(servletrequest, servletresponse);
 }
 
 @override
 public void destroy() {
 
 }
 
}

其实在webfilter注解中有一些属性我们需要进行设置, 比如value、urlpatterns,这两个属性其实都是一样的作用,都是为了设置拦截路径,asyncsupported这个属性是设置配置的filter是否支持异步响应,默认是不支持的,如果我们的项目需要进行请求的异步响应,请求经过了filter,那么这个filter的asyncsupported属性必须设置为true不然请求的时候会报异常。

设置拦截器:

编写一个配置类,继承org.springframework.web.servlet.config.annotation.webmvcconfigureradapter或者org.springframework.web.servlet.config.annotation.webmvcconfigurationsupport并重写addinterceptors(interceptorregistry registry)方法,其实父类的addinterceptors(interceptorregistry registry)方法就是个空方法。使用方法如下:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
@configuration
public class mvcconfig extends webmvcconfigurationsupport {
 
 @override
 public void addinterceptors(interceptorregistry registry) {
  interceptorregistration registration = registry.addinterceptor(new handlerinterceptor() {
   @override
   public boolean prehandle(httpservletrequest request, httpservletresponse response, object handler) throws exception {
    return true;
   }
 
   @override
   public void posthandle(httpservletrequest request, httpservletresponse response, object handler, modelandview modelandview) throws exception {
 
   }
 
   @override
   public void aftercompletion(httpservletrequest request, httpservletresponse response, object handler, exception ex) throws exception {
 
   }
  });
  // 配置拦截路径
  registration.addpathpatterns("/**");
  // 配置不进行拦截的路径
  registration.excludepathpatterns("/static/**");
 }
}

配置监听器:

一般我们常用的就是request级别的javax.servlet.servletrequestlistener和session级别的javax.servlet.http.httpsessionlistener,下面以servletrequestlistener为例,编写一个类实现servletrequestlistener接口并实现requestinitialized(servletrequestevent event)方法和requestdestroyed(servletrequestevent event)方法,在实现类上加上@weblistener(javax.servlet.annotation包下),如下所示

?
1
2
3
4
5
6
7
8
9
10
11
12
13
@weblistener
public class requestlistener implements servletrequestlistener {
 
 @override
 public void requestdestroyed(servletrequestevent sre) {
  system.out.println("请求结束");
 }
 
 @override
 public void requestinitialized(servletrequestevent sre) {
  system.out.println("请求开始");
 }
}

这样每一个请求都会被监听到,在请求处理前equestinitialized(servletrequestevent event)方法,在请求结束后调用requestdestroyed(servletrequestevent event)方法,其实在spring中有一个非常好的例子,就是org.springframework.web.context.request.requestcontextlistener类

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
public class requestcontextlistener implements servletrequestlistener {
 
  private static final string request_attributes_attribute =
      requestcontextlistener.class.getname() + ".request_attributes";
 
 
  @override
  public void requestinitialized(servletrequestevent requestevent) {
    if (!(requestevent.getservletrequest() instanceof httpservletrequest)) {
      throw new illegalargumentexception(
          "request is not an httpservletrequest: " + requestevent.getservletrequest());
    }
    httpservletrequest request = (httpservletrequest) requestevent.getservletrequest();
    servletrequestattributes attributes = new servletrequestattributes(request);
    request.setattribute(request_attributes_attribute, attributes);
    localecontextholder.setlocale(request.getlocale());
    requestcontextholder.setrequestattributes(attributes);
  }
 
  @override
  public void requestdestroyed(servletrequestevent requestevent) {
    servletrequestattributes attributes = null;
    object reqattr = requestevent.getservletrequest().getattribute(request_attributes_attribute);
    if (reqattr instanceof servletrequestattributes) {
      attributes = (servletrequestattributes) reqattr;
    }
    requestattributes threadattributes = requestcontextholder.getrequestattributes();
    if (threadattributes != null) {
      // we're assumably within the original request thread...
      localecontextholder.resetlocalecontext();
      requestcontextholder.resetrequestattributes();
      if (attributes == null && threadattributes instanceof servletrequestattributes) {
        attributes = (servletrequestattributes) threadattributes;
      }
    }
    if (attributes != null) {
      attributes.requestcompleted();
    }
  }
 
}

在这个类中,spring将每一个请求开始前都将请求进行了一次封装并设置了一个threadlocal,这样我们在请求处理的任何地方都可以通过这个threadlocal获取到请求对象,好处当然是有的啦,比如我们在service层需要用到request的时候,可以不需要调用者传request对象给我们,我们可以通过一个工具类就可以获取,岂不美哉。

扩充:在springboot的启动类中我们可以添加一些applicationlistener监听器,例如:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
@springbootapplication
public class demoapplication {
 
  public static void main(string[] args) {
    springapplication application = new springapplication(demoapplication.class);
    application.addlisteners(new applicationlistener<applicationevent>() {
      @override
      public void onapplicationevent(applicationevent event) {
        system.err.println(event.tostring());
      }
    });
    application.run(args);
  }
}

applicationevent是一个抽象类,她的子类有很多比如servletrequesthandledevent(发生请求事件的时候触发)、applicationstartedevent(应用开始前触发,做一些启动准备工作)、contextrefreshedevent(容器初始化结束后触发),其他还有很多,这里不再多说,但是这些applicationlistener只能在springboot项目以main方法启动的时候才会生效,也就是说项目要打jar包时才适用,如果打war包,放在tomcat等web容器中是没有效果的。

总结

以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作具有一定的参考学习价值,谢谢大家对服务器之家的支持。

原文链接:http://www.cnblogs.com/zzw-blog/p/10656181.html

延伸 · 阅读

精彩推荐