Spring全家桶系列--SpringBoot之AOP详解（下）

5.@AfterReturning

切入点返回结果之后执行,也就是都前置后置环绕都执行完了，这个就执行了

1.    /**
   
2.     * 执行完请求可以做的
   
3.     * @param result
   
4.     * @throws Throwable
   
5.     */
   
6.    @AfterReturning(returning ="result", pointcut ="cutOffPoint()")
   
7.    publicvoid doAfterReturning(Object result)throwsThrowable{
   
8.        logger.info("大家好，我是@AfterReturning，他们都秀完了，该我上场了");
   
9.    }
   

执行结果

应用场景可以用来在订单支付完成之后就行二次的结果验证，重要参数的二次校验，防止在方法执行中的时候参数被修改等等

6.@AfterThrowing

这个是在切入执行报错的时候执行的

1.    // 声明错误e时指定的抛错类型法必会抛出指定类型的异常
   
2.    // 此处将e的类型声明为Throwable，对抛出的异常不加限制
   
3.    @AfterThrowing(throwing ="e",pointcut ="cutOffPoint()")
   
4.    publicvoid doAfterReturning(Throwable e){
   
5.        logger.info("大家好，我是@AfterThrowing，他们犯的错误，我来背锅");
   
6.        logger.info("错误信息"+e.getMessage());
   
7.    }
   

在其他切入内容中随意整个错误出来，制造一个环境。

下面是@AfterThrowing的执行结果

7.AOP用在全局异常处理

定义切入点拦截ResultBean或者PageResultBean

1.    @Pointcut(value ="execution(public com.example.beans.PageResultBean *(..)))")
   
2.    publicvoid handlerPageResultBeanMethod(){
   
3.    }
   
4. 
   
5. 
   
6.    @Pointcut(value ="execution(public com.example.beans.ResultBean *(..)))")
   
7.    publicvoid handlerResultBeanMethod(){
   
8.    }
   

下面是AopController.java

1. package com.example.aop;
   
2. 
   
3. import com.example.beans.PageResultBean;
   
4. import com.example.beans.ResultBean;
   
5. import com.example.entity.UnloginException;
   
6. import com.example.exception.CheckException;
   
7. import org.aspectj.lang.ProceedingJoinPoint;
   
8. import org.aspectj.lang.annotation.Around;
   
9. import org.aspectj.lang.annotation.Aspect;
   
10. import org.aspectj.lang.annotation.Pointcut;
    
11. import org.slf4j.Logger;
    
12. import org.slf4j.LoggerFactory;
    
13. import org.springframework.stereotype.Component;
    
14. 
    
15. /**
    
16. * 使用@Aspect注解将此类定义为切面类
    
17. * 根据晓风轻著的ControllerAOP所修改
    
18. * 晓风轻大佬(很大的佬哥了)：https://xwjie.github.io/
    
19. */
    
20. @Aspect
    
21. @Component
    
