Aop源码

首先配置文件内容如下：

<!--横切逻辑-->
    <bean id="logUtils" class="com.test.circular.LogUtils">
    </bean>
 
    <aop:config>
        <aop:aspect ref="logUtils">
            <aop:before method="beforeMethod" pointcut="execution(public void com.test.aop.AopBean.test())"/>
            <aop:after method="alertMethod" pointcut="execution(public void com.test.aop.AopBean.test())"/>
            <aop:around method="aroundMethod" pointcut="execution(public void com.test.aop.AopBean.test())"/>
            <aop:after-returning method="afterReturning" pointcut="execution(public void com.test.aop.AopBean.test())"/>
            <aop:after-throwing method="afterThrowingMethod" pointcut="execution(public void com.test.aop.AopBean.test())"/>
        </aop:aspect>
    </aop:config>

public class LogUtils {
 
    public void beforeMethod() {
        System.out.println("前置通知");
    }
 
    public void alertMethod() {
        System.out.println("最终通知");
    }
 
    public Object aroundMethod(ProceedingJoinPoint pjp) throws Throwable {
        System.out.println("环绕通知-前");
        Object proceed = pjp.proceed();
        System.out.println("环绕通知-后");
 
        return proceed;
    }
 
    public void afterThrowingMethod() {
        System.out.println("异常通知");
    }
 
    public void afterReturning() {
        System.out.println("后置通知");
    }
}

public class AopBean implements AopBeanInf{

   @Override
   public void test() {
      System.out.println("spring aop 测试");
   }

}

　　通过SpringIOC源码中的源码分析过程，可以将切入点定位到如下图所示方法。

接着会遍历所有的初始化的bean，主要进入AbstractAutowireCapableBeanFactory的doCreateBean方法，会完成实例创建。

往下走会完成bean生命周期的管理，首先属性填充，调用初始化bean，重点分析这个方法。

1) 调用Bean中的BeanNameAware.setBeanName()方法，如果该Bean实现了BeanNameAware接口；调用Bean中的BeanFactoryAware.setBeanFactory()方法，如果该Bean实现了BeanFactoryAware接口，调用Bean中的BeanClassLoader.setBeanClassLoader()方法。

2)调用BeanPostProcessors.postProcessBeforeInitialization()方法

3)调用Bean中的afterPropertiesSet方法，如果该Bean实现了InitializingBean接口；

4）调用Bean中的init-method，通常是在配置bean的时候指定了init-method，例如：<beanclass="beanClass"init-method="init"></bean>

5）调用BeanPostProcessors.postProcessAfterInitialization()方法；

实现AOP主要在初始化后应用Bean后置处理器---在这一步生成代理对象

这个方法会遍历所有的后置处理器。

主要进入AbstractAutoProxyCreator类的postProcessAfterInitialization方法，如下红框所示对象进行包装即增强

将所有的通知拆分成数组。

如下图所示，通过createProxy方法创建代理对象。

进入的createProxy方法，该方法中主要有getProxy这个方法中会通过代理工厂生成对象

判断是否实现接口，用jdk还是cglib代理,默认采用jdk代理。

public Object getProxy(@Nullable ClassLoader classLoader) {
       return createAopProxy().getProxy(classLoader);
}

public AopProxy createAopProxy(AdvisedSupport config) throws AopConfigException {
    if (config.isOptimize() || config.isProxyTargetClass() || hasNoUserSuppliedProxyInterfaces(config)) {
        Class<?> targetClass = config.getTargetClass();
        if (targetClass == null) {
            throw new AopConfigException("TargetSource cannot determine target class: " +
                    "Either an interface or a target is required for proxy creation.");
        }
        if (targetClass.isInterface() || Proxy.isProxyClass(targetClass)) {
            return new JdkDynamicAopProxy(config);
        }
        return new ObjenesisCglibAopProxy(config);
    }
    else {
        return new JdkDynamicAopProxy(config);
    }
}