Spring AOP从入门到精通
目录
2.2 @EnableAspectJAutoProxy工作原理
1. AOP的演化过程
编程中我们经常会遇到这样的场景，有一段通用逻辑横跨多个业务，不能用继承来解决，比如方法耗时、数据库事务、通用日志等等。一个典型的DAO方法调用分为下面3个步骤:
每一次都手工的开启和提交事务，即显得啰嗦，又影响业务的可读性。AOP就十分擅长解决这类问题，它把开启和提交事务的逻辑抽取到Advice当中，在任务DAO上复用。那么AOP到底是怎么实现的呢？
1. 代理模式
熟悉设计模式的人这时候会想到代理模式，通过新增一个代理类实现，负责处理事务的开启和提交。假设我们要处理的是下面的类图，Staff是我们要处理的实体类，StaffDao是接口，定义两个方法employ、paySalary，StaffDaoImpl是实际的DAO实现，StaffDaoProxy是代理类，负责事务开启和提交。
Dao的操作用伪代码实现，StaffDaoImpl和代理类，核心代码如下
public class StaffDaoImpl implements StaffDao {
public void employ(Staff p) {
System.out.println("employ staff: " + p);
}
public void paySalary(Staff p) {
System.out.println("pay salary :" + p);
}
}
public class StaffDaoProxy implements StaffDao {
private StaffDao staffDao;
public StaffDaoProxy(StaffDao staffDao) {
this.staffDao = staffDao;
}
public void employ(Staff p) {
System.out.println("start transaction...");
staffDao.employ(p);
System.out.println("commit transaction...");
}
public void paySalary(Staff p) {
System.out.println("start transaction...");
staffDao.paySalary(p);
System.out.println("commit transaction...");
}
}通过如下代码进行测试，StaffDaoImpl只是完成了数据操作，StaffDaoProxy会额外事务开启和提交操作
Staff staff = new Staff("zhangsan",18);
StaffDao staffDao = new StaffDaoImpl(); // 直接调用
staffDao.employ(staff);
staffDao.paySalary(staff);
StaffDaoProxy proxy = new StaffDaoProxy(staffDao); // 通过代理类使用
proxy.employ(staff);
proxy.paySalary(staff);2. 动态代理
代理模式确实达成了我们想要的效果，如果每一个需要横切逻辑的类都需要通过代理模式类实现的话，人力成本过高，而且也不便于维护，后续每一次修改都需要改大量的代理类。通过JDK提供的动态代理，或者字节码操作的第三方库能解决这个问题。
2.1 JDK动态代理
我们来看一个通过JDK的Proxy类实现动态代理的示例，首先要定义一个InvocationHandler的实现
public class TransactionInvocationHandler implements InvocationHandler {
private StaffDao staffDao;
public TransactionInvocationHandler(StaffDao staffDao) {
this.staffDao = staffDao;
}
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
System.out.println("start transaction...");
Object result = method.invoke(staffDao,args);
System.out.println("commit transaction...");
return result;
}
}接着就可以通过Proxy.newInstance来创建代理类实例，并测试，其中staff和staffDao的实例和代理模式里的创建方式一样，通过proxy.employ和proxy.paySalary调用输出也同之前的案例。
InvocationHandler invocationHandler = new TransactionInvocationHandler(staffDao);
StaffDao proxy = (StaffDao) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(),new Class[]{StaffDao.class},invocationHandler);
proxy.employ(staff);
proxy.paySalary(staff);2.2 Cglib动态代理
JDK动态代理存在的一个问题是，生成代理对象必须基于接口，如果一个类没有实现接口就无法创建代理。好在还有大量的第三方库支持无接口的类生成动态代理。我们来看一个cglib的示例。和JDK代理类似，首先我们要实现一个回调类，不过cglib里回调类接口是MethodInterceptor。
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;
import java.lang.reflect.Method;
public class TransactionMethodInterceptor implements MethodInterceptor {
private StaffDao staffDao;
public TransactionMethodInterceptor(StaffDao staffDao) {
this.staffDao = staffDao;
}
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
System.out.println("start transaction...");
Object result = method.invoke(staffDao, args);
System.out.println("commit transaction...");
return result;
}
}紧接着使用Enhancer类创建代理类对象，并使用测试，也能得到同样的测试结果。
TransactionMethodInterceptor interceptor = new TransactionMethodInterceptor(staffDao);
Enhancer enhancer = new Enhancer();
enhancer.setCallback(interceptor);
enhancer.setSuperclass(StaffDao.class);
StaffDao proxy = (StaffDao) enhancer.create();3. Spring模式
动态代理解决代理模式带来的部分问题，我不需要再为每个类手动创建子类，所有横切逻辑都集中到InvocationHandler或MethodInterceptor中了。但是每次使用的时候都需要手工创建代理对象，还是比较麻烦。Spring基于自己的能力对这个问题做了简化
3.1 ProxyFactory
Spring提供了ProxyFactory来简化代理对象的创建，频闭通过JDK或Cglib创建代理对象的差异(涉及类如下图)，除此以外并没有其他改善。
同样需要实现一个回调类，实现aopaliance提供的MethodInterceptor接口，具体代码如下
import org.aopalliance.intercept.MethodInterceptor;
import org.aopalliance.intercept.MethodInvocation;
public class SpringTransactionMethodInterceptor implements MethodInterceptor {
@Override
public Object invoke(MethodInvocation invocation) throws Throwable {
System.out.println("start transaction...");
Object result = invocation.proceed();
System.out.println("commit transaction...");
return result;
}
}然后使用ProxyFactory来创建代理对象，并进行测试，测试结果同之前的示例
ProxyFactory factory = new ProxyFactory();
factory.setTarget(staffDao);
factory.addAdvice(new SpringTransactionMethodInterceptor());
StaffDao proxy = (StaffDao) factory.getProxy();
Staff staff = new Staff("zhangsan", 18);
proxy.employ(staff);
proxy.paySalary(staff);3.2 ProxyFactoryBean
到目前为止我们依然需要手动创建代理类对象，通过Spring本身的FactoryBean机制，Spring AOP为我们提供了ProxyFactoryBean实现。首先通过xml配置Bean实现
<bean id="staffDao" class="com.lws.designPattern.StaffDaoImpl"/>
<bean id="springTransaction" class="com.lws.spring.SpringTransactionMethodInterceptor"/>
<bean id="staffDaoProxy" class="org.springframework.aop.framework.ProxyFactoryBean">
<property name="target" ref="staffDao"/>
<property name="interceptorNames">
<list>
<value>springTransaction</value>
</list>
</property>
</bean>接着通过创建ApplicationContext，获取Bean实例，测试代码如下
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
StaffDao proxy = context.getBean("staffDaoProxy", StaffDao.class);
proxy.employ(staff);
proxy.paySalary(staff);3.3 AbstractAutoProxyCreator
ProxyFactoryBean已经基本可以使用了，只是每一个Bean要做代理时都需要手工配置一个ProxyFactoryBean，使用起来还是略显繁琐。Spring提供了AbstractAutoProxyCreator来完成AOP代理的自动创建。这里我们以BeanNameAutoProxyCreator为例，看看AutoProxyCreator是如何使用，它是怎么工作的。同样先基于xml配置BeanNameAutoProxyFactory，使用相同interceptorNames的所有Bean都可以通过这一个配置自动创建代理，而且staffDao不需要和之前那样创建staffDao、staffDaoProxy两个Bean。
<bean id="staffDao" class="com.lws.designPattern.StaffDaoImpl"/>
<bean id="springTransaction" class="com.lws.spring.SpringTransactionMethodInterceptor"/>
<bean class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<list>
<value>staffDao</value>
</list>
</property>
<property name="interceptorNames" value="springTransaction"/>
</bean>接着只需要正常的获取staffDao的Bean实例，并调用测试即可
Staff staff = new Staff("zhangsan", 18);
ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("application.xml");
StaffDao proxy = context.getBean("staffDao", StaffDao.class);
proxy.employ(staff);
proxy.paySalary(staff);
应该承认BeanNameAutoProxyCreator的使用已经比较简单了，对使用相同interceptorNames的AOP场景，只需要把Bean实例名称添加到beanNames就行了。再进一步简化就是通过AnnotationAwareAspectJAutoProxyCreator来实现了，它会自动判断Bean是否匹配AspectJ表达式，对符号条件的Bean完成代理。后面的代码中我们会进行源码级解释，现在我们先来讲讲Spring对AOP做的抽象，以及它实现AOP的核心组件。
2. Spring AOP抽象
1. 核心术语
1.1 连接点(JoinPoint)
连接点是程序中客观存在的特定位置，比如类初始化前、类初始化后、方法执行前、方法执行后等等。Spring AOP中只支持方法的连接点。连接到有两组信息组成，一个是程序的执行点，比如哪个类的哪个方法；一个是相对位置，比如方法执行前、方法返回后等等。Spring使用切点(Pointcut)表示执行点，用增强(Advice)表示相对位置。
1.2 切点(Pointcut)
连接点是程序中客观存在的事务，比如一个程序内有2个方法，方法执行前、方法执行后、抛出异常时，连接点个数就已经确定了，如果只看这3类相对位置的话，连接点就是6个。切点用来表示我们关心的连接点。Spring中使用Pointcut类表示切点。下图是Pointcut类的定义，它有两个成员变量，分别是ClassFilter实例、MethodMatcher实例。通过如下的UML图中的方法定义可以看到，ClassFilter用来表示哪些类是满足当前切点要求，MethodMatcher用来确定哪些方法满足当前切点要求。
Spring内部的核心实现类有下面这些，后面我们会挑几个看一下如何使用。
1.3 增强(Advice)
在介绍连接点的时候我们提供到过，连接点相对位置是通过增强(Advice)来表示的，此外Advice还包含相对位置要执行的代码。下图是Spring提供的Advice的核心类。我们日常使用的较多的就是在图的中心位置的4个类:
- MethodBeforeAdvice，方法执行前增强
- MethodInterceptor，方法环绕增强
- AfterReturningAdvice，方法返回后增强
- ThrowsAdvice，方法抛异常是的正常，这里需要特别注意ThrowsAdvice是一个标记接口，Spring通过反射调用，查看类JavaDoc有描述对方法签名的限制
1.4 切面(Aspect)
从之前的定义中可知，Pointcut和Advice已经完整的定义了在哪里执行什么增强逻辑。切面有切点(Pointcut)和增强(引介)组成，即包括横切逻辑的定义，也包括连接点的定义。
1.5 目标对象(Target)
要进行增强逻辑的目标类，在我们前面的例子里，StaffDao类的实例就是目标对象。
1.6 代理对象(Proxy)
对目标对象进行增强后生成的对象，就称为代理对象，这个对象已经包含增强的执行逻辑。
2. 核心组件
这张图里给出了Spring AOP中的核心流程涉及的组件，包括怎么定义切点(Pointcut)，增强(Advice)，并且通过组合Pointcut和Advice获得Advisor的定义。拿到Advisor后，我们可以使用ProxyFactory将Advisor和目标对象(target)组合，生成代对象。Spring默认支持两种生成代理对象的实现，一种是基于JDK的实现，JdkDynamicAopProxy，一种是基于Cglib的实现，ObjenesisCglibAopProxy。
每一个组件都有大量的实现类，这里不进行展开。接下来我们对几个关键点做详细的说明
2.1 AutoProxyCreator工作原理
BeanNameAutoProxyCreator继承自AbstractAutoProxyCreator，实现了Bean生命周期里的InstantiationAwareBeanFactoryProcessor、BeanPostProcessor，覆写的是两个方法: postProcessBeforeInstantiation、postProcessAfterInitialization，核心流程图如下:
对于定义了customTargetSource的AbstractAutoProxyCreator，Bean不会走正常的实例化流程，在postProcessBeforeInstantiation就通过TargetSource实例化并创建代理返回。日常开发中我们极少使用TargetSource，TargetSource适用于aop时期望目标对象(target)支持池化或者热替换的场景，更多TargetSource信息可以阅读Spring官方文档中关于Using TargetSources章节。
BeanNameAutoProxy主要覆写了AbstractAutoProxyCreator以下几个方法:
- isSupportedBeanName，基于配置的beanNames判断当前bean是否支持自动创建代理对象
- getAdvicesAndAdvisorsForBean，支持的时候返回空数组，不支持返回null
BeanNameAutoProxyCreator的Advice和Advisor对象的注入主要时通过interceptorNames做为bean名称从容器中查找的，具体实现看AbstractorAutoProxyCreator的buildAdvisors实现
AnnotationAwareAspectJAutoProxyCreator基于AbstractAutoProxyCreator实现，不适用interceptorNames，核心逻辑在于查找bean匹配的Advisor，通过findCandidateAdvisors查找候选Advisor。
以下是AbstractAutoProxyCreator的骨干代码，实现类基于下面的模板修改部分逻辑。
@Override
public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName) {
...
TargetSource targetSource = getCustomTargetSource(beanClass, beanName); // 自定义customTargetSourceCreator的Bean
if (targetSource != null) {
if (StringUtils.hasLength(beanName)) {
this.targetSourcedBeans.add(beanName);
}
Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource); // 通过自定义TargetSource直接返回Bean
Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
this.proxyTypes.put(cacheKey, proxy.getClass());
return proxy;
}
...
}
@Override
public Object postProcessAfterInitialization(@Nullable Object bean, String beanName) {
if (bean != null) {
Object cacheKey = getCacheKey(bean.getClass(), beanName);
if (this.earlyBeanReferences.remove(cacheKey) != bean) {
return wrapIfNecessary(bean, beanName, cacheKey);
}
}
return bean;
}2.2 @EnableAspectJAutoProxy工作原理
EnableAspectJAutoProxy通过在自身注解@Import引入ImportBeanDefinitionRegistrar实现，ImportBeanDefinitionRegistrar接口允许用户通过代码注册自己的BeanDefinition。
@Import({AspectJAutoProxyRegistrar.class})
public @interface EnableAspectJAutoProxy AspectJAutoProxyRegistrar的核心代码如下:
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
public void registerBeanDefinitions(AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
AnnotationAttributes enableAspectJAutoProxy = AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
...
}
}进一步往AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary下面追踪，我们发现自动注册了AnnotationAwareAspectJAutoProxyCreator，结合上面我们对AutoProxyCreator的了解，整个基于注解的配置AOP的流程就通顺了。
3. Spring AOP案例
基于上面对原理的探究，我们能理解怎么从Advice、Pointcut开始创建Advisor，怎么利用ProxyFactoryBean创建代理，通过AutoProxyCreator让Spring自动创建代理，Spring对所有这些元素的抽象，以及相互之间如何协同。然而在显示工作中，仅仅知道这些是不够的，我们不可能每次都从最原始的MethodBeforceAdvice来创建我们的Advice，不可能从ClassFilter、MethodMatcher开始定义Pointcut，这样的话使用成本太高了，Spring提供了大量的内置类型，降低我们使用Spring AOP的成本。下一篇中我们会专注提供实战案例，包括但不限于如下主题
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。 如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：veading@qq.com进行投诉反馈，一经查实，立即删除！