Aop注解：@Before 具体的逻辑 @AfterRunning @After @Around 顺序

最新推荐文章于 2024-04-25 06:00:00 发布

天海华兮

最新推荐文章于 2024-04-25 06:00:00 发布

阅读量6.3k

点赞数

分类专栏： spring 文章标签： aop before after around

原文链接：https://mp.weixin.qq.com/s/iuhjtVXed0mmcpFAOZOMVQ

版权

spring 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

定义切点

1. 编写切点代码

@Aspect
@Component
public class LogAspect {

    ThreadLocal<Long> startTime = new ThreadLocal<>();

    // 第一个*代表返回类型不限
    // 第二个*代表所有类
    // 第三个*代表所有方法
    // (..) 代表参数不限
    @Pointcut("execution(public * com.example.demoxin2.blog.controller.*.*(..))")
    @Order(2)
    public void pointCut() {
    }

    @Before(value = "pointCut()")
    public void before(JoinPoint joinPoint) {

        System.out.println("方法执行前执行......before");
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        System.out.println("请求来源： =》" + request.getRemoteAddr());
        System.out.println("请求URL：" + request.getRequestURL().toString());
        System.out.println("请求方式：" + request.getMethod());
        System.out.println("响应方法：" + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        System.out.println("请求参数：" + Arrays.toString(joinPoint.getArgs()));

        startTime.set(System.currentTimeMillis());

        System.out.println("方法执行前执行......before，执行完毕了");
    }


    @AfterReturning(pointcut = "pointCut()", returning = "rst")
    public void afterRunning(String rst) {
        if (startTime.get() == null) {
            startTime.set(System.currentTimeMillis());
        }
        System.out.println("方法执行完执行...afterRunning");
        System.out.println("耗时（毫秒）：" + (System.currentTimeMillis() - startTime.get()));
        System.out.println("返回数据：{}" + rst);

        System.out.println("方法执行完执行...afterRunning，执行完毕了");
    }

    @After(value = "pointCut()")
    public void after() {
        System.out.println("方法之后执行...after.");
    }
    
    @AfterThrowing("within(com.example.demoxin2.blog.controller.*Controller)")
    public void afterThrowing() {
        System.out.println("异常出现之后...afterThrowing");
    }

    //private static final Logger logger = LoggerFactory.getLogger(LogAspect.class);

}

2. 编写controller测试

@RestController
public class TestController {
    @RequestMapping("/achieve")
    public String achieve() {
        System.out.println("方法执行-----------");
        return "1";
    }

    //@RedisCache
    @RequestMapping("/sendEmail")
    public String sendEmailToAuthor(@RequestParam String content){
        System.out.println("测试执行次数");
        return "2";
    }
}

无环绕通知

3. 无环绕通知：测试结果

方法执行前执行......before
请求来源： =》0:0:0:0:0:0:0:1
请求URL：http://localhost:8080/achieve
请求方式：GET
响应方法：com.example.demoxin2.blog.controller.TestController.achieve
请求参数：[]
方法执行前执行......before，执行完毕了

方法执行-----------

方法执行完执行...afterRunning
耗时（毫秒）：25377
返回数据：{}1
方法执行完执行...afterRunning

方法之后执行...after.

before
具体的方法
afterRunning
after

如若遇到异常

    @RequestMapping("/achieve")
    public String achieve() throws Exception {
        System.out.println("方法执行-----------");
        if (1 == 1) {
            throw new Exception("1");
        }
        return "1";
    }

before
方法执行-----------
异常出现之后...afterThrowing
方法之后执行...after.

before
具体方法，执行出现异常，不报错
执行 AfterThrowing
执行after

环绕通知

4. 增加环绕通知


