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
网友评论