Spring AOP 实现函数执行时间打印

AOP 概念

AOP：Aspect Orient Programming
中文翻译：面向切面编程
作为面向对象编程的一种补充，采用非侵入式技术手段处理系统中分布于各个模块的横切关注点，比如事务管理，安全审计，日志、缓存等等。

AOP 优缺点

优点：原有代码无需更改，不影响原有业务逻辑；
缺点：通过代理方式，会有一定的性能损失；

AOP 代理

AOP 的底层实现是通过代理和反射技术，拦截正常的方法调用，在正常方法调用完成前和完成后插入切面相关的代码。具体实现有如下两种：

静态代理：
代表：AspectJ，直接通过修改字节码实现，编译期完成，但是需要额外的编译器支持；
动态代理：
代表：Spring AOP，运行时动态创建代理类；
Spring AOP 代理又分为两种，JDK Proxy 和 CGLIB，分别针对接口代理和类代理。

AOP 关键点：

Aspect：切面
对应一个类，用于实现横跨多个企业应用类的业务处理，比如事务，日志等。
通俗的话来说，其他应用类实现业务的主要逻辑（纵向），切面关注次要方面（横向插入日志，事务处理，安全审计等动作）。
Join Point：连接点
方法执行，异常处理，改变对象的值等特定情况；
Advice：动作
与连接点和切点相关的一系列动作
对应一个方法
Pointcut：切点
与连接点相关的表达式，匹配则执行相关动作（Advice）；
Target Object：目标对象
加入相关的动作处理（Advice）的目标对象；
AOP Proxy：代理
Spring AOP 通过 JDK Proxy 或者 CGLIB 创建代理；
Weaving：织入
关联切面和目标对象的过程。可以在编译期，加载期或运行期完成；
Spring AOP 在运行期完成这个过程，AspectJ在编译期完成这个过程；

AOP 实现举例：（函数执行时间打印）

基于常用的 Spring AOP 为例，基于注解实现打印函数执行时间的切面功能。

增加依赖包

创建 Spring 项目，在 pom.xml 加入 Spring AOP 相关的类。

#pom.xml


  org.springframework
  spring-aop
  ${spring.version}



  org.aspectj
  aspectjrt
  1.8.14


  org.aspectj
  aspectjweaver
  1.8.14

开启切面能力

proxyTargetClass = true，强制使用 CGLIB 代理，如果不设置针对于接口方法织入，默认使用 JDK Proxy 代理。

@Configuration
@EnableAspectJAutoProxy(proxyTargetClass = true)
 public class AspectJConfiguration {
 }

定义注解

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface CallTime {

}

创建切面

@Aspect
@Component
public class CallTimeAspect {
 
}

增加切点

@Aspect
@Component
public class CallTimeAspect {
  @Pointcut("@annotation(CallTime) && execution(public org.test.service.*(..))") 
  public void pointCutMethod();
}

"@annotation(CallTime) && execution(public org.test.service.*(..))"
这个表达式表示只拦截加有CallTime注解的，并且是public方法，并且是 org.test.service这个包下面的类的方法，只有匹配这个表达式的方法才会被拦截，当然这个表达式可以更复杂，比如针对参数做匹配等等。

增加连接点和动作

Spring 只支持方法连接点，主要有3种方式对方法进行增强：
@Before 方法执行前；
@After 方法执行后；
@Around 方法执行过程中；

@Aspect
@Component
public class CallTimeAspect {
  @Pointcut("@annotation(CallTime) && execution(public org.test.service.*(..))") 
  public void pointCutMethod();

  @Around("pointCutMethod()")
  public Object callTime(ProceedingJoinPoint joinPoint) throws Throwable {
    long start = System.currentTimeMillis();
    Object proceed = joinPoint.proceed();
    long end = System.currentTimeMillis();
    String className = proceed.getSignature().getDeclaringType().getSimpleName();
    String functionName = proceed.getSignature().getName();
    System.out.println(String.format("%s.%s takes %dms", className, functionName, end - start));
    return proceed;
  }
}

增加拦截代码

# org.test.service

public class BusinessService {

   @CallTime
   void doBusiness() {
      ...
   }
}

当doBusiness在外部被调用时，就会打印执行时间了：

BusinessService.doBusiness takes XXXms

潜在的问题

被final修饰的类无法被改写，因此也就没法使用 AOP 进行拦截；
在外部调用被拦截的方法中再调用该类其他的方法，无法使用 AOP 进行拦截；

class Test {
  @CallTime
  public void funcA() {
     this.funcB();
  }
  
  @CallTime
  public void funcB() {
  }

在外部调用：

new Test().funcA()

只有 funcA 会被拦截，funcB 并不会。

私有方法不能被外部调用，因此也就没法使用 AOP 进行拦截；

Spring AOP 参考

https://www.journaldev.com/2583/spring-aop-example-tutorial-aspect-advice-pointcut-joinpoint-annotations