农银一面：Filter、Interceptor、Spring AOP 的执行顺序

package javax.servlet;

import java.io.IOException;

public interface Filter {
    default public void init(FilterConfig filterConfig) throws ServletException {}

    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException;

    default public void destroy() {}
}

package com.example.filter;

@WebFilter(urlPatterns = "/*", filterName = "exampleFilter")
public class ExampleFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化逻辑...
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        // 传递给下一个过滤器或目标资源
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
        // 清理资源...
    }
}

@SpringBootApplication
@ServletComponentScan(basePackages = "com.example.filter") // 指定扫描包路径
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

@Configuration
public class FilterConfig {
    @Bean
    public FilterRegistrationBean<ExampleFilter> customFilterRegistration() {
        FilterRegistrationBean<ExampleFilter> registrationBean = new FilterRegistrationBean<>();

        ExampleFilter customFilter = new ExampleFilter();
        registrationBean.setFilter(customFilter);
        registrationBean.addUrlPatterns("/*");
        registrationBean.setOrder(1); // 设置过滤器的执行顺序

        // 添加初始化参数
        registrationBean.addInitParameter("encoding", "UTF-8");
        return registrationBean;
    }
}

@Component
public class ExampleFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {}

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {}
}

/**
 * A HandlerInterceptor gets called before the appropriate HandlerAdapter triggers the execution of the handler itself.
 * This mechanism can be used for a large field of preprocessing aspects, e.g. for authorization checks,
 * or common handler behavior like locale or theme changes.
 * Its main purpose is to allow for factoring out repetitive handler code.
 */
public interface HandlerInterceptor {
    default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        return true;
    }

    default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable ModelAndView modelAndView) throws Exception {
    }

    default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, @Nullable Exception ex) throws Exception {
    }
}

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exceptio {
    // 此处用 processedRequest 接收了用户的 request 请求
    HttpServletRequest processedRequest = request;
    // HandlerExecutionChain 局部变量
    HandlerExecutionChain mappedHandler = null;
    // 标记一下是否解析了文件类型的数据，如果有最终需要清理操作
    boolean multipartRequestParsed = false;

    WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

    try {
        // ModelAndView 局部变量
        ModelAndView mv = null;
        // 处理异常局部变量
        Exception dispatchException = null;

        try {
            /**
             * 判断一下是否是文件上传请求。
             * 如果请求是 POST 请求，并且 Context-Type 是以 multipart/ 开头的就认为是文件上传的请求。
             * 需要注意的是，若是这里被认定为文件上传请求，processedRequest 和 request 将不再指向同一对象
             * 这里返回的是 MultipartHttpServletRequest。
             */
            processedRequest = checkMultipart(request);
            // 两个请求不再相同，进行文件上传标记，用于后续清理操作
            multipartRequestParsed = (processedRequest != request);

            /**
             * 向 HandlerMapping 请求查找 HandlerExecutionChain
             * 找到一个处理器，如果没有找到对应的处理类的话，这里通常会返回404。
             */
            mappedHandler = getHandler(processedRequest);
            // 如果没找到对应的处理器，则抛出异常
            // 相信大家都见过 'No mapping for GET /xxxx'，就是这里抛出的
            if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
            }

            // 根据查找到的 Handler 请求查找能够进行处理的 HandlerAdapter
            HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

            // 判断自上次请求后是否有修改，没有修改直接返回响应
            // 如果是GET请求，且内容没有变化的话，就直接返回
            String method = request.getMethod();
            boolean isGet = "GET".equals(method);
            if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (log.isDebugEnabled()) {
                    log.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
                }
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                    return;
                }
            }

            /**
             * <<<<<<<<<这里到了我们本节内容，拦截器的执行了>>>>>>>>>
             * 这里通过 applyPreHandle 方法，按顺序依次执行 HandlerInterceptor 的 preHandle 方法
             * 可以看到，如果任一 HandlerInterceptor 的 preHandle 方法返回了 false， 则整个拦截器连
             * 不再继续进行处理。
             */
            if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
            }

            /**
             * 通过 HandlerAdapter 执行查找到的 handler
             * 这里真正执行我们 controller 中的方法逻辑，返回一个 ModelAndView
             */
            mv = ha.handle(processedRequest, response, mappedHandler.getHandler());

            /**
             * 检查是否已经开始处理并发请求，如果并发处理已经开始，那么当前的请求线程就可以返回了，而不会等待异步操              * 作的结果，也就不会再执行拦截器 PostHandle 之类的操作了。
             */
            if (asyncManager.isConcurrentHandlingStarted()) {
                return;
            }

            // 如果我们没有设置 viewName，就采用默认的，否则采用我们自己的
            applyDefaultViewName(processedRequest, mv);
            // <<<<<<<<< 这里，通过 applyPostHandle 逆序执行 HandlerInterceptor 的 postHandle 方法>>>>>>>>>
            mappedHandler.applyPostHandle(processedRequest, response, mv);
        }
        catch (Exception ex) {
            dispatchException = ex;
        }
        catch (Throwable err) {
            // As of 4.3, we're processing Errors thrown from handler methods as well,
            // making them available for @ExceptionHandler methods and other scenarios.
            dispatchException = new NestedServletException("Handler dispatch failed", err);
        }
        // 渲染视图填充 Model，如果有异常渲染异常页面
        processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
    }
    catch (Exception ex) {
        // 如果有异常按倒序执行所有 HandlerInterceptor 的 afterCompletion 方法
        triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
    }
    catch (Throwable err) {
        // 如果有异常按倒序执行所有 HandlerInterceptor 的 afterCompletion 方法
        triggerAfterCompletion(processedRequest, response, mappedHandler,
                new NestedServletException("Handler processing failed", err));
    }
    finally {
        if (asyncManager.isConcurrentHandlingStarted()) {
            // Instead of postHandle and afterCompletion
            if (mappedHandler != null) {
                // 倒序执行所有 HandlerInterceptor 的 afterCompletion 方法
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
            }
        }
        else {
            // Clean up any resources used by a multipart request.
            if (multipartRequestParsed) {
                // 如果请求包含文件类型的数据则进行相关清理工作
                cleanupMultipart(processedRequest);
            }
        }
    }
}