22. publicclassAopController{
    
23. 
    
24.    privatestaticfinalLogger logger =LoggerFactory.getLogger(AopController.class);
    
25. 
    
26.    ThreadLocal<ResultBean> resultBeanThreadLocal =newThreadLocal<>();
    
27.    ThreadLocal<PageResultBean<?>> pageResultBeanThreadLocal =newThreadLocal<>();
    
28.    ThreadLocal<Long> start =newThreadLocal<>();
    
29. 
    
30.    /**
    
31.     * 定义一个切点
    
32.     */
    
33.    @Pointcut(value ="execution(public com.example.beans.PageResultBean *(..)))")
    
34.    publicvoid handlerPageResultBeanMethod(){
    
35.    }
    
36. 
    
37. 
    
38.    @Pointcut(value ="execution(public com.example.beans.ResultBean *(..)))")
    
39.    publicvoid handlerResultBeanMethod(){
    
40.    }
    
41. 
    
42.    @Around("handlerPageResultBeanMethod()")
    
43.    publicObject handlerPageResultBeanMethod(ProceedingJoinPoint pjp){
    
44.        start.set(System.currentTimeMillis());
    
45.        try{
    
46.            pageResultBeanThreadLocal.set((PageResultBean<?>)pjp.proceed());
    
47.            logger.info(pjp.getSignature()+" 方法执行耗时:"+(System.currentTimeMillis()- start.get()));
    
48.        }catch(Throwable e){
    
49.            ResultBean<?> resultBean = handlerException(pjp , e);
    
50.            pageResultBeanThreadLocal.set(newPageResultBean<>().setMsg(resultBean.getMsg()).setCode(resultBean.getCode()));
    
51.        }
    
52.        return pageResultBeanThreadLocal.get();
    
53.    }
    
54. 
    
55.    @Around("handlerResultBeanMethod()")
    
56.    publicObject handlerResultBeanMethod(ProceedingJoinPoint pjp){
    
57.        start.set(System.currentTimeMillis());
    
58.        try{
    
59.            resultBeanThreadLocal.set((ResultBean<?>)pjp.proceed());
    
60.            logger.info(pjp.getSignature()+" 方法执行耗时:"+(System.currentTimeMillis()- start.get()));
    
61.        }catch(Throwable e){
    
62.            resultBeanThreadLocal.set(handlerException(pjp , e));
    
63.        }
    
64.        return resultBeanThreadLocal.get();
    
65.    }
    
66.    /**
    
67.     * 封装异常信息，注意区分已知异常（自己抛出的）和未知异常
    
68.     */
    
69.    privateResultBean<?> handlerException(ProceedingJoinPoint pjp,Throwable e){
    
70. 
    
71.        ResultBean<?> result =newPageResultBean();
    
72.        logger.error(pjp.getSignature()+" error ", e);
    
73. 
    
74.        // 已知异常
    
75.        if(e instanceofCheckException){
    
76.            result.setMsg(e.getLocalizedMessage());
    
77.            result.setCode(ResultBean.FAIL);
    
78.        }elseif(e instanceofUnloginException){
    
79.            result.setMsg("Unlogin");
    
80.            result.setCode(ResultBean.NO_LOGIN);
    
81.        }else{
    
82.            result.setMsg(e.toString());
    
83.            result.setCode(ResultBean.FAIL);
    
84.        }
    
85.        return result;
    
86.    }
    
87. }
    

用上面的环绕通知可以对所有返回ResultBean或者PageResultBean的方法进行切入，这样子就不用在业务层去捕捉错误了，只需要去打印自己的info日志。

看下面一段代码

1.    @Transactional
   
2.    @Override
   
3.    publicint insertSelective(Area record){
   
4.        record.setAddress("test");
   
5.        record.setPostalcode(88888);
   
6.        record.setType(3);
   
7.        int i=0;
   
8.        try{
   
9.            i = areaMapper.insertSelective(record);
   
10.        }catch(Exception e){
    
11.            logger.error("AreaServiceImpl insertSelective error："+e.getMessage());
    
12.        }
    
13.        return i;
    
14.    }
    

假如上面的插入操作失败出错了？ 你认为会回滚吗？

答案是：不会。

为什么？

因为你把错误捕捉了，事物没检测到异常就不会回滚。

那么怎么才能回滚呢？

在catch里加throw new RuntimeException().

可是那么多业务方法每个设计修改的操作都加，代码繁琐,怎么进行处理呢？

在这里用到上面的AOP切入处理，错误不用管，直接抛，抛到控制层进行处理，这样的话，接口调用的时候，出错了，接口不会什么都不返回，而是会返回给你错误代码，以及错误信息，便于开发人员查错。

8.以上用的是log4j2的日志处理

先移除springboot自带的log日志处理

在build.gradle中增加

1. configurations {
   
2.    providedRuntime
   
3.    // 去除SpringBoot自带的日志
   
4.    all*.exclude group:'org.springframework.boot',module:'spring-boot-starter-logging'
   
5. }
   
6. ext {
   
7.    springBootVersion ='2.0.1.RELEASE'
   
8. }
   
9. dependencies {
   
10.    compile "org.springframework.boot:spring-boot-starter-log4j2:${springBootVersion}"
    
11. }
    

然后在application.yml中增加

1. #显示mysql执行日志
   
2. logging:
   
3.  level:
   
4.    com:
   
5.      example:
   
6.        dao: debug
   
7.  config: classpath:log4j2-spring.xml
   

log4j2-spring.xml

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
   
3. <!--Configuration后面的status，这个用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，你会看到log4j2内部各种详细输出-->
   
4. <!--monitorInterval：Log4j能够自动检测修改配置 文件和重新配置本身，设置间隔秒数-->
   
5. <configurationstatus="INFO"monitorInterval="30">
   
6.    <!--先定义所有的appender-->
   
7.    <appenders>
   
8.        <!--这个输出控制台的配置-->
   
9.        <consolename="Console"target="SYSTEM_OUT">
   
10.            <!--输出日志的格式-->
    
11.            <PatternLayoutpattern="%highlight{[ %p ] [%-d{yyyy-MM-dd HH:mm:ss}] [ LOGID:%X{logid} ] [%l] %m%n}"/>
    
12.        </console>
    
13. 
    
14.        <!--文件会打印出所有信息，这个log每次运行程序会自动清空，由append属性决定，这个也挺有用的，适合临时测试用-->
    
15.        <Filename="Test"fileName="logs/test.log"append="false">
    
16.            <PatternLayoutpattern="%highlight{[ %p ] %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] [%l] %m%n}"/>
    
17.        </File>
    
18. 
    
19.        <RollingFilename="RollingFileInfo"fileName="logs/log.log"filePattern="logs/info.log.%d{yyyy-MM-dd}">
    
20.            <!-- 只接受level=INFO以上的日志 -->
    
21.            <ThresholdFilterlevel="info"onMatch="ACCEPT"onMismatch="DENY"/>
    
22.            <PatternLayoutpattern="%highlight{[ %p ] [%-d{yyyy-MM-dd HH:mm:ss}] [ LOGID:%X{logid} ] [%l] %m%n}"/>
    
23.            <Policies>
    
24.                <TimeBasedTriggeringPolicymodulate="true"interval="1"/>
    
25.                <SizeBasedTriggeringPolicy/>
    
26.            </Policies>
    
27.        </RollingFile>
    
28. 
    
29.        <RollingFilename="RollingFileError"fileName="logs/error.log"filePattern="logs/error.log.%d{yyyy-MM-dd}">
    
30.            <!-- 只接受level=WARN以上的日志 -->
    
31.            <Filters>
    
32.                <ThresholdFilterlevel="warn"onMatch="ACCEPT"onMismatch="DENY"/>
    
33.            </Filters>
    
34.            <PatternLayoutpattern="%highlight{[ %p ] %-d{yyyy-MM-dd HH:mm:ss} [ %t:%r ] [%l] %m%n}"/>
    
35.            <Policies>
    
36.                <TimeBasedTriggeringPolicymodulate="true"interval="1"/>
    
37.                <SizeBasedTriggeringPolicy/>
    
38.            </Policies>
    
39.        </RollingFile>
    
40. 
    
41.    </appenders>
    
42. 
    
43.    <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
    
44.    <loggers>
    
45.        <!--过滤掉spring和mybatis的一些无用的DEBUG信息-->
    
46.        <loggername="org.springframework"level="INFO"></logger>
    
47.        <loggername="org.mybatis"level="INFO"></logger>
    
48.        <rootlevel="all">
    
49.            <appender-refref="Console"/>
    
50.            <appender-refref="Test"/>
    
51.            <appender-refref="RollingFileInfo"/>
    
52.            <appender-refref="RollingFileError"/>
    
53.        </root>
    
54.    </loggers>
    
55. </configuration>
    

之后在你要打印日志的类中增加

1. privatestaticfinalLogger logger =LoggerFactory.getLogger(你的类名.class);
   
2. 
   
3.    publicstaticvoid main(String[] args){
   
4.        logger.error("error级别日志");
   
5.        logger.warn("warning级别日志");
   
6.        logger.info("info级别日志");
   
7.    }
   

有了日志后就很方便了，在你的方法接收对象时打印下，然后执行了逻辑之后打印下， 出错之后很明确了，就会很少去Debug的，养成多打日志的好习惯，多打印一点info级别的日志，用来在开发环境使用，在上线的时候把打印的最低级别设置为warning，这样你的info级别日志也不会影响到项目的重要Bug的打印

写这个博客的时候我也在同时跑着这个项目，有时候会出现一些错误，例如jar包版本，业务层引用无效，AOP设置不生效等等，也同时在排查解决，如果你遇到了同样的错误，可以去我的GitHub联系我，如小弟有时间或许也能帮到你，谢谢

Github地址：https://github.com/cuifuan