springboot-config 自定义拦截器、过滤器、servlet、监听器

本文介绍Spring-Boot中自定义拦截器、过滤器、servlet、监听器使用。

自定义拦截器

一般在拦截器中处理跨域处理，允许跨域访问项目，拦截器使用详细资料请查阅官网。

实现自定义拦截器步骤： 
1、创建一个类并实现HandlerInterceptor接口。 
2、创建一个Java类继承WebMvcConfigurerAdapter，并重写 addInterceptors 方法。 
2、将自定义的拦截器交由spring管理，然后将对像手动添加到拦截器链中（在addInterceptors方法中添加）。

创建拦截器类

package com.example.springboot.config.intercepter;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * @desc 自定义拦截器，使用 @Component 让 Spring 管理其生命周期
 * @Author wangsh
 * @date 2018/5/6 17:06
 * @return
 */
@Component
public class TestIntercepter implements HandlerInterceptor {

   @Override
   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      System.out.println(">>>preHandle>>>>>>>在请求处理之前进行调用（Controller方法调用之前）");
      setCrossDomain(response);
      return true;// 只有返回true才会继续向下执行，返回false取消当前请求
   }

   @Override
   public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
      // 请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）;
      System.out.println(">>>postHandle>>>>>>>请求处理之后进行调用，但是在视图被渲染之前（Controller方法调用之后）");
   }

   @Override
   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
      // 在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）;
      System.out.println(">>>postHandle>>>>>>>在整个请求结束之后被调用，也就是在DispatcherServlet 渲染了对应的视图之后执行（主要是用于进行资源清理工作）");
   }

   /**
    * @param @param response    设定文件
    * @return void    返回类型
    * @throws
    * @Title: setCrossDomain
    * @Description: TODO(设置跨域问题)
    */
   private void setCrossDomain(HttpServletResponse response) {
      response.addHeader("Access-Control-Allow-Origin", "*");
      response.addHeader("Access-Control-Allow-Methods", "POST,GET");
      response.addHeader("Access-Control-Allow-Credentials", "true");
   }
}

将自定义拦截器添加到拦截器链中

package com.example.springboot.config.config;

import com.example.springboot.config.intercepter.TestIntercepter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

/**
 * 注册bean
 */
@Configuration
public class InterceptorConfig extends WebMvcConfigurerAdapter {

   @Autowired
   private TestIntercepter testInterceptor;


   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(testInterceptor);
   }


}

自定义过滤器

步骤：1、创建一个类实现Filter接口

2、实现Filter接口中的方法，在实现方法中编写自己需求。

3、将自定义Filter注入到FilterRegistrationBean中。

package com.example.springboot.config.filter;

import javax.servlet.*;
import java.io.IOException;

/**
 * @desc 自定义过滤器
 * @Author wangsh
 * @date 2018/4/13 21:58
 */
public class TestFilter implements Filter {

   /**
    * 服务启动,调用初始化方法
    *
    * @param filterConfig
    * @throws ServletException
    */
   @Override
   public void init(FilterConfig filterConfig) throws ServletException {

      System.out.println("服务启动,调用过滤器Filter初始化方法init()..........");
   }


   /**
    * 请求时调用
    *
    * @param servletRequest
    * @param servletResponse
    * @param filterChain
    * @throws IOException
    * @throws ServletException
    */
   @Override
   public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {

      System.out.println("发送请求时调用过滤器Filter的doFilter()方法..........");
      //放行通过
      filterChain.doFilter(servletRequest, servletResponse);
   }

   /**
    * 销毁调用
    */
   @Override
   public void destroy() {

      System.out.println("服务关闭，调用过滤器Filter的销毁方法destroy()..........");
   }
}

自定义Servlet

步骤：1、创建一个类继承HttpServlet类

2、重写servlet中的方法，重写其方法编写自己业务需求。

3、将自定义servlet注入到ServletRegistrationBean中。

/**
 * 自定义servlet
 */
public class ServletTest extends HttpServlet {

    @Override
   protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doPost(req, resp);
    }

    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.setContentType("text/html;charset=utf-8");
        resp.getWriter().write("自定义Servlet");
    }
    
}

自定义监听器

步骤：1、创建一个类实现ServletContextListener接口

2、实现listener中的方法，实现其方法编写自己业务需求。

3、将自定义listener注入到ServletListenerRegistrationBean中。

package com.example.springboot.config.listener;

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

/**
 * @desc 自定义监听器
 * @Author wangsh
 * @date 2018/4/13 22:14
 */
public class TestListener implements ServletContextListener {

   /**
    * 服务启动,在filter init()方法之前调用初始化方法
    *
    * @param servletContextEvent
    */
   @Override
   public void contextInitialized(ServletContextEvent servletContextEvent) {
      System.out.println("服务启动,在filter init()方法之前调用监听器Listener初始化方法contextInitialized().................");
   }

   /**
    * 服务销毁时，在filter destroy()方法之前调用
    *
    * @param servletContextEvent
    */
   @Override
   public void contextDestroyed(ServletContextEvent servletContextEvent) {

      System.out.println("服务销毁时，在filter destroy()方法之前调用监听器Listener销毁方法contextDestroyed().................");
   }
}

将过滤器、拦截器、servlet、监听器交由spring管理

package com.example.springboot.config.config;

import com.example.springboot.config.filter.TestFilter;
import com.example.springboot.config.listener.TestListener;
import com.example.springboot.config.servlet.ServletTest;
import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.ArrayList;
import java.util.List;

/**
 * 注册bean
 */
@Configuration
public class WebConfig {

   /**
    * 注册自定义servlet，设置servlet访问url路径
    *
    * @return
    */
   @Bean
   public ServletRegistrationBean servletRegistrationBean() {

      return new ServletRegistrationBean(new ServletTest(), "/servletTest");
   }


   /**
    * 注册过滤器,有两种方式：
    * 1) 使用 @Component 注解<br>
    * 2) 添加到过滤器链中，此方式适用于使用第三方的过滤器。将过滤器写到 WebConfig 类中，如下：
    */
   @Bean
   public FilterRegistrationBean filterRegistrationBean() {

      FilterRegistrationBean registrationBean = new FilterRegistrationBean();

      TestFilter testFilter = new TestFilter();
      registrationBean.setFilter(testFilter);

      //设置过滤器拦截请求
      List<String> urls = new ArrayList<>();
      urls.add("/*");
      registrationBean.setUrlPatterns(urls);

      return registrationBean;
   }

   /**
    * 注册监听器
    */
   @Bean
   public ServletListenerRegistrationBean servletListenerRegistrationBean() {

      ServletListenerRegistrationBean listenerRegistrationBean = new ServletListenerRegistrationBean();
      listenerRegistrationBean.setListener(new TestListener());

      return listenerRegistrationBean;
   }


}

创建controller类

package com.example.springboot.config.conroller;

import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    @RequestMapping("/hello")
    public String hello(){
        return "hello";
    }

}

创建启动服务类

package com.example.springboot.config;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringbootConfigApplication {

   public static void main(String[] args) {
      SpringApplication.run(SpringbootConfigApplication.class, args);
   }
}

启动服务测试，在浏览器访问http://localhost:8088/hello ，打印日志如下，可以看出经过了拦截器。