    // 定义需要匹配的切点表达式，同时需要匹配参数
    @Around("pointCut() && args(arg)")
    public String around(ProceedingJoinPoint pjp, String arg) throws Throwable {
        System.out.println("参数args的值为:" + arg);
        System.out.println("方法环绕start...around");
        String result = null;
        try {
            //添加上自定义信息
            result = pjp.proceed().toString() + "aop String";
            System.out.println("添加上自定义的信息，result为:" + result);
        } catch (Throwable e) {
            e.printStackTrace();
        }
        System.out.println("方法环绕end...around");
        return result;
    }
    
    
        /*@Pointcut("@annotation(com.example.demoxin2.blog.annotation.RedisCache)")
    @Order(1)
    public void annotationPoint(){};*/

5. 环绕通知测试

http://localhost:8080/sendEmail?content=222

参数args的值为:222
方法环绕start...around

方法执行前执行......before
请求来源： =》0:0:0:0:0:0:0:1
请求URL：http://localhost:8080/sendEmail
请求方式：GET
响应方法：com.example.demoxin2.blog.controller.TestController.sendEmailToAuthor
请求参数：[222]
方法执行前执行......before，执行完毕了

测试执行次数

方法执行完执行...afterRunning
耗时（毫秒）：25929
返回数据：{}2
方法执行完执行...afterRunning，执行完毕了

方法之后执行...after.

添加上自定义的信息，result为:2aop String
方法环绕end...around

Around 的proceed方法前
before
执行逻辑
afterRunning
after
Around 的proceed方法后
1. 最终返回结果会加上aop string

6. 使用注解拦截

public @interface RedisCache {
}

    @Pointcut("@annotation(com.example.demoxin2.blog.annotation.RedisCache)")
    //@Order(1)
    public void annotationPoint(){};

    @Around("annotationPoint() && args(arg)")

	//改造后，想被环绕通知拦截，必须加上注解
	@RedisCache
    @RequestMapping("/sendEmail")

7. 环绕通知多次调用 proceed

        return pjp.proceed().toString();

参数args的值为:222
方法环绕start...around

方法执行前执行......before

测试执行次数

方法执行完执行...afterRunning

方法之后执行...after.

添加上自定义的信息，result为:2aop String
方法环绕end...around
// 此时返回结果为 2aop String，不进行返回。

方法执行前执行......before

测试执行次数

方法执行完执行...afterRunning

方法之后执行...after.
//返回 2

Around 的proceed方法前
before
执行逻辑
afterRunning
after
Around 的proceed方法后，结果加上aop string。
before 。==新的逻辑开始了
执行逻辑
afterRunning
after
return pjp.proceed().toString(); 结果就是controller的返回2

Spring 注解 @After,@Around,@Before 的执行顺序是？

https://mp.weixin.qq.com/s/iuhjtVXed0mmcpFAOZOMVQ

AOP中有@Before，@After，@Around，@AfterRunning注解等等。

切点

首先上下自己的代码，定义了切点的定义


@Aspect
@Component
public class LogApsect {
 
    private static final Logger logger = LoggerFactory.getLogger(LogApsect.class);
 
    ThreadLocal<Long> startTime = new ThreadLocal<>();
 
    // 第一个*代表返回类型不限
    // 第二个*代表所有类
    // 第三个*代表所有方法
    // (..) 代表参数不限
    @Pointcut("execution(public * com.lmx.blog.controller.*.*(..))")
    @Order(2)
	//.*.*(..) 所有类的所有方法 参数不限
    //定义切点，切这个controller下的 所有类
    public void pointCut(){};
 
    //定义第二个切点。就是 使用了这个注解的切点
    @Pointcut("@annotation(com.lmx.blog.annotation.RedisCache)")
    @Order(1) // Order 代表优先级，数字越小优先级越高
    public void annoationPoint(){};
 
