1. 写在前面

在之前的学习中，我们对 AOP 相关的概念进行了学习，明白了 AOP 作为切面编程的体现，其包含了 jointPoint、pointCut、advice、aspect 等概念。也通过一个生动的例子对这些概念进行了理解。
最后，了解到了 在 spring 中仅支持 方法执行 这一种 jointPoint，同时学习了不同的 advice类型，其中最为常用的是 around advice，其在 jointPoint 方法执行前后都运行。

2. Spring中如何使用 AOP

2.1 使用

这里的使用，由于 Spring 容器的存在，因此我们只需要规定如下三个点：

• join point 在哪里
• advice 是什么
• 添加 @Component & @Aspect 注解
• 在 @Configuration 类上面 添加 @EnableAspectJAutoProxy 注解

事实上就是定义切面注入要执行的方法，以及执行的位置即可。
其他的都是一些必要的配置。

2.1.1 引入依赖

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-aspects</artifactId>
    <version>${spring.version}</version>
</dependency>

这里的依赖会自动引入 AspectJ，因为其定义比较简单，实现AOP比较方便。

2.1.2 定义 Aspect

这里我们定义一个 Aspect，用来完成相关 执行方法advice 的定义 和 连接点join point 的指定。

@Aspect
@Component
public class LoggingAspect {
    // 在执行UserService的每个方法前执行:
    @Before("execution(public * com.itranswarp.learnjava.service.UserService.*(..))")
    public void doAccessCheck() {
        System.err.println("[Before] do access check...");
    }

    // 在执行MailService的每个方法前后执行:
    @Around("execution(public * com.itranswarp.learnjava.service.MailService.*(..))")
    public Object doLogging(ProceedingJoinPoint pjp) throws Throwable {
        System.err.println("[Around] start " + pjp.getSignature());
        Object retVal = pjp.proceed();
        System.err.println("[Around] done " + pjp.getSignature());
        return retVal;
    }
}

在 doAccessCheck() 方法上添加了 @Before 注解，同时后面字符串指定了其执行的位置（连接点）。合起来为 UserService 类下的所有 public 方法执行前，执行 doAccessCheck() 方法。

同样，doLogging() 方法是在 MailService 类中所有 public 方法执行前和执行后执行，但是注意到这里有. ProceedJoinPoint.proceed() 方法，其显示的声明了，joinPint 的代码需要执行。

记得上一章最后说到了，@Before advice 是无法规定原代码是否执行的。@Around 则需要规定。

2.1.3 添加 @EnableAspectJAutoProxy 注解

给 @Configuration 类添加 @EnableAspectJAutoProxy 注解。
Spring 看到这个注解，就会去寻找带有 @Aspect 注解的Bean，根据其中方法上对应的 @Before、@Around 等注解把 Aspect 织入特定的 Bean 中，执行代码。

3. Spring 实现 AOP 的原理

从上面不难看出，我们通过简单的配置，就可以将 @Aspect 类中定义的方法织入相关的Bean 中进行执行。
那么 Spring 究竟是怎么实现AOP的呢。
以下面这个例子来看，把 LoggingAspect.doAccessCheck() 注入到 UserService 的每个 public 方法中，最容易实现的方法就是编写一个 UserService 的子类，持有原始实例的引用。

public UserServiceAopProxy extends UserService {
    private UserService target;
    private LoggingAspect aspect;

    public UserServiceAopProxy(UserService target, LoggingAspect aspect) {
        this.target = target;
        this.aspect = aspect;
    }

    public User login(String email, String password) {
        // 先执行Aspect的代码:
        aspect.doAccessCheck();
        // 再执行UserService的逻辑:
        return target.login(email, password);
    }

    public User register(String email, String password, String name) {
        aspect.doAccessCheck();
        return target.register(email, password, name);
    }

    ...
}

核心就是：创建子类，按照顺序将织入Aspect代码和原 joinPoint 代码逻辑执行。

