springboot-config custom interceptors, filters, servlets, listeners

This article introduces the use of custom interceptors, filters, servlets, and listeners in Spring-Boot.

custom interceptor

Generally, cross-domain processing is handled in the interceptor, allowing cross-domain access to the project. For details on the use of the interceptor, please refer to the official website.

Steps to implement a custom interceptor: 
1. Create a class and implement the HandlerInterceptor interface. 
2. Create a Java class that inherits WebMvcConfigurerAdapter and override the addInterceptors method. 
2. Hand over the custom interceptor to spring management, and then manually add the image to the interceptor chain (add it in the addInterceptors method).

Create an interceptor class

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 custom interceptor, use @Component to let Spring manage its life cycle
 * @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 >>>>>>>>Called before request processing (before Controller method call)" );
      setCrossDomain(response);
      return true ; // Only return true will continue to execute downward, return false to cancel the current request
    }

   @Override
 public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
       // Called after request processing, but before view is rendered (after Controller method call);
 System.out .println ( "> >>postHandle>>>>>>>>Called after the request is processed, but before the view is rendered (after the Controller method call)" );         
   }

   @Override
 public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
       // Called after the entire request ends, that is, after the DispatcherServlet renders the corresponding view (mainly used for resource cleanup) work);
 System.out .println ( ">>> postHandle >>>>>>> is called after the entire request ends, that is, after the DispatcherServlet renders the corresponding view (mainly used for resource cleanup) " );         
   }

   /**
     * @param @param response setting file
     * @return void return type
     * @throws
 * @Title: setCrossDomain
     * @Description: TODO(set cross-domain problem)
 */
 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");
   }
}

Add a custom interceptor to the interceptor chain

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 ，打印日志如下，可以看出经过了拦截器。