public class MyInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 在这里添加拦截逻辑，例如身份验证或日志记录
        System.out.println("MyInterceptor preHandle: " + request.getRequestURI());
        return true; // 返回 true 继续处理请求，返回 false 中断请求
    }

    @Override
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {
        // 在视图渲染之前执行的逻辑
        System.out.println("MyInterceptor postHandle: " + request.getRequestURI());
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 请求完成后的逻辑，比如资源清理
        System.out.println("MyInterceptor afterCompletion: " + request.getRequestURI());
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 添加拦截器，并指定拦截路径模式
        registry.addInterceptor(new MyInterceptor())
                .addPathPatterns("/**") // 拦截所有路径
                .excludePathPatterns("/static/**", "/login", "/register"); // 排除静态资源和某些 URL
    }
}

@SpringBootApplication
@EnableAspectJAutoProxy
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

@Slf4j
@Aspect
@Component
public class AllAdviceAspect {

    // 定义切入点，匹配 service 包下的所有方法
    @Pointcut("execution(* com.example.service..*.*(..))")
    public void serviceLayerExecution() {}

    // 前置通知，在方法调用前打印日志
    @Before("serviceLayerExecution()")
    public void logBefore(JoinPoint joinPoint) {
        log.info("Before method execution: {}", joinPoint.getSignature().getName());
    }

    // 后置返回通知，在方法成功返回后打印日志
    @AfterReturning(pointcut = "serviceLayerExecution()", returning = "result")
    public void logAfterReturning(JoinPoint joinPoint, Object result) {
        log.info("Method returned successfully: {}, Result: {}", joinPoint.getSignature().getName(), result);
    }

    // 抛出异常通知，在方法抛出异常后打印日志
    @AfterThrowing(pointcut = "serviceLayerExecution()", throwing = "ex")
    public void logAfterThrowing(JoinPoint joinPoint, Exception ex) {
        log.error("An exception was thrown in {}: {}", joinPoint.getSignature().getName(), ex.getMessage());
    }

    // 后置最终通知，在方法完成之后打印日志，无论是否抛出异常
    @After("serviceLayerExecution()")
    public void logAfter(JoinPoint joinPoint) {
        log.info("After method execution: {}", joinPoint.getSignature().getName());
    }

    // 环绕通知，包围方法调用，控制方法执行流程
    @Around("serviceLayerExecution()")
    public Object logAround(ProceedingJoinPoint pjp) throws Throwable {
        log.info("Starting around advice for method: {}", pjp.getSignature().getName());

        long start = System.currentTimeMillis();
        try {
            // 执行目标方法
            Object result = pjp.proceed();
            log.info("Method {} took {} ms to execute", pjp.getSignature().getName(), System.currentTimeMillis() - start);
            return result;
        } catch (Throwable e) {
            log.error("Error during method execution: {}", e.getMessage());
            throw e; // 重新抛出异常以便后续处理
        } finally {
            log.info("Ending around advice for method: {}", pjp.getSignature().getName());
        }
    }
}