目录

1. 面向切面编程

2. AOP概念

3. AOP的实现

​4. Spring 对AOP支持

4.1 支持@Aspect

4.2 声明一个切面

4.3 声明一个切入点

4.4 声明通知

5. 用AOP实现日志拦截

6. 思考

参考

1. 面向切面编程

定义：面向切面编程（AOP，Aspect Oriented Programming）是通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。

作用：利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

主要功能：日志记录、性能统计、安全控制、事务处理、异常处理等。

总结：面向切面编程是希望能够将通用需求功能从不相关的类当中分离出来，能够使得很多类共享一个行为，一旦发生变化，不必修改很多类，而只是修改这个行为即可。

AOP通过提供另一种思考程序结构的方式来补充了面向对象编程（OOP）。OOP中模块化的基本单元是类(class)，而AOP中模块化的基本单元是切面(aspect)。

Spring的关键组件之一是AOP框架。虽然Spring IOC容器不依赖于AOP，意味着如果你不想使用AOP，则可以不使用AOP，但AOP补充了Spring IOC以提供一个非常强大的中间件解决方案。

2. AOP概念

• 切面（aspect）：在AOP中，切面一般使用@Aspect注解来标识。
• 连接点（Join Point）：在Spring AOP，一个连接点总是代表一次方法的执行。
• 通知（Advice）：在连接点执行的动作。
• 切入点（Pointcout）：说明如何匹配到连接点。
• 引入（Introduction）：为现有类型声明额外的方法和属性。
• 目标对象（Target Object）：由一个或者多个切面建议的对象，也被称为“建议对象”，由于Spring AOP是通过动态代理来实现的，这个对象永远是一个代理对象。
• AOP代理（AOP proxy）：一个被AOP框架创建的对象，用于实现切面约定（通知方法的执行等）。在Spring framework中，一个AOP代理是一个JDK动态代理或者CGLIB代理。
• 织入（Weaving）：连接切面和目标对象或类型创建代理对象的过程。它能在编译时（例如使用AspectJ编译器）、加载时或者运行时完成。Spring AOP与其他的纯Java AOP框架一样是在运行时进行织入的。

Spring AOP包括以下类型的通知：

• 前置通知(Before advice)：在连接点之前运行，但不能阻止到连接点的流程继续执行（除非抛出异常）
• 返回通知(After returning advice)：在连接点正常完成后运行的通知（例如，方法返回没有抛出异常）
• 异常通知(After thorwing advice)：如果方法抛出异常退出需要执行的通知
• 后置通知(After (finally) Advice)：无论连接点是正常或者异常退出，都会执行该通知
• 环绕通知(Around advice)：围绕连接点的通知，例如方法的调用。环绕通知能在方法的调用之前和调用之后自定义行为。它还可以选择方法是继续执行或者去缩短方法的执行通过返回自己的值或者抛出异常。

 

3. AOP的实现

AOP的两种实现方式：静态织入（AspectJ实现）和动态代理（Spring AOP实现）

AspectJ是一个采用Java实现的AOP框架，它能够对代码进行编译（在编译期进行），让代码具有AspectJ的AOP功能

Spring AOP实现：

通过动态代理技术实现的，而动态代理是基于反射设计的。

 Spring AOP采用了两种混合的实现方式：JDK动态代理和CGLib动态代理。

• JDK动态代理：Spring AOP的首选方法。每当目标对象实现一个接口时，就会使用JDK动态代理。目标对象必须实现接口。
• CGLIB：如果目标对象没有实现接口，则可以使用CGLIB代理。 

4. Spring 对AOP支持

Spring可以使用两种方式来实现AOP：基于注解式配置和基于XML配置

下面介绍基于注解配置的形式

4.1 支持@Aspect

如果是Spring framework，需要使用aspectjweaver.jar包，然后创建我们自己的AppConfig，如下，并加上@EnableAspectJAutoProxy注解开启AOP代理自动配置(Spring Boot默认是开启的，则不需要增加配置)，如下：

@Configuration
@EnableAspectJAutoProxy
public class AppConfig {

}

4.2 声明一个切面

@Aspect //告诉Spring 这是一个切面
@Component  //交给Spring容器管理
public class MyAspect {

}

可以使用@Aspect来定义一个类作为切面，但是这样，该类并不会自动被Spring加载，还是需要加上@Component注解

4.3 声明一个切入点

一个切入点的生命包含两个部分：一个包含名称和任何参数的签名和一个切入点的表达式，这个表达式确定了我们对哪些方法的执行感兴趣。

我们以拦截Controller层中的MyController中的test方法为例子，代码如下：

@RestController
@RequestMapping("/my")
public class MyController {

    @GetMapping("/test")
    public void test() {
        System.out.println("test 方法");
    }
}

下面定义一个名为controller的切入点，该切入点与上述的test方法相匹配，切入点需要用@Pointcut注解来标注，如下：

  //表达式
  @Pointcut("execution (public * com.yc.springboot.controller.MyController.test())")
  public void controller(){}; //签名

切入点表达式的格式如下：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern?name-pattern(param-pattern) throws-pattern?)

execution(方法修饰符(可选) 返回类型 类路径 方法名 参数 异常模式（可选）)

AspectJ描述符如下：

AspectJ描述符	描述
arg()	限制连接点匹配参数为指定类型的执行方法
@args()	限制连接点匹配参数由指定注解标注的执行方法
execution()	用于匹配是连接点的执行方法
this()	限制连接点匹配的AOP代理的bean引用为指定类型的类
target	限制连接点匹配目标对象为指定类型的类
@target()	限制连接点匹配特定的执行对象，这些对象对应的类要具有指定类型的注解
within()	限制连接点匹配指定的类型
@within()	限制连接点匹配指定注解所标注的类型
@annotationn	限定匹配带有指定注解的连接点

常用的主要是：execution()

AspectJ类型匹配的通配符

通配符	含义
*	匹配任何数量字符
..	匹配任何数量字符的重复
+	匹配指定类型的子类型；仅能用于后缀放在类型模式后面

常用的匹配规则

表达式	内容
execution(public * *(..))	匹配所有public方法
execution(* set*(..))	匹配所有方法名开头为set的方法
execution(* com.xyz.service.AccountService.*(..))	匹配AccountService下的所有方法
execution(* com.xyz.service.*.*(..))	匹配service包下的所有方法
execution(* com.xyz.service..*.*(..))	匹配service包或其子包下的所有方法
@annotation(org.springframework.transaction.annotation.Transactional)	匹配所有打了@Transactional注解的方法
bean(*Service)	匹配命名后缀为Service的类的方法

4.4 声明通知

通知与切点表达式相关联，并且在与切点匹配的方法之前、之后或者前后执行。

在3当中已经对各类通知绍了，这里就不详细展开了，下面直接罗列了各种通知的声明，用于拦截MyController中的各个方法

@Aspect //告诉Spring 这是一个切面
@Component  //告诉Spring容器需要管理该对象
public class MyAspect {

    //通过规则确定哪些方法是需要增强的
    @Pointcut("execution (public * com.yc.springboot.controller.MyController.*(..))")
    public void controller() {
    }

    //前置通知
    @Before("controller()")
    public void before(JoinPoint joinPoint) {
        System.out.println("before advice");
    }

    //返回通知
    @AfterReturning(
            pointcut = "controller()",
            returning = "retVal"
    )
    public void afterReturning(Object retVal) {
        System.out.println("after returning advice, 返回结果 retVal:" + retVal);
    }

    //异常通知
    @AfterThrowing(
            pointcut = "controller()",
            throwing = "ex"
    )
    public void afterThrowing(Exception ex) {
        System.out.println("after throwing advice, 异常 ex:" + ex.getMessage());
    }

    //后置通知
    @After("controller()")
    public void after(JoinPoint joinPoint) {
        System.out.println("after advice");
    }

    //环绕通知
    @Around("controller()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        System.out.println("before advice");
        //相当于是before advice
        Object reval = null;
        try {
            reval = joinPoint.proceed();
        } catch (Exception e) {
            //相当于afterthrowing advice
            System.out.println("afterthrowing advice");
        }
        //相当于是after advice
        System.out.println("after advice");
        return reval;
    }
}

需要注意的是：

1. 在返回通知中，我们需要给@AfterReturing设置returning的值，且需要与方法的参数名一致，用于表示业务方法的返回值
2. 在异常通知中，需要给@AfterThrowing设置throwing的值，且需要与方法的参数名一致，用于表示业务方法产生的异常
3. 在环绕通知中，参数为ProceedingJoinPoint类型，它是JoinPoint的子接口，我们需要在这个方法中手动调用其proceed方法来触发业务方法
4. 在所有的通知方法中都可以申明第一个参数为JoinPoint(注意的是，环绕通知是使用ProceedingJoinPoint来进行申明，它实现了JoinPoint接口)
5. JoinPoint接口提供了几个有用的方法
   1. getArgs()：返回这个方法的参数
   2. getThis()：返回这个代理对象
   3. getTarget()：返回目标对象(被代理的对象)
   4. getSignature()：返回被增强方法的描述
   5. toString()：打印被增强方法的有用描述

下面为Mycontroller测试类：

@RestController
@RequestMapping("/my")
public class MyController {

    @GetMapping("/testBefore")
    public void testBefore() {
        System.out.println("testBefore 业务方法");
    }

    @GetMapping("/testAfterReturning")
    public String testAfterReturning() {
        System.out.println("testAfterReturning 业务方法");
        return "我是一个返回值";
    }

    @GetMapping("/testAfterThrowing")
    public void testAfterThrowing() {
        System.out.println("testAfterThrowing 业务方法");
        int a = 0;
        int b = 1 / a;
    }

    @GetMapping("/testAfter")
    public void testAfter() {
        System.out.println("testAfter 业务方法");
    }

    @GetMapping("/around")
    public void around() {
        System.out.println("around 业务方法");
    }
}

5. 用AOP实现日志拦截

打印日志是AOP的一个常见应用场景，我们可以对Controller层向外提供的接口做统一的日志拦截，用日志记录请求参数、返回参数、请求时长以及异常信息，方便我们线上排查问题，下面是核心类LogAspect的实现

@Aspect
@Component
public class LogAspect {

    @Resource
    private IdWorker idWorker;

    @Pointcut("execution (public * com.yc.core.controller.*.*(..))")
    public void log(){}

    
    @Around("log()")
    public Object logAround(ProceedingJoinPoint joinPoint) throws Throwable {
        //获得执行方法的类和名称
        String className = joinPoint.getTarget().getClass().getName();
        //获得方法名
        MethodSignature signature = (MethodSignature) joinPoint.getSignature();
        String methodName = signature.getMethod().getName();
        //获得参数
        Object[] args = joinPoint.getArgs();
        long requestId = idWorker.nextId();
        //打印参数
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",params:" + JSONObject.toJSonString(args));
        long startTime = System.currentTimeMillis();
        //执行业务方法
        Object result = null;
        try {
            result = joinPoint.proceed();
        } catch (Exception e) {
            LogHelper.writeErrLog(className, methodName, "requestId:" + requestId + ",异常啦：" + LogAspect.getStackTrace(e));
        }
        long endTime = System.currentTimeMillis();
        //打印结果
        LogHelper.writeInfoLog(className, methodName, "requestId:" + requestId + ",耗时：" + (endTime - startTime) +  "ms，result:" + JSONObject.toJSonString(result));
        //返回
        return result;
    }

    
    public static String getStackTrace(Throwable throwable)
    {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        try
        {
            throwable.printStackTrace(pw);
            return sw.toString();
        } finally
        {
            pw.close();
        }
    }
}

1. 在proceed()方法之前，相当于前置通知，收集类名、方法名、参数，记录开始时间，生成requestId
2. 在proceed()方法之后，相当于后置通知，并能获取到返回值，计算耗时
3. 在前置通知时，生成requestId，用于串联多条日志
4. 使用try、catch包裹proceed()方法，在catch中记录异常日志
5. 提供了getStackTrace方法获取异常的堆栈信息，便于排查报错详细情况

6. 思考

1. 代理对象是什么时候创建的？

2. 当存在多个通知时，执行顺序是怎么保证的？

3. 真正的业务方法是什么时候调用的，怎么做到只调用一次？

参考

1.  AOP（面向切面编程）_百度百科

2. Core Technologies