spring AOP使用和注意事项

最新推荐文章于 2023-02-26 12:34:21 发布
最新推荐文章于 2023-02-26 12:34:21 发布
阅读量732 收藏
点赞数
分类专栏： SpringMVC/boot/cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/w8y56f/article/details/104383534
版权

spring AOP使用和注意事项

本项目研究spring的AOP

官方参考文档

https://docs.spring.io/spring/docs/5.2.3.RELEASE/spring-framework-reference/core.html#aop

项目说明

（本文是一个测试项目的 README.md 文件，如果找不到代码，那就是没有提供代码，懒得上传GitHub）

例子1

  • com.wyf.test.aopspring.aophello.example01.AopTest：说明不能不启动spring容器进行测试
  • com.wyf.test.aopspring.aophello.example01.Guess：猜测了@Before、@After、@AfterReturning、@AfterThrowing、@Around 这些注解的拦截先后顺序，提供了伪代码
  • com.wyf.test.aopspring.aophello.example01.LogAspect01：例子1，说明了Aspect、Pointcut、@Before、@After、@AfterReturning、@AfterThrowing、@Around 的用法，以及这些注解拦截的先后顺序
  • com.wyf.test.aopspring.aophello.example01.LogAspect01SpringTest：是spring test的测试类，启动spring容器并测试

例子2

  • com.wyf.test.aopspring.aophello.example02.LogAspect02：演示了Pointcut的写法。

例子3

  • com.wyf.test.aopspring.aophello.example03.LogAspect03SpringTest：演示public、private、protected、default、static的方法能否得到拦截（除了private和static都可以）

例子4

  • com.wyf.test.aopspring.aophello.example04.LogAspect04SpringTest：演示如果类是final的，是否会被拦截（结果是spring容器无法启动，因为启动时需要产生子类的bean）

例子5

  • com.wyf.test.aopspring.aophello.example05.LogAspect05：演示Pointcut表达式的多种写法

例子99

  • com.wyf.test.aopspring.aophello.example99.ControllerAspect：演示了常用的拦截Controller的入参的aop的写法，详细参考附录

使用AOP步骤

  1. 添加依赖
<!-- AOP，Springboot默认未引入，需要自行引入-->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-aop</artifactId>
</dependency>
  1. 定义 aspect、pointcut、advice
  • 新建一个 aspect（切面）的java类，即用 @Aspect 注解的类；aspect 类要让 spring 容器能发现，所以要增加 @Component 注解
  • 在 aspect 类里定义 pointcut（切入点），即新增一个方法用 @Pointcut 注解，它是一个定义要拦截的规则。可以定义多个@Pointcut
  • 在 aspect 类里定义 advice（通知），即Aspect类里定义怎么拦截的方法（如 @Before、@After、@Around、@AfterReturning、@AfterThrowing 所注释的方法就叫做advice方法）

使用AOP中的注意实现和细节

  • @Before、@After、@AfterReturning、@AfterThrowing、@Around 这些注解的拦截先后顺序、异常情况时的细节，参考附录 com.wyf.test.aopspring.aophello.example01.Guess
  • 常见的pointcut的写法，见附录com.wyf.test.aopspring.aophello.example02.LogAspect02
  • 如果目标类是final的（Calculator），是否会被拦截? 不能。结果导致spring容器无法启动，因为启动时需要产生目标类的子类的bean用于动态代理。需要注释掉以免导致其他spring test启动不了。
  • 静态方法无法使用aop? 是的，因为需要动态代理而静态方法。
  • protected、default、private方法能否使用aop?
    protected和default可以，private无法调用，但是通过反射强制调用私有方法，表名是不行的。使用反射调用public、protected、default是可以触发aop拦截的
  • aspect可以写多个Pointcut吗? 可以
  • 我们可能会遇到将Pointcut表达式直接写在advice的注解里（即@Before…），或者让advice的注解引用@Pointcut的方法。参考附录com.wyf.test.aopspring.aophello.example05.LogAspect05

补充：AOP的概念

  • 切面（ASPECT）：横切关注点被模块化的特殊对象。即，它是一个类。 ====>即 @Aspect 所注解的类
  • 通知（Advice）：切面必须要完成的工作。即，它是类中的一个方法。 ====>即 @Aspect 所注解的类 里， @Before、@After、@Around、@AfterReturning、@AfterThrowing 所注解的方法
  • 目标（Target）：被通知对象。 ===>即类似 Calculator02_00 这些类的对象
  • 代理（Proxy）：向目标对象应用通知之后创建的对象。 =====> 即 Calculator02_00 这些类，会产生子类作为它的代理对象
  • 切入点（PointCut）：切面通知执行的“地点”的定义。 ===>即 @Aspect 所注解的类 里， @Pointcut 所注解的方法
  • 连接点（JointPoint）：与切入点匹配的执行点。

注意aop的拦截，跟javax.servlet.Filter或者spring的interceptor是不一样的，它们需要http请求才能拦截，而aop的拦截并不需要aop，只要spring容器启动起来，普通的junit测试的调用即可拦截

附录

附录1：com.wyf.test.aopspring.aophello.example02.LogAspect02
@Aspect
@Component
public class LogAspect02 {

    /**
     * 具体的某个类，的某个方法
     */
    @Pointcut("execution(* com.wyf.test.aopspring.aophello.example02.method.Calculator02_00.div2(..))")
    public void pointCutOneMethod() {
    }

    /**
     * 具体的某个类，的所有方法
     */
    @Pointcut("execution(* com.wyf.test.aopspring.aophello.example02.sub.Calculator02_01.*(..))")
    public void pointCutOneClassAllMethod() {
    }

    /**
     * 某个包下的所有类，不包括子目录，的所有方法
     */
    @Pointcut("execution(* com.wyf.test.aopspring.aophello.example02.sub2.*.*(..))")
    public void pointCutAllClassExceptSubDir() {
    }

    /**
     * 某个包下的所有类，包括子目录，的所有方法
     */
    @Pointcut("execution(* com.wyf.test.aopspring.aophello.example02.sub2..*.*(..))")
    public void pointCutPackageIncludeSubDir() {
    }

    /**
     * 任何目录下的，类上有@RestController或@Controller，方法带有@GetMapping、@PostMapping
     * 、@DeleteMapping、@PutMapping、@RequestMapping任一注解的则拦截（用于拦截Controller方法）
     * <p>
     * 注意：仅方法有注解，类上没注解的，不拦截
     */
    @Pointcut("!execution(* com.wyf.test.aopspring.aophello.example02.HealthCheckController.*(..)) &&" +
            "((@within(org.springframework.web.bind.annotation.RestController) || @within(org.springframework.stereotype.Controller)) " +
            "&& (@annotation(org.springframework.web.bind.annotation.GetMapping) " +
            "|| @annotation(org.springframework.web.bind.annotation.PostMapping)" +
            "|| @annotation(org.springframework.web.bind.annotation.DeleteMapping)" +
            "|| @annotation(org.springframework.web.bind.annotation.PutMapping)" +
            "|| @annotation(org.springframework.web.bind.annotation.RequestMapping)))")
    public void pointCutControllerMethod3() {
    }

    /**
     * 拦截用指定注解的方法（这个注解单独写在类上面，并不会自动实现该类所有方法被拦截）
     */
    @Pointcut("@annotation(com.wyf.test.aopspring.aophello.example02.MyAnnotaion)")
    public void pointCutSomeAnnotation() {

    }


    @Before("pointCutControllerMethod3()")
    public void before(JoinPoint joinPoint) {
        System.out.println("target:" + joinPoint.getTarget().getClass().getName() + "#" + joinPoint.getSignature().getName());
    }

}
附录2：com.wyf.test.aopspring.aophello.example01.Guess
/**
 * 这是一个猜测advice的源码的类，为什么@Before、@After、@AfterReturning、@AfterThrowing、@Around 会有那样的执行顺序? 下面是猜测
 *
 * @author Stone
 * @version V1.0.0
 * @date 2020/2/14
 */
public class Guess {
    /**
     * <pre>
     * 【建议直接看伪代码更加简单!!!】
     * 1、当调用目标方法时，不是直接调用真正的实现，而是其代理方法
     * 2、代理方法最终会调用这里的 entrance 方法
     * 3、调用 @Around 所修饰的方法
     *      3.1 先执行proceed()之前的代码 `around before`
     *      3.2 执行proceed()方法
     *          3.2.1 执行 @Before （有定义@Before的话）
     *          3.2.2 执行实际的目标方法
     *          3.2.3 执行 @After（有的话），无论目标方法是否有抛出异常在finally里，所以一定会执行
     *      3.3 proceed()是否抛出异常
     *          3.3.1 否
     *              3.3.1.1 执行 proceed()之后的代码 `around after`
     *              3.3.1.2 执行 @AfterReturning（有的话）。【结束】
     *          3.3.2 是
     *              3.3.2.1 不执行proceed()之后的代码 `around after`
     *              3.3.2.1 执行 @AfterThrowing，并继续往上抛出异常。【结束】
     * </pre>
     */
    void entrance() {
        boolean isException = false;
        Throwable throwable = null;
        try {
            // 当然不是直接调用，估计是通过反射进行调用，这里为了简化写成直接调用
            around();
        } catch (Throwable t) {
            isException = true;
            throwable = t;
        }

        if (!isException) {
            // 执行 @AfterReturning（有的话）
        } else {
            // 执行 @AfterThrowing（有的话）
            throw new RuntimeException(throwable);
        }
    }

    /**
     * 这是 @Around 所修饰的方法
     */
    void around() {
        System.out.println("around before");
        proceed();
        System.out.println("around after");
    }


    void proceed() {
        // 执行 @Before（有的话）
        try {
            // 执行实际的目标方法
        } finally {
            // 执行 @After（有的话）
        }
    }

}
附录3：com.wyf.test.aopspring.aophello.example05.LogAspect05
@Aspect
@Component
public class LogAspect05 {
    /**
     * 指定具体的某个类，
     */
    @Pointcut("execution(* com.wyf.test.aopspring.aophello.example05.Calculator05_1.*(..))")
    public void pointCut() {
    }


    /**
     * 可以引用@Pointcut的方法，也可以直接将表达式写在字串里
     *
     * @param joinPoint
     */
    @Before("pointCut()")
    public void before(JoinPoint joinPoint) {
        System.out.println("@Before,target:" + joinPoint.getTarget().getClass().getName() + "#" + joinPoint.getSignature().getName());
    }

    /**
     * 可以引用@Pointcut的方法，也可以直接将表达式写在字串里
     *
     * @param joinPoint
     */
    @After("execution(* com.wyf.test.aopspring.aophello.example05.Calculator05_2.*(..))")
    public void after(JoinPoint joinPoint) {
        System.out.println("@Before,target:" + joinPoint.getTarget().getClass().getName() + "#" + joinPoint.getSignature().getName());
    }
}
附录4：com.wyf.test.aopspring.aophello.example99.ControllerAspect
package com.wyf.test.aopspring.aophello.example99;

import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.MDC;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.UUID;

/**
 * 拦截控制器的方法
 *
 * @author Strone
 * @version V1.0.0
 * @date 2020/2/14
 */
@Aspect
@Component
@Slf4j
public class ControllerAspect {
    /**
     * 响应头的名字，值是请求的唯一ID；同时也是日志的全局ID，这么设置：%X{RequestId}，
     * 例如：<pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%X{RequestId}] [%thread] %-5level %logger{36} - %msg%n</pattern>
     */
    private static final String REQUEST_ID = "RequestId";

    /**
     * 格式化JSON的工具。线程安全。
     */
    private static ObjectMapper objectMapper = new ObjectMapper();

    static {
        // 如果json字符串中有新增的字段，但实体类中不存在的该字段，不报错。默认true
        objectMapper.configure(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES, false);
        // 日期格式指定格式
        objectMapper.setDateFormat(new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"));
    }


    /**
     * 任何目录下的，类上有@RestController或@Controller，方法带有@GetMapping、@PostMapping
     * 、@DeleteMapping、@PutMapping、@RequestMapping任一注解的则拦截，除HealthCheckController外，除HealthCheckController外（用于拦截Controller方法）
     * <p>
     * 注意：仅方法有注解，类上没注解的，不拦截
     */
    @Pointcut("!execution(* com.wyf.test.aopspring.aophello.example02.HealthCheckController.*(..)) &&" +
            "((@within(org.springframework.web.bind.annotation.RestController) || @within(org.springframework.stereotype.Controller)) " +
            "&& (@annotation(org.springframework.web.bind.annotation.GetMapping) " +
            "|| @annotation(org.springframework.web.bind.annotation.PostMapping)" +
            "|| @annotation(org.springframework.web.bind.annotation.DeleteMapping)" +
            "|| @annotation(org.springframework.web.bind.annotation.PutMapping)" +
            "|| @annotation(org.springframework.web.bind.annotation.RequestMapping)))")
    public void pointCutControllerMethod() {
    }

    /**
     * 拦截请求，打印请求的参数，方便DEBUG
     *
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around(value = "pointCutControllerMethod()")
    public Object aroundRestApi(ProceedingJoinPoint joinPoint) throws Throwable {
        long beginTime = System.currentTimeMillis();

        // 防止非http请求方式进行调用导致异常
        HttpServletRequest req = null;
        HttpServletResponse resp = null;
        String requestId = null;
        try {
            ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
            req = attributes.getRequest();
            resp = attributes.getResponse();

            // 将该请求ID写入响应头，方便查找到该条日志
            requestId = UUID.randomUUID().toString();
            resp.setHeader(REQUEST_ID, requestId);
        } catch (Exception e) {
        }


        // 请求执行
        boolean isSuccess = true;
        try {
            // 每个请求拥有唯一的请求ID
            MDC.put(REQUEST_ID, requestId);

            // 执行实际方法
            return joinPoint.proceed();
        } catch (Throwable e) {
            isSuccess = false;
            // 需要注意以下@ControllerAdvice或@RestControllerAdvice是否能囊括这里抛出的异常并将其封装
            // （实际测试似乎不需要加@Order默认就能包揽这里抛出的异常
            throw e;
        } finally {
            MDC.clear();

            Long endTime = System.currentTimeMillis();
            log.info("IP:{}, RequestId:{}, Method:{}, ContentType:{}, Url:{}, Param:{}, Time:{}, Status:{}",
                    req == null ? null : req.getRemoteAddr(),
                    requestId,
                    req == null ? null : req.getMethod(),
                    req.getContentType(),
                    req == null ? null : req.getRequestURL(),
                    getRequestParams(joinPoint),
                    // getRequestParams(req),// 这种方式对于application/json，请求体里的参数无法获取
                    endTime - beginTime,
                    isSuccess ? "success" : "fail");

        }
    }


    /**
     * 获取请求参数
     *
     * @param joinPoint 上下文
     * @return 请求参数
     */
    private String getRequestParams(JoinPoint joinPoint) {
        try {
            Object[] args = joinPoint.getArgs();
            Map<String, Object> parameters = new LinkedHashMap<>();
            Method method = ((MethodSignature) joinPoint.getSignature()).getMethod();
            // 将自己写在Controller里的HttpServletRequest和HttpServletResponse等排除掉。常用的是这些，要排除掉以免某些类无法json化导致异常
            for (int i = 0; i < method.getParameters().length; i++) {
                if (args[i] instanceof ServletRequest || args[i] instanceof ServletResponse) {
                    continue;
                }
                parameters.put(method.getParameters()[i].getName(), args[i]);
            }
            return objectMapper.writeValueAsString(parameters);
        } catch (Exception e) {
            log.error("OBTAIN_PARAM_ERROR", e);
            return "OBTAIN_PARAM_ERROR";
        }
    }

    /**
     * 获取请求参数。弊端：对于application/json，请求体里的参数无法获取。不予采用
     *
     * @param req
     * @return
     */
    @Deprecated
    private String getRequestParams(HttpServletRequest req) {
        try {
            if (req == null) {
                return null;
            }
            return objectMapper.writeValueAsString(req.getParameterMap());
        } catch (Exception e) {
            log.error("OBTAIN_PARAM_ERROR", e);
            return "OBTAIN_PARAM_ERROR";
        }
    }
}
石头wang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring AOP使用注意点
凌晨港口
03-22 2514
Spring中的AOP面向切面编程结合IOC容器，是编程的灵活性大大提高。结合支持通配符和注解等等一系列方便切入的特性，真香！我这里分享几个需要注意的地方，以及以我的经验总结几条原则。 Spring AOP简介 Spring AOP 基于动态代理，为以下两种： 基于接口，使用JDK Dynamic Proxy 非接口，使用CGLIB自动生成子类实现代理 AOP作为一种编程模型，还有着很多实现。...
spring aop两种配置方式
09-03
-- 定义切面bean，这里假设它包含beforeMethod()方法 --> <bean id="myAspectBean" class="com.bjsxt.aop.MyAspectBean"/> ``` 注意事项1. 使用注解配置时，需要在Spring配置文件中启用自动扫描并开启基于注解的AOP...
使用SpringAOP中的注意事项
banbei19991010的博客
02-19 529
SpringAOP通过Aspectj方式创建(开发时比较常用) 第一：jar包 第二：创建自定义类和方法(对配置要求高) // schema-based方式必须实现throwsAdvice接口,必须自己写方法,且必须叫 afterThrowing AspectJ方式:自己定义方法,在applicationContext中配置引用异常类和方法; 如果想要输出异常信息必须配置&lt;aop:after...
spring aop 注意事项
mygodccl的博客
06-14 220
[list] [*][b]1.需要被aop拦截的类, 要么没有实现接口. 如果实现了接口, 则只有接口中声明的方法才能被拦截[/b] [*][b]2.aop类和被拦截类都必须是spring管理的bean[/b] [/list]...
Spring AOP 使用注意事项
Be_With_I的博客
12-26 259
使用 一个类 作为切面 加上注解 @Aspectj 方法上 加上通知的注解 @Before 等 。。。 注解后边的匹配具体方法的，表达式：通过表达式找到方法，然后就是 在配置文件中加入aop:aspectj-autoproxy</aop:aspectj-autoproxy> 让方法匹配后自动生成代理对象 JointPoint 这个对象中封装了要调用的方法，的所有信息，名称...
Spring框架Aop开发注意点
c17315377559的博客
09-28 272
一、配置文件开发注意点 【1】切入点表达式 within表达式（粗粒度表达式） within(包名.类名） execution表达式（细粒度表达式，常用） execution(返回值类型 包名.类名.方法名(参数类型,参数类型…)) 常用符号： .*：当前包下的任意类/当前类中的任意方法 ..*：当前包下以及子包下的所有类 *：任意返回值 ..：接收任意参数 【2】五...
spring aop使用注意事项
最新发布
10-14
在使用Spring AOP时，需要注意以下几点： 1. AOP只能应用于Spring管理的Bean，因此需要将目标对象交给Spring容器管理。 2. AOP默认使用JDK动态代理，如果目标对象没有实现接口，则需要使用CGLIB代理。 3. AOP切面类...
jar包---Spring AOP 还需.rar
07-16
7. **使用注意事项**：虽然Spring AOP简化了代码，但过度使用可能导致系统过于复杂，增加理解和调试的难度。合理规划切面和通知的使用，避免不必要的性能开销。 这个压缩包可能包含了Spring框架、Spring AOP相关的...
Spring AOP定义AfterReturning增加实例分析
08-25
Spring AOP 定义 AfterReturning 增加实例分析 Spring AOP (面向方面编程) 是 Spring 框架中的一种编程...通过本文，读者可以了解 Spring AOP 中的 AfterReturning 增加实例分析，并且掌握相关的使用技巧和注意事项。
使用Spring AOP 需要注意的问题
jeff_fangji的专栏
09-30 5397
》如果是使用Jdk动态代理实现Spring AOP，Spring容器的getBean方法获得的对象是不能转型成该Bean定义的Class类型。 如下定义的id为calculatorService的bean，class类型是CalculatorServiceImpl，该类实现了ICalculatorService接口并且我们给这个Bean定义了使用Jdk动态代理实现的AOP。 使用Sprin
spring aop 的使用及注意事项(部分)
城中行
07-26 639
第一步在配置文件或注解中配置aspectj开启标识 第二步导入需要的jar包,或在maven中添加配置 其他版本可在https://mvnrepository.com/自行查询 代码如下: @Aspect @Component public class Aop { @Pointcut("execution(public * demo.AOP.TestAop.*(....
spring aop注意事项
zhaozhenzuo的专栏
06-06 1683
spring aop注意事项
spring-boot配置aop及注意事项
u010882325的博客
03-06 995
使用spring-boot配置aop会变得十分简单，只需引入一个starter即可，但是也有需要注意的地方，以下记录一下踩的坑。 首先是配置方式： maven依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <ver
使用Spring AOP应该注意的一个小细节
u013958151的博客
12-19 339
如果切入点切入的是实现类需要在spring的配置文件中加上标签，代表代理的实现类而非基于接口代理 也就是Proxy和Enhancer的区别
SpringAop使用注意事项
LuckDD的博客
02-26 173
【代码】SpringAop使用注意事项。
AOP注意事项
weixin_40401730的博客
10-16 157
Spring AOP切面编程，在程序员aop切面方法（before、around、after）等，已经完成了报文的赋值，取得的入参是已经赋值的入参！
aop使用注意事项以及一些异常
KingZhCool的专栏
09-12 234
Cannot proxy target class because CGLIB2 is not available. Add CGLIB to the class path or specify proxy interfaces --问题解决：缺少jar包 cglib-2.1.3.jar Instantiation of bean failed; nested exception i...
Spring AOP源码分析（八）SpringAOP要注意的地方
乒乓狂魔的专栏
10-01 203
[size=medium]SpringAOP要注意的地方有很多，下面就举一个，之后想到了再列出来： （1）SpringAOP对于最外层的函数只拦截public方法，不拦截protected和private方法，另外不会对最外层的public方法内部调用的其他方法也进行拦截，即只停留于代理对象所调用的方法。如下案例： B类有两个public方法，foo1（）和foo2(),foo1内部调用了fo...
SpringAOP使用注意三点
笨小孩的博客
09-14 710
1.不要把业务逻辑代码放入aop中，应该放入非功能性的需求，比如 权限控制 缓存控制 事物控制审计日志 性能监控 分布式追踪  异常处理 2.无法拦截static final private方法 3.无法拦截内部方法调用
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值