SpringBoot 面向切面编程

认识 SpringAOP

什么是 AOP

AOP（ Aspect Oriented Program，面向切面编程 ）把业务功能分为核心、非核心两部分。

• 核心业务功能：用户登录、增加数据、删除数据。
• 非核心业务功能：性能统计、日志、事务管理。

在Spring的面向切面编程（ AOP ）思想里，非核心业务功能被定义为切面。核心业务功能和切面功能先被分别进行独立开发，然后把切面功能和核心业务功能 “编织" 在一起，这就是AOP。

未使用AOP的程序如图

使用AOP的程序如图

由此可见，AOP 将那些与业务无关，却为业务模块所共同调用的逻辑封装起来，以便减少系统的重复代码，降低模块间的耦合度，利于未来的拓展和维护。这正是AOP的目的，它是Spring最为重要的功能之一，被广泛使用。

AOP中的概念

切入点（pointcut）：在哪些类、哪些方法上切入。

通知（advice）：在方法前、方法后、方法前后做什么。

切面（aspect）：切面 = 切入点 + 通知。即在什么时机、什么地方、做什么。

织入（weaving）：把切面加入对象，并创建出代理对象的过程。

环绕通知：AOP中最强大、灵活的通知，它集成了前置和后置通知，保留了连接点原有的方法。

用 AOP 方式管理日志

导入依赖

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>

代码解释如下：

@Component：把切面类加入loC容器中，让Spring进行管理。

@Aspect：标记为切面类。

@Before：在切入点开始处切入内容。

@AfterReturmning：在切入点返回(return)内容之后切入内容，可以用来对处理返回值做一些加工处理。

@AfterThrowing：用来处理当切入内容部分抛出异常之后的处理逻辑。

@After：在切入点结尾处切入内容。

@Around：在切入点前后切入内容，并控制何时执行切入点自身的内容。

AOP 日志注解类

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.servlet.http.HttpServletRequest;

/**
 * @author 贾宇光
 * @version 1.0
 * @date 2020/7/11 16:39
 * 
 * 使用@Before在切入点开始处切入内容
 * 使用@AfterReturning在切入点return内容之后切入内容（可以用来对处理返回值做一些加工处理）
 * 使用@AfterThrowing用来处理当切入内容部分抛出异常之后的处理逻辑
 * 使用@After在切入点结尾处切入内容
 * 使用@Around在切入点前后切入内容，并自己控制何时执行切入点自身的内容
 */


/**
 * Description:  使之成为切面类
 */
@Aspect
/**
 * Description: 把切面类加入到IOC容器中
 */
@Component
public class AopLog {
    private Logger logger = LoggerFactory.getLogger(this.getClass());
    //线程局部的变量,解决多线程中相同变量的访问冲突问题。
    ThreadLocal<Long> startTime = new ThreadLocal<>();

    //定义切点
    @Pointcut("execution(public * com.jia..*.*(..))")
    public void aopWebLog() {
    }

    @Before("aopWebLog()")
    public void doBefore(JoinPoint joinPoint) throws Throwable {
        startTime.set(System.currentTimeMillis());
        // 接收到请求，记录请求内容
        ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request = attributes.getRequest();

        // 记录下请求内容
        logger.info("前置通知：执行");
        logger.info("URL : " + request.getRequestURL().toString());
        logger.info("HTTP方法 : " + request.getMethod());
        logger.info("IP地址 : " + request.getRemoteAddr());
        logger.info("类的方法 : " + joinPoint.getSignature().getDeclaringTypeName() + "." + joinPoint.getSignature().getName());
        //logger.info("参数 : " + Arrays.toString(joinPoint.getArgs()));
        logger.info("参数 : " + request.getQueryString());
        logger.info("-----------------------------------------------------------------------------------------------");
    }

    @AfterReturning(pointcut = "aopWebLog()", returning = "retObject")
    public void doAfterReturning(Object retObject) throws Throwable {
        // 处理完请求，返回内容
        logger.info("后置通知：执行");
        logger.info("应答值 : " + retObject);
        logger.info("-----------------------------------------------------------------------------------------------");
    }

    //抛出异常后通知（After throwing advice） ： 在方法抛出异常退出时执行的通知。
    @AfterThrowing(pointcut = "aopWebLog()", throwing = "ex")
    public void addAfterThrowingLogger(JoinPoint joinPoint, Exception ex) {
        logger.error("异常通知：执行 " + " 异常", ex);
        logger.info("-----------------------------------------------------------------------------------------------");
    }

    //在切入点结尾处切入内容
    @After("aopWebLog()")
    public void addAfterLogger(JoinPoint joinPoint) {
        logger.info("最终通知：执行");
        logger.info("费时：" + (System.currentTimeMillis() - startTime.get()));
        logger.info("-----------------------------------------------------------------------------------------------");
    }

}

           切入点表达式的写法：
                关键字：execution(表达式)
                表达式：
                    访问修饰符  返回值  包名.包名.包名...类名.方法名(参数列表)
                标准的表达式写法：
                    public void com.jia.service.impl.AccountServiceImpl.saveAccount()
                访问修饰符可以省略
                    void com.jia.service.impl.AccountServiceImpl.saveAccount()
                返回值可以使用通配符，表示任意返回值
                    * com.jia.service.impl.AccountServiceImpl.saveAccount()
                包名可以使用通配符，表示任意包。但是有几级包，就需要写几个*.
                    * *.*.*.*.AccountServiceImpl.saveAccount())
                包名可以使用..表示当前包及其子包
                    * *..AccountServiceImpl.saveAccount()
                类名和方法名都可以使用*来实现通配
                    * *..*.*()
                参数列表：
                    可以直接写数据类型：
                        基本类型直接写名称           int
                        引用类型写包名.类名的方式   java.lang.String
                    可以使用通配符表示任意类型，但是必须有参数
                    可以使用..表示有无参数均可，有参数可以是任意类型
                全通配写法：
                    * *..*.*(..)

                实际开发中切入点表达式的通常写法：
                    切到业务层实现类下的所有方法
                        * com.jia.service.impl.*.*(..)

编写控制器用于测试

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AopLogController {
    @GetMapping("/aopNormalTest")
    public String aVoid() {
        return "hello aop test";
    }

    @GetMapping("/aopExceptionTest")
    public String aArg(int x) {
        int temp = x / 0;
        return "hello aop test";
    }
}

启动项目测试，控制台输出：

http://localhost:8080/aopNormalTest

http://localhost:8080/aopExceptionTest?x=1