spring的过滤器,拦截器,aop,advice等执行顺序

最新推荐文章于 2025-04-15 15:12:33 发布

Maven_su

最新推荐文章于 2025-04-15 15:12:33 发布

阅读量1.9k

点赞数 6

分类专栏： spring 文章标签： spring java springboot

本文链接：https://blog.youkuaiyun.com/qq_41132384/article/details/129090953

版权

spring 专栏收录该内容

5 篇文章

订阅专栏

文章通过示例代码展示了SpringBoot应用中过滤器、拦截器、AOP切面和全局异常处理的执行顺序。在给定的配置下，当请求到达时，会先执行过滤器，然后是拦截器的preHandle，接着是AOP的before和around，如果方法正常执行则会经过afterReturning，若有异常则会触发afterThrowing，最后是拦截器的afterCompletion和全局异常处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

有时候这几个技术都用的话会对业务造成影响;

名词解释

过滤器; public class LoginFilter implements Filter
拦截器; public class MyInterceptor implements HandlerInterceptor
aop; 切面编程. @Aspect实现
advice; @ControllerAdvice实现. 用于全局异常. 或者修改requestBody和 responseBody的值

springboot版本

本次是springboot 2.5.1版本.
不排除其他版本变动的可能性

省流版

结论

粗略看
细看; 里面还有aop中 @Around, @AfterThrowing等的执行顺序

具体代码

controller


package com.example.boottest.controller;

import com.example.boottest.domain.StudentDomain;
import com.example.boottest.exec.order.LogAction;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("/test")
@Slf4j
public class TestController {

    /**
     *
     */
    @PostMapping("/LogAction")
    @LogAction
    public String methodDo(@RequestBody StudentDomain studentDomain) {
        log.info("真正的方法执行");
        //int ii = 1/0;

        return "1111";
    }

}

domain

package com.example.boottest.domain;

import lombok.Data;

/**
 * @author: riyueming
 * @date: 2023/2/17
 * @description:
 */
@Data
public class StudentDomain {
    String name;
}

过滤器


package com.example.boottest.exec.order;

import lombok.extern.slf4j.Slf4j;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

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;

/**
 * 登录过滤器
 *
 */

@Component
@Slf4j
@Order(9)
public class LoginFilter implements Filter {

    /**
     * 用户登录filter
     *
     * @param request
     * @param response
     * @param filterChain
     * @throws IOException
     * @throws ServletException
     */
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain) throws IOException, ServletException {
        log.info("filter--------doFilter前");
        filterChain.doFilter(request, response);
        log.info("filter--------doFilter后");
    }



    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        //TODO
    }

    @Override
    public void destroy() {
        //TODO
    }

}

拦截器


package com.example.boottest.exec.order;

import lombok.extern.slf4j.Slf4j;
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;

/**
 * 自定义拦截器类
 */
@Component
@Slf4j
public class MyInterceptor implements HandlerInterceptor {// 实现HandlerInterceptor接口
	/**
	 * 访问控制器方法前执行
	 */
	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		log.info("Interceptor-----preHandle");
		return true;
	}

	/**
	 * 访问控制器方法后执行
	 */
	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {

		log.info("Interceptor-----postHandle");
	}

	/**
	 * postHandle方法执行完成后执行，一般用于释放资源
	 */
	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		log.info("Interceptor-----afterCompletion");

	}
}











// 配置类

package com.example.boottest.exec.order;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * Web配置类
 */
@Configuration
public class WebConfig implements WebMvcConfigurer {

	@Resource
	MyInterceptor myInterceptor;
	/**
	 * 添加Web项目的拦截器
	 */
	@Override
	public void addInterceptors(InterceptorRegistry registry) {
		// 对所有访问路径，都通过MyInterceptor类型的拦截器进行拦截
		registry.addInterceptor(myInterceptor).addPathPatterns("/**")
		.excludePathPatterns("/", "/login", "/index.html", "/user/login", "/css/**", "/images/**", "/js/**", "/fonts/**");
		 //放行登录页，登陆操作，静态资源
	}
}

aop切面

//注解 
package com.example.boottest.exec.order;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author: siyu
 * @date: 2021/5/24
 * @description: 用于记录操作日志
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface LogAction {

    String operation() default "";
}





//切面

package com.example.boottest.exec.order;

import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.AfterReturning;
import org.aspectj.lang.annotation.AfterThrowing;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;


/**
 * @author: riyueming
 * @date: 2021/5/25
 * @description: 系统操作日志切面
 */
@Aspect
@Component
@Slf4j
public class LogAspect {


    @Pointcut("@annotation(LogAction)")
    public void pointcut() {
    }


    @Before(value = "pointcut()")
    public void before(JoinPoint joinPoint) {
        log.info("aop----before");
    }


    @Around("pointcut()")
    public Object around(ProceedingJoinPoint point) throws Throwable {
        log.info("aop----around--前");
        Object proceed = point.proceed();
        log.info("aop----around--后");
        return proceed;
    }

    /**
     * 处理完请求后执行
     *
     * @param joinPoint 切点
     */
    @AfterReturning(pointcut = "@annotation(logAction)", returning = "jsonResult")
    public void doAfterReturning(JoinPoint joinPoint, LogAction logAction, Object jsonResult) {
        log.info("aop----AfterReturning");
    }

    /**
     * 拦截异常操作
     *
     * @param joinPoint 切点
     * @param e         异常
     */
    @AfterThrowing(pointcut = "@annotation(logAction)", throwing = "e")
    public void doAfterThrowing(JoinPoint joinPoint, LogAction logAction, Exception e) {
        log.info("aop----AfterThrowing");
    }


    @After(value = "@annotation(logAction)")
    public void after(JoinPoint joinPoint, LogAction logAction) {
        log.info("aop----after");
    }



}

advice

全局异常拦截

package com.example.boottest.exec.order;

import com.example.boottest.common.ResultJson;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
 * 控制器相关处理
 *
 * @author hushi
 */
@ControllerAdvice
@Slf4j
public class ControllerAdviceWrap {


    @Autowired
    public ControllerAdviceWrap() {
    }



    /**
     * 全局异常处理
     *
     * @param cause 错误对象
     * @return
     */
    @ResponseBody
    @ExceptionHandler(Exception.class)
    ResultJson resolveException(Exception cause) {

        log.info("ControllerAdvice--------ExceptionHandler");

        log.error(cause.getMessage(), cause);

        return ResultJson.buildFail(cause);
    }
}

requestBody 读取前拦截


package com.example.boottest.exec.order;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.MethodParameter;
import org.springframework.http.HttpInputMessage;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.RequestBodyAdviceAdapter;

import java.io.IOException;
import java.lang.reflect.Type;

@Slf4j
@ControllerAdvice
public class DecryptRequestBodyAdvice extends RequestBodyAdviceAdapter {


    @Override
    public boolean supports(MethodParameter methodParameter, Type targetType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @SneakyThrows
    @Override
    public HttpInputMessage beforeBodyRead(HttpInputMessage inputMessage, MethodParameter parameter, Type targetType, Class<?
            extends HttpMessageConverter<?>> converterType) throws IOException {

        //必须是@RequestBody 才能进来
        log.info("ControllerAdvice------RequestBodyAdvice");

        return inputMessage;
    }
}

responseBody 返回前拦截

package com.example.boottest.exec.order;

import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

@Slf4j
@ControllerAdvice
public class EncryptResponseBodyAdvice implements ResponseBodyAdvice<Object> {



    @Override
    public boolean supports(MethodParameter returnType, Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }

    @SneakyThrows
    @Override
    public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType,
                                  Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {

        log.info("ControllerAdvice------ResponseBodyAdvice");

        return body;
    }

}

启动类

别忘了加上@EnableAspectJAutoProxy 开启aop


package com.example.boottest;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
import org.springframework.scheduling.annotation.EnableAsync;

import java.io.IOException;

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

}