Spring AOP 的底层实现

实例代码 demo code

• 创建一个配置类去扫描包，开启 AspectJ 的自动代理支持

@Configuration
@EnableAspectJAutoProxy
@ComponentScan("com.aspectj")
public class DemoAspectJConfig {
	// @EnableAspectJAutoProxy 开启注解 aop 功能
	// 向 spring 容器中已经加入 AnnotationAwareAspectJAutoProxyCreator bean 实例
}

• 新建接口和接口实现类

// 接口
public interface DemoDao {
	void query();
}

// 实现类
@Component
public class DemoDaoImpl implements DemoDao {
	@Override
	public void query() {
		System.out.println("query ......");
	}
}

• 创建一个切面

@Aspect
@Component
public class DemoAspect {
	// 配置切点
	@Pointcut("execution(* com.aspectj.dao.*.*(..))")
	public void point(){
	}
	// 切点通知
	@Before("point()")
	public void beforeAd(){
		System.out.println("before-------------");
	}
}

• 创建启动类

public class TestAspect {
	public static void main(String[] args) {
		// 这一步已经生成代理对象，是非懒加载的方式加载
		// 在容器初始化刷新的时候已经向 bean 容器中添加： AnnotationAwareAspectJAutoProxyCreator 对象
		AnnotationConfigApplicationContext configApplicationContext = new AnnotationConfigApplicationContext(DemoAspectJConfig.class);
		
		// 验证前一步创建的代理对象是否成功
		DemoDao dao = configApplicationContext.getBean(DemoDao.class);
		dao.query();
	}
}

• 启动 main() 方法，可以看到输出的内容，所有 aop 的功能有启用
  

对代码进行 debug，分析如何创建 bean 对象，并对 bean 对象进行增强

• 对 main() 方法进行 debug，执行完成这一行代码，已经创建出一个被增强的 bean 对象，而不是下面一行才创建增强 bean 对象，这个创建出的 beanName 为 demoDaoImpl
  

• 来到 refresh() 方法
  

• 来到 refresh() 方法中的 finishBeanFactoryInitialization(beanFactory) 方法，这个方法对 bean 进行实例化和初始化操作
  

• 来到 finishBeanFactoryInitialization() 方法中 preInstantiateSingletons() 方法，开始着手实例化 bean 对象
  

• 来到 preInstantiateSingletons() 方法，打上断点，指定 beanName.equals(“demoDaoImpl”)，可以看到想要注册的 bean
  

• debug 代码往下执行，来到 getBean(beanName) 方法
  

• debug 继续往下执行，来到 doGetBean(beanName) 方法，在 spring 中一般 do 开头的方法才是真正做事的方法
  

• 最开始创建 bean 对象的时候，通过 getSingleton() 获取的 sharedInstance 为 null，所有执行到 if(sharedInstance != null) 对应的 else 逻辑里面
  

• 来到 else 逻辑里面的 createBean() 方法，非常核心的方法，debug 进去看
  

• 在 createBean() 方法中跳到 doCreateBeanBean 方法中，do 开头的方法要开始真正创建 bean 对象了
  

• doCreateBean() 方法中调用 addSingletonFactory() 方法，这个逻辑是判断当前对象是否持有 InstantiationAwareBeanPostProcessor，如果有的话通过它的 getEarlyBeanReference() 方法获取对象引用，然后将其放到三级缓存中
  

• bean 填充 populateBean()，bean 初始化 initializeBean()

  • populateBean() 通过 InstantiationAwareBeanPostProcessor.postProcessProperties() 方法对 bean 属性进行填充，@Autowired 注入属性就在这里实现
  • initializeBean() 初始化 bean，通过各种的 BeanPostProcessor 对 bean 进行后置处理
    
  • 后置处理器的前置处理
    
  • 后置处理器的后置处理，bean 代理增强就是通过后置处理完成的
    
  • 可以看到有个后置处理器 AnnotationAwareAspectJAutoProxyCreator，这个处理器就是一个 BeanPostProcessor
    
  • AbstractAutoProxyCreator 对 postProcessAfterInitialization() 方法进行重写，wrapIfNecessary() 方法，对 bean 对象进行代理增强
    
  • 来到 wrapIfNecessary() 方法，查看 bean 有哪些地方需要增强，如果有增强的地方，就对其进行增强，通过 createProxy() 方法，创建代理对象返回
    
  • 来到 createProxy() 方法，真正创建代理的方法就是 getProxy()
    
  • getProxy() 执行前调用 createAopProxy() 创建 AopProxyFactory，委托 AopProxyFactory 去创建代理对象
    
  • 进到 createAopProxy() 方法，先调用 getAopProxyFactory() 获取到 AopProxyFactory 对象，再调用 createAopProxy() 方法
    
  • createAopProxy() 有个默认的实现类 DefaultAopProxyFactory，该类的默认实现，判断是通过 Jdk 动态代理 还是 Cglib 代理，到这一步确定返回的代理的类型，确定代理的类型之后，可以根据返回的对象调用 getProxy() 方法，生成代理对象
    
  • Cglib 和 JdkDynamic 通过生成 class 文件对增强的目标进行增强，实现逻辑是 jdk 部分的源码，之后具体分析，需要留意：
    • JdkDynamic 通过 Proxy 生成的 .class 文件，默认 extends Proxy，所以接口进行代理，要通过 JdkDynamic
    • Cglib 通过对目标类 extends 的方法继承重写增强，所以类的增强一定要通过 Cglib 的方式，因为 java 的规定就是单继承、多实现

生成字节码(.class)文件文件之后如何进行调用 ？

• CglibAopProxy
  • 代理对象调用方法的时候会到 intercept() 方法
  • 拿到所有的 aop advice：List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
  • 实例化一个 CglibMethodInvocation(其实就是 ReflectiveMethodInvocation 对象) 对象调用 proceed() 方法：retVal = new CglibMethodInvocation(proxy, target, method, args, targetClass, chain, methodProxy).proceed();
  • proceed() 方法中递归调用会得到 MethodInterceptor 对象，调用 invoke() 方法，各种拦截器起作用，进行方法的拦截处理：return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);

• JdkDynamicAopProxy
  • 代理对象调用方法的时候会到 invoke()，操作和 Cglib 基本一样
  • 获取 aop advice：List<Object> chain = this.advised.getInterceptorsAndDynamicInterceptionAdvice(method, targetClass);
  • 实例化 MethodInvocation 对象，调用 proceed() 方法：MethodInvocation invocation = new ReflectiveMethodInvocation(proxy, target, method, args, targetClass, chain);
  • 递归调用 Joinpoint.proceed() 方法，同样也是 ReflectiveMethodInvocation 实现类的 proceed() 方法，各种拦截器起作用，进行方法的拦截处理：return ((MethodInterceptor) interceptorOrInterceptionAdvice).invoke(this);

• 上面两个方法中的 MethodInterceptor.invoke() 方法调用，其中就包括事物的 TransactionInterceptor，事物的实现就是由该拦截器处理，invoke() 方法调用 invokeWithinTransaction() 方法真正处理事物
  

Aop 创建代理对象流程总结

AbstractApplicationContext.refresh(); 容器刷新
->
AbstractApplicationContext.finishBeanFactoryInitialization(beanFactory); 完成bean工厂的初始化
->
beanFactory.preInstantiateSingletons(); 初始化非懒加载的 bea 实例
->
DefaultListableBeanFactory.getBean(beanName); 创建bean
->
AbstractBeanFactory.getBean(String name); 创建 bean
->
AbstractBeanFactory.doGetBean(String name, @Nullable Class requiredType, @Nullable
Object[] args, boolean typeCheckOnly); 创建 bean
->
createBean(beanName, mbd, args); 创建 bean
->
Object beanInstance = doCreateBean(beanName, mbdToUse, args); 创建 bean
->
exposedObject = initializeBean(beanName, exposedObject, mbd); 初始化 bean
->
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName); 获取所有的 BeanPostProcessor (AnnotationAwareAspectJAutoProxyCreator > AspectJAwareAdvisorAutoProxyCreator > AbstractAdvisorAutoProxyCreator > AbstractAutoProxyCreator 这个类是 BeanPostProcessor 的实现类，是后置处理器实现代理对象增强的关键点)
->
Object current = processor.postProcessAfterInitialization(result, beanName); 调用所有的 BeanPostProcessor，来到 wrapIfNecessary() 方法
->
AbstractAutoProxyCreator.wrapIfNecessary(bean, beanName, cacheKey); 如果 bean 需要增强，就进行增强
->
Object proxy = createProxy(bean.getClass(), beanName, specificInterceptors, new
SingletonTargetSource(bean)); 创建代理对象
->
proxyFactory.getProxy(getProxyClassLoader()); 获取代理对象 classLoader
->
createAopProxy().getProxy(classLoader); 判断代理增强的类型
->
Proxy.newProxyInstance(classLoader, this.proxiedInterfaces, this); 生成代理对象