springboot的拦截器，监听器，过滤器，servlet的使用（三大组件）

目录

• [1. 拦截器](#1. 拦截器)
• • [1.1 简介](#1.1 简介)
  • [1.2 使用](#1.2 使用)
• [2. 监听器](#2. 监听器)
• • [2.1 简介](#2.1 简介)
  • [2.2 使用](#2.2 使用)
• [3. 过滤器](#3. 过滤器)
• • [3.1 简介](#3.1 简介)
  • [3.2 使用](#3.2 使用)
• [4. servlet](#4. servlet)
• • [4.1 简介](#4.1 简介)
  • [4.2 使用](#4.2 使用)
• [5. 例子](#5. 例子)
• [6. 心得](#6. 心得)

1. 拦截器

1.1 简介

Spring Boot 拦截器（Interceptor）是Spring MVC中用于在请求处理流程中执行某些操作的组件。它们允许你在请求到达控制器之前或响应发送回客户端之后插入自定义行为。这可以包括日志记录、身份验证、请求数据转换等。

实现一个Spring Boot拦截器

要创建一个Spring Boot拦截器，你需要遵循以下步骤：

1. 创建一个拦截器类：实现HandlerInterceptor接口，并重写其方法（如preHandle、postHandle、afterCompletion）。
2. 注册拦截器：在你的配置类中，通过实现WebMvcConfigurer接口并重写addInterceptors方法来注册你的拦截器。

1.2 使用

实现一下

首先创建一个拦截器类

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

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

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        System.out.println("前置拦截");
        return true;
    }
    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        System.out.println("后置拦截");
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        System.out.println("最终拦截");
    }

}

注册拦截器

@Configuration
public class MyConfig implements WebMvcConfigurer {
    // 拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new MyInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns("/hello");
    }
}

说明一下：

• addInterceptor函数（实际上是一个方法，因为它被定义在InterceptorRegistry接口中，并由WebMvcConfigurer的实现类在配置时调用）的作用是将自定义的拦截器（HandlerInterceptor）注册到Spring MVC的拦截器链中。
• 通过addPathPatterns方法指定哪些请求路径应该被该拦截器拦截。
• 通过 excludePathPatterns 方法指定些请求路径应该被排除

在拦截器中可以写一些跳转或者添加一下属性到Model中

比如：

2. 监听器

2.1 简介

在Spring Boot中，通常我们更多地依赖于Spring的事件监听机制（ApplicationListener）和Spring MVC的拦截器（Interceptor）来处理请求前后的逻辑，而不是传统的Servlet监听器（如ServletContextListener、HttpSessionListener等）。这是因为Spring Boot和Spring MVC提供了更高级别的抽象和更丰富的功能集，使得开发者能够更专注于业务逻辑的实现。

然而，如果你确实需要在Spring Boot应用中使用Servlet监听器，你仍然可以这样做，因为Spring Boot是建立在Servlet API之上的。

步骤：

1. 创建Servlet监听器
2. 注册Servlet监听器

2.2 使用

创建Servlet监听器

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

public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // 应用程序启动时执行的初始化操作
        System.out.println("Listener->应用程序已启动");
        // 加载配置文件、初始化数据库连接池等
        // ...
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // 应用程序关闭时执行的清理操作
        System.out.println("Listener->应用程序即将关闭");
        // 关闭数据库连接池、释放资源等
        // ...
    }
}

注册：

@Configuration
public class MyConfig implements WebMvcConfigurer {
@Bean
    public ServletListenerRegistrationBean myListener(){
        ServletListenerRegistrationBean<MyListener> registrationBean = new
                ServletListenerRegistrationBean(new MyListener());
        return registrationBean;
    }
}

3. 过滤器

3.1 简介

在Spring Boot中，过滤器（Filter）是一种能够拦截请求和响应的组件，它可以在请求到达控制器之前或响应发送给客户端之后执行特定的代码。这使得过滤器非常适合用于处理日志记录、身份验证、请求预处理和响应后处理等任务。
Spring Boot 提供了几种方式来注册和使用过滤器，以下是一些常见的方法：

1. 使用 @WebFilter 注解和 ServletRegistrationBean

   对于基于 Servlet 的应用，可以通过 @WebFilter 注解来定义一个过滤器，并使用 ServletRegistrationBean 在 Spring Boot 应用程序中注册这个过滤器。但是，请注意，这种方法依赖于 Servlet 容器对 @WebFilter 的支持，而且它更适用于传统的 Servlet 应用程序而不是纯粹的 Spring Boot 应用程序。

2. 实现 Filter 接口并注册为 Bean

   在 Spring Boot 应用程序中，更常见的做法是实现 javax.servlet.Filter 接口，然后直接在配置类中将其注册为一个 Bean。这种方法使得过滤器的注册更加灵活，并且可以更容易地集成到 Spring 的依赖注入体系中。

3.2 使用

第二种方法

public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        System.out.println("filter正在被创建");
    }

    @Override
    public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
//        servletRequest.getRequestDispatcher("/myFilter").forward(servletRequest,servletResponse);
        filterChain.doFilter(servletRequest, servletResponse); // 将请求传递给下一个过滤器或目标资源  
    }

    @Override
    public void destroy() {
        System.out.println("filter被销毁中。。。");
    }
}

注册函数：

 @Bean
 public FilterRegistrationBean myFilter(){
     FilterRegistrationBean registrationBean = new FilterRegistrationBean();
     registrationBean.setFilter(new MyFilter());
     registrationBean.setUrlPatterns(Arrays.asList("/hello","/myServlet"));
     return registrationBean;
 }

4. servlet

4.1 简介

在Spring Boot中，虽然Spring Boot的自动配置和嵌入式服务器（如Tomcat, Jetty, 或Undertow）极大地简化了传统Servlet应用程序的部署和配置，但Spring Boot仍然支持Servlet API的使用。你可以直接在Spring Boot应用中注册和使用Servlet，这为你提供了灵活性来集成需要Servlet API的旧系统或库。

4.2 使用

1. 创建servlet

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


public class MyServlet implements Servlet {


    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        System.out.println("servlet正在创建");
    }

    @Override
    public ServletConfig getServletConfig() {
        return null;
    }

    @Override
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("正在服务！！！");
        System.out.println("走你！！！");
        servletRequest.getRequestDispatcher("/myServlet").forward(servletRequest,servletResponse);	// 跳转到/myServlet
    }

    @Override
    public String getServletInfo() {
        return null;
    }

    @Override
    public void destroy() {
        System.out.println("servlet被销毁");
    }
}

2. 注册

@Bean
public ServletRegistrationBean myServlet(){
    ServletRegistrationBean registrationBean = new ServletRegistrationBean( new MyServlet(),"/hello");
    return registrationBean;
}

5. 例子

登录的拦截器：在进行登录之前，判断是否有session，没有就跳转到登录界面
写一个拦截器

import org.springframework.web.servlet.HandlerInterceptor;

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


public class LoginInterceptor implements HandlerInterceptor {

    // 没有session 就跳转
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 在请求处理之前进行调用（Controller方法调用之前）
        HttpSession session = request.getSession();
        if(session.getAttribute("user") == null){
            response.sendRedirect(request.getContextPath() + "/header");
            return false;
        }
        return true;
    }
}

注册：

@Configuration
@MapperScan("cn.tx.springboot.mapper")
public class TxMvcConfig implements WebMvcConfigurer {
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        List<String> excludePatterns = new ArrayList<String>();
        // 这几个请求不拦截
        excludePatterns.add("/css/**");
        excludePatterns.add("/images/**");
        excludePatterns.add("/toLogin");
        excludePatterns.add("/header");
        excludePatterns.add("/login");
        // 防止收不到js
        excludePatterns.add("/webjars/**");
        // 添加
        registry.addInterceptor(new LoginInterceptor())
                .addPathPatterns("/**")
                .excludePathPatterns(excludePatterns);
    }
}

6. 心得