事实上，这个子类是存在的，但是不是我们显示去写的，是 Spring 的容器为我们自动创建的。其取代了原始的 UserService，原UserService 实例作为内部变量隐藏在 UserServiceAopProxy 中。
如果这时候我们从 Spring 容器中获取 UserService 实例类型，会看到
UserService$$EnhancerBySpringCGLIB$$a7e2ed9，实际上，其是使用 CGLIB 动态创建的子类，对于我们使用调用来说，没有任何区别。

4. 总结

使用 Spring 完成AOP 非常简单，因为由 Spring容器通过 CGLIB 自动创建了对应类的子类，完成了相关的 waving。
我们只需要定义 @Aspect 类，在其中编写 advice，并通过 @Before @Around 等指定要执行的 joinPoint 即可。

5. 使用注解实现AOP装配

事实上，在工程开发中，通过 execution(* xx.aa.bb) 这种包路径的方式来进行 joinPoint 指定的，属实是非常笨蛋的。
我们更常用的是通过注解实现。在特定的方法上，直接打上相应的注解，例如我们常用的事务控制 @Transactional ，就是用这种方式实现的。

只需要定义相关注解，然后在@Aspect类中使用 @Around("@annotation(注解名称)") ，限定注入 AOP 的方法。

/**/
//这里是注解的定义，可以看到这里的注解名叫做 MetricTime

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

    String value();

}


@Aspect
@Component
public class MetricAspect {
// 这里使用参数名来指定，可以看到这个参数名对应的参数类型是 MetricTime 注解，因此这里事实上是规了
    @Around("@annotation(metricTime)") 
    public Object metric(ProceedingJoinPoint joinPoint, MetricTime metricTime) throws Throwable {
        String name = metricTime.value();
        long start = System.currentTimeMillis();
        try {
            return joinPoint.proceed();
        } finally {
            long t = System.currentTimeMillis() - start;
            // 写入日志或发送至JMX:
            System.err.println("[Metrics] " + name + ": " + t + "ms");
        }
    }
}

6. AOP 避坑指南

所谓的 AOP，事实上是由 Spring 为我们创建了一个 Proxy 代理类，运行期，这个代理类织入了Aspect 中的代码和原始类逻辑。

在使用AOP时，会遇到几个经典问题。而这几个问题的产生都和 Spring 创建代理类有关。

6.1 代理类不会初始化变量

下面UserService是原始类，@Aspect 类注入到该类中，形成代理类。
在MailService调用sendMail()时，会发现报异常 NullPointerException。

@Component
@Getter
public class UserService {
    // 成员变量:
    public final ZoneId zoneId = ZoneId.systemDefault();

    // 构造方法:
    public UserService() {
        System.out.println("UserService(): init...");
        System.out.println("UserService(): zoneId = " + this.zoneId);
    }

    // public方法:
    public ZoneId getZoneId() {
        return zoneId;
    }

    // public final方法:
    public final ZoneId getFinalZoneId() {
        return zoneId;
    }
}

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(public * com..*.UserService.*(..))")
    public void doAccessCheck() {
        System.err.println("[Before] do access check...");
    }
}

@Component
public class MailService {
    @Autowired
    UserService userService;

    public String sendMail() {
        ZoneId zoneId = userService.zoneId;
        String dt = ZonedDateTime.now(zoneId).toString();
        return "Hello, it is " + dt;
    }
}

为啥呢

众所周知，java编译器会在继承类构造时候默认调用super() 构造方法。因为代理是通过CGLIB 完成的，其直接生成字节码，因此没有 源码-编译-字节码 这个步骤。因此不会掉用父类构造方法，其继承的父类变量，也就没有初始化，即为 null。

总结一下，
代理类代理的是方法。方法都会被重写。
AOP 代理类不会初始化自身继承的任何成员变量。

如何避免

在使用被注入AOP的类时候，避免直接访问变量，使用方法访问变量。

ZoneId zoneId = UserService.zoneId;  // 会报NPE错

ZoneId zoneId = UserService.getZoneId();

6.2 fianl 方法不可以被代理

在上面的例子中，如果我们用

ZoneId zoneId = UserService.getFinalZoneId()；

也会报错 NPE，因为 fianl 方法无法被 override。
因此如果方法可能被代理，那就不要给他 final