    //之前执行，如果满足这个两个切点的任意个，就执行
    @Before(value = "annoationPoint() || pointCut()")
    public void before(JoinPoint joinPoint){
        System.out.println("方法执行前执行......before");
        
        //上下文holder拿到 所有的请求参数
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        //从参数中，拿到request
        HttpServletRequest request = attributes.getRequest();
        
        logger.info("<=====================================================");
        //请求地址
        logger.info("请求来源： =》" + request.getRemoteAddr());
        //请求的所有url
        logger.info("请求URL：" + request.getRequestURL().toString());
        logger.info("请求方式：" + request.getMethod());
        
        //原生的 响应类型 和 方法
        logger.info("响应方法：" + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        //请求参数
        logger.info("请求参数：" + Arrays.toString(joinPoint.getArgs()));
        logger.info("------------------------------------------------------");
        //请求开始的时间。ThreadLocal
        startTime.set(System.currentTimeMillis());
    }
 
    //符合切点，参数匹配
    // 定义需要匹配的切点表达式，同时必须 是有参数的接口
    @Around("pointCut() && args(arg)")
    public Response around(ProceedingJoinPoint pjp,String arg) throws Throwable{
        //方法
        System.out.println("name:" + arg);
        //打印
        System.out.println("方法环绕start...around");
        
        String result = null;
        try{
            //执行 proceed
            result = pjp.proceed().toString() + "aop String";
            //打印
            System.out.println(result);
        }catch (Throwable e){
            e.printStackTrace();
        }
        System.out.println("方法环绕end...around");
        //结果进行返回
        return (Response) pjp.proceed();
    }
 
    //切 这个包下，所有类名字，后缀是controller的
    @After("within(com.lmx.blog.controller.*Controller)")
    public void after(){
        System.out.println("方法之后执行...after.");
    }
 
  	//after注解：切点，返回的是rst
    @AfterReturning(pointcut="pointCut()",returning = "rst")
    public void afterRunning(Response rst){
        //如果开始时间为null，这里设置开始时间
        if(startTime.get() == null){
            startTime.set(System.currentTimeMillis());
        }
        //执行完毕
        System.out.println("方法执行完执行...afterRunning");
        //耗时多久
        logger.info("耗时（毫秒）：" +  (System.currentTimeMillis() - startTime.get()));
        //返回的数据
        logger.info("返回数据：{}", rst);
        logger.info("==========================================>");
    }
 
   	//异常之后的拦截
    @AfterThrowing("within(com.lmx.blog.controller.*Controller)")
    public void afterThrowing(){
        System.out.println("异常出现之后...afterThrowing");
    }
 
 
}

proceed 
英 /prəˈsiːd/  美 /proʊˈsiːd/  全球(美国)  
简明 牛津 新牛津  韦氏  柯林斯 例句  百科
v. 开始行动，开展；<正式>继续做（或从事、进行）；（完成其他事后）继续做某事；<正式>行进，前往；起诉某人；来自，出自
n. （某个事件或活动的）收入，收益

@Before，@After，@Around注解的区别大家可以自行百度下。

总之就是@Around可以实现@Before和@After的功能，并且只需要在一个方法中就可以实现。

不经过@Around逻辑

首先我们来测试一个方法用于获取数据库一条记录的


@RequestMapping("/achieve")
public Response achieve(){
    System.out.println("方法执行-----------");
    return Response.ok(articleDetailSercice.getPrimaryKeyById(1L));
}

以下是控制台打印的日志

方法执行前执行......before  //1 先执行前置通知
2018-11-23 16:31:59.795 [http-nio-8888-exec-9] INFO  c.l.blog.config.LogApsect - <=====================================================
    
LogApsect - 请求来源：=》0:0:0:0:0:0:0:1
LogApsect - 请求URL：http://localhost:8888/user/achieve
LogApsect - 请求方式：GET
LogApsect - 响应方法：com.lmx.blog.controller.UserController.achieve
LogApsect - 请求参数：[]
LogApsect - ------------------------------------------------------

//2 执行具体的方法
方法执行-----------
2018-11-23 16:31:59.806 [http-nio-8888-exec-9] DEBUG c.l.b.m.A.selectPrimaryKey - ==>  Preparing: select * from article_detail where id = ? 
selectPrimaryKey - ==> Parameters: 1(Long)
selectPrimaryKey - <==      Total: 1

//3 执行@After注解
方法之后执行...after.

//4 执行 afterRunning
方法执行完执行...afterRunning
LogApsect - 耗时（毫秒）：27
LogApsect - 返回数据：com.lmx.blog.common.Response@8675ce5
LogApsect - ==========================================>

可以看到，因为没有匹配@Around的规则，所以没有进行环绕通知。

（PS：我定义的环绕通知意思是要符合是 controller 包下的方法并且方法必须带有参数，
而上述方法没有参数，所以只走了@before和@after方法，不符合@Around的匹配逻辑）

执行@Around逻辑

我们再试一下另一个带有参数的方法

@RedisCache(type = Response.class)
@RequestMapping("/sendEmail")
public Response sendEmailToAuthor(String content){
    System.out.println("测试执行次数");
    return Response.ok(true);
}

以下是该部分代码的console打印

//1 先执行了 Around 方法，的 proceed 前面的方法
name:第二封邮件呢
方法环绕start...around

//2 在执行before
方法执行前执行......before
2018-11-23 16:34:55.347 [http-nio-8888-exec-2] INFO  c.l.blog.config.LogApsect - <=====================================================
LogApsect - 请求来源：=》0:0:0:0:0:0:0:1
LogApsect - 请求URL：http://localhost:8888/user/sendEmail
LogApsect - 请求方式：GET
LogApsect - 响应方法：com.lmx.blog.controller.UserController.sendEmailToAuthor
LogApsect - 请求参数：[第二封邮件呢]
LogApsect - ------------------------------------------------------

//3 具体执行方法的逻辑
测试执行次数
com.lmx.blog.common.Response@6d17f2fdaop String

//4 在执行 Around 方法，的 proceed 后面的方法
方法环绕end...around

//1，around 的 proceed 前面的代码。
//2，before。 
//3，具体的方法。
//4，around 的 proceed 后面的代码。

//5， 又执行before。
//6，具体的方法。
//7，after。
//8，AfterReturning。

方法执行前执行......before
2018-11-23 16:34:55.349 [http-nio-8888-exec-2] INFO  c.l.blog.config.LogApsect - <=====================================================
LogApsect - 请求来源：=》0:0:0:0:0:0:0:1
LogApsect - 请求URL：http://localhost:8888/user/sendEmail
LogApsect - 请求方式：GET
LogApsect - 响应方法：com.lmx.blog.controller.UserController.sendEmailToAuthor
LogApsect - 请求参数：[第二封邮件呢]
LogApsect - ------------------------------------------------------

//6 又执行 具体的逻辑
测试执行次数

//7 执行after。
方法之后执行...after.

//8 afterRunning
方法执行完执行...afterRunning
2018-11-23 16:34:55.350 [http-nio-8888-exec-2] INFO  c.l.blog.config.LogApsect - 耗时（毫秒）：0
LogApsect - 返回数据：com.lmx.blog.common.Response@79f85428
LogApsect - ==========================================>

显而易见，该方法符合 @Around 环绕通知的匹配规则，所以进入了@Around的逻辑，但是发现了问题，所有的方法都被执行了2次，不管是切面层还是方法层。（有人估计要问我不是用的自定义注解 @RedisCache(type = Response.class) 么。为什么会符合 @Around的匹配规则呢，这个等会在下面说）

我们分析日志的打印顺序可以得出，在执行环绕方法时候，会优先进入 @Around下的方法。@Around的方法再贴一下代码。


// 定义需要匹配的切点表达式，同时需要匹配参数
@Around("pointCut() && args(arg)")
public Response around(ProceedingJoinPoint pjp,String arg) throws Throwable{
    System.out.println("name:" + arg);
    System.out.println("方法环绕start...around");
    String result = null;
    try{
        result = pjp.proceed().toString() + "aop String";
        System.out.println(result);
    }catch (Throwable e){
        e.printStackTrace();
    }
    System.out.println("方法环绕end...around");
    return (Response) pjp.proceed();
}

打印了前两行代码以后，转而去执行了 @Before方法，是因为中途触发了 ProceedingJoinPoint.proceed() 方法。

这个方法的作用是执行被代理的方法，

也就是说执行了这个方法之后会执行我们controller的方法，(错误，先before，在执行自己的controller)
而后执行 @before，@after，
然后回到@Around执行未执行的方法，最后执行 @afterRunning，
- 如果有异常抛出能执行 @AfterThrowing

也就是说环绕的执行顺序是

@Around→

@Before→

@After→

@Around执行 ProceedingJoinPoint.proceed() 之后的操作→

@AfterRunning(如果有异常→@AfterThrowing)

而我们上述的日志相当于把上述结果执行了2遍，根本原因在于 ProceedingJoinPoint.proceed() 这个方法，

可以发现在@Around 方法中我们使用了2次这个方法，然而每次调用这个方法时都会走一次
- @Before→
- @After→
- @Around执行 ProceedingJoinPoint.proceed() 之后的操作→
- @AfterRunning(如果有异常→@AfterThrowing)。

@Around 只用一次 proceed方法

因此问题是出现在这里。所以更改@Around部分的代码即可解决该问题。更改之后的代码如下：


@Around("pointCut() && args(arg)")
public Response around(ProceedingJoinPoint pjp,String arg) throws Throwable{
    System.out.println("name:" + arg);
    System.out.println("方法环绕start...around");
    String result = null;
    Object object = pjp.proceed();
    try{
        result = object.toString() + "aop String";
        System.out.println(result);
    }catch (Throwable e){
        e.printStackTrace();
    }
    System.out.println("方法环绕end...around");
    return (Response) object;
}

更改代码之后的运行结果


//1，先执行around 前半段
name:第二封邮件呢
方法环绕start...around

//2，在执行before
方法执行前执行......before
2018-11-23 16:52:14.315 [http-nio-8888-exec-4] INFO  c.l.blog.config.LogApsect - <=====================================================
LogApsect - 请求来源：=》0:0:0:0:0:0:0:1
LogApsect - 请求URL：http://localhost:8888/user/sendEmail
LogApsect - 请求方式：GET
LogApsect - 响应方法：com.lmx.blog.controller.UserController.sendEmailToAuthor
LogApsect - 请求参数：[第二封邮件呢]
LogApsect - ------------------------------------------------------

//3，在执行具体的方法
测试执行次数
com.lmx.blog.common.Response@1b1c76afaop String

//4，在执行 around的 后半段
方法环绕end...around

//5,在执行 after
方法之后执行...after.

//6，最终执行 afterRunning
方法执行完执行...afterRunning
2018-11-23 16:52:14.316 [http-nio-8888-exec-4] INFO  c.l.blog.config.LogApsect - 耗时（毫秒）：0
2018-11-23 16:52:14.316 [http-nio-8888-exec-4] INFO  c.l.blog.config.LogApsect - 返回数据：com.lmx.blog.common.Response@1b1c76af
2018-11-23 16:52:14.316 [http-nio-8888-exec-4] INFO  c.l.blog.config.LogApsect - ==========================================>


//1，around前。

//2，before。
//3，具体方法。

//4，around后。

//5，after。
//6，afterRunning

切面切某个controller

回到上述未解决的问题，为什么我定义了切面的另一个注解还可以进入@Around方法呢？

因为我们的方法仍然在controller下，因此满足该需求，如果我们定义了controller包下的某个controller才有用。

例如：

@Pointcut("execution(public * com.lmx.blog.controller.UserController.*(..))")

而如果我们刚才定义的方法是写在 TestController 之下的，那么就不符合 @Around方法的匹配规则了，也不符合@before和@after的注解规则，因此不会匹配任何一个规则，如果需要匹配特定的方法，可以用自定义的注解形式或者特性controller下的方法

①：特性的注解形式


@Pointcut("@annotation(com.lmx.blog.annotation.RedisCache)")
@Order(1) // Order 代表优先级，数字越小优先级越高
public void annoationPoint(){};

然后在所需要的方法上加入 @RedisCache注解，在@Before，@After，@Around等方法上添加该切点的方法名（“annoationPoint()”），如果有多个注解需要匹配则用 || 隔开

②：指定controller或者指定controller下的方法


@Pointcut("execution(public * com.lmx.blog.controller.UserController.*(..))")
@Order(2)
public void pointCut(){};

该部分代码是指定了 com.lmx.blog.controller包下的UserController下的所有方法。

第一个*代表的是返回类型不限

第二个*代表的是该controller下的所有方法，(…)代表的是参数不限

总结

上例子，把Response改为String可测试

当方法符合切点规则不符合环绕通知的规则时候，执行的顺序如下

@Before→@After→@AfterRunning(如果有异常→@AfterThrowing)

最终测试的是：@Before→具体的逻辑→@AfterRunning→@After
所以作者的说法应该是错误的

当方法符合切点规则并且符合环绕通知的规则时候，执行的顺序如下

@Around→@Before→@Around→@After执行 ProceedingJoinPoint.proceed() 之后的操作→@AfterRunning(如果有异常→@AfterThrowing)

真实的执行如下

@Around process前代码
@Before
具体的逻辑
@AfterRunning(如果有异常→@AfterThrowing)
@After
@Around process之后（上面在返回值上统一加了 aop String ，这种处理通用吧）