过滤器、拦截器实现、aop的 先后顺序和作用范围

在Spring框架中，过滤器（Filter）、拦截器（Interceptor）和面向切面编程（AOP）都是用于处理请求和处理流程的组件，但它们的作用范围和触发时机有所不同。下面我会解释这三者的先后顺序和作用范围。

过滤器（Filter）

在 Spring Boot 中实现过滤器可以通过实现 javax.servlet.Filter 接口来完成。以下是创建和注册自定义过滤器的步骤：

 

过滤器是Servlet规范中的一部分，它在Spring框架之外，由Servlet容器（如Tomcat）管理。
过滤器在请求到达Servlet之前执行，并且可以在响应返回给客户端之前执行。
过滤器通常用于执行一些跨多个请求和响应的任务，如日志记录、身份验证、编码转换等。
过滤器通过实现javax.servlet.Filter接口来定义。

在 Spring Boot 中实现过滤器可以通过实现 javax.servlet.Filter 接口来完成。以下是创建和注册自定义过滤器的步骤：

1. 创建自定义过滤器

首先，创建一个实现 Filter 接口的类。例如，命名为 MyFilter：

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 java.io.IOException;

public class MyFilter implements Filter {

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 过滤器初始化时执行
        System.out.println("Filter initialized");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 在请求处理之前执行
        System.out.println("Before filtering the request");

        // 继续调用下一个过滤器或目标资源
        chain.doFilter(request, response);

        // 在请求处理之后执行
        System.out.println("After filtering the request");
    }

    @Override
    public void destroy() {
        // 过滤器销毁时执行
        System.out.println("Filter destroyed");
    }
}

2. 注册过滤器

交给IOC容器管理
接下来，在你的 Spring Boot 应用中注册这个过滤器。你可以使用 @Bean 注解在一个配置类中注册它：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class FilterConfig {

    @Bean
    public MyFilter myFilter() {
        return new MyFilter();
    }
}

3. 设置过滤器顺序（可选）

如果你有多个过滤器，并且需要控制它们的执行顺序，可以使用 @Order 注解或在注册时指定顺序：

import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Order(1) // 数字越小，优先级越高
@Component
public class MyFilter implements Filter {
    // 实现方法
}

4. 测试过滤器

启动你的 Spring Boot 应用程序，并尝试发送请求。你应该能够在控制台中看到过滤器的输出。

注意事项
过滤器适用于所有请求，包括静态资源，而拦截器则是基于 Spring MVC 的处理，因此只会拦截经过 Spring MVC 的请求。
过滤器的 doFilter 方法中可以实现请求和响应的修改。

拦截器

首先，创建一个实现 Filter 接口的类。例如，命名为 MyFilter：
拦截器（Interceptor）

拦截器是Spring框架的一部分，它依赖于Spring的AOP模块。
拦截器在Spring的DispatcherServlet中工作，用于拦截请求并在控制器之前或之后执行。
拦截器通常用于记录日志、执行安全检查、数据绑定等操作。
拦截器通过实现org.springframework.web.servlet.HandlerInterceptor接口或扩展org.springframework.web.servlet.handler.HandlerInterceptorAdapter类来定义。

在 Spring Boot 中自定义拦截器可以通过实现 HandlerInterceptor 接口来实现。以下是创建和注册自定义拦截器的步骤：

1. 创建自定义拦截器

首先，创建一个实现 HandlerInterceptor 接口的类。例如，命名为 MyInterceptor：

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

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

@Component
public class MyInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 在请求处理之前执行
        System.out.println("Before handling the request: " + request.getRequestURI());
        return true; // 返回 true 继续处理请求，返回 false 则不再继续
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 在请求处理之后执行
        System.out.println("After handling the request: " + request.getRequestURI());
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 在整个请求结束后执行
        System.out.println("Request completed: " + request.getRequestURI());
    }
}

2. 注册拦截器

接下来，在配置类中注册你的拦截器。你可以创建一个类实现 WebMvcConfigurer 接口，并重写 addInterceptors 方法：

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.WebMvcConfigurer;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Autowired
    private MyInterceptor myInterceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 注册拦截器，并指定拦截的 URL 路径
        registry.addInterceptor(myInterceptor)
                .addPathPatterns("/**") // 拦截所有请求
                .excludePathPatterns("/login", "/logout"); // 排除特定请求
    }
}

3. 测试拦截器

启动你的 Spring Boot 应用程序，并尝试访问受拦截的 URL。你应该能够在控制台中看到拦截器中的输出。

其他注意事项

确保将拦截器标记为 @Component，以便 Spring 能够扫描到它并自动注册。
可以根据需求调整 addPathPatterns 和 excludePathPatterns 方法中的路径，以控制拦截器的适用范围。
这样，你就成功地创建和注册了一个自定义拦截器！如果你有其他问题或需要进一步的帮助，请告诉我。

AOP（面向切面编程）

这个实现步骤已经在我另一篇推文中有详细的说明

aop实现+自定义注解

AOP是Spring框架中的一个重要特性，它允许开发者定义横切关注点（cross-cutting concerns），这些关注点通常与业务逻辑无关，如日志、事务管理等。
AOP通过代理模式在运行时织入切面（Aspect）到目标对象中，从而在不修改业务逻辑代码的情况下增强功能。
AOP的切点（Pointcut）可以定义在方法执行之前、之后或异常抛出时触发。
AOP通过实现org.aspectj.lang.annotation.Aspect接口并使用@Aspect、@Pointcut、@Before、@After、@AfterReturning、@AfterThrowing等注解来定义。

首先，请求到达Servlet容器，触发过滤器（Filter）。
然后，请求被DispatcherServlet捕获，触发拦截器（Interceptor）。
接着，如果定义了AOP切面，它们会在相应的时机（如方法执行前或后）被触发。
最后，请求到达控制器（Controller），执行相应的业务逻辑。
请注意，这个顺序可能因具体的配置和使用的技术而有所不同。在实际应用中，建议根据项目的具体需求来合理配置和使用这些组件。

请求的执行顺序是：请求进入容器 > 进入过滤器 > 进入 Servlet > 进入拦截器 > 执行控制器（Controller），如下图所示：