AOP-AspectJ注解源码解析

1.示例

public class Main {
    public static void main(String[] args) {
        ApplicationContext applicationContext =
                new ClassPathXmlApplicationContext("spring-aop-test.xml");

        TestInterface test = (TestInterface) applicationContext.getBean("test");
        test.dosomeTest();
        System.out.println("-----");
        test.doOtherTest();
        System.out.println("-----");
        test.a();
        test.b();
    }
}

@Aspect
public class AspectConfig {
    /**
     * 如何定义一个切点？
     * 切点位置：com.xl.code 包下的所有class 的所有 test结尾的方法。
     */
    @Pointcut(value = "execution(* com.wz.spring..*.*Test(..))")
    public void test(){}


    /**
     * 定义一个前置通知
     */
    @Before(value = "test()")
    public void beforeAdvice() {
        System.out.println("before advice");
    }


    /**
     * 定义一个后置通知
     */
    @After(value = "test()")
    public void afterAdvice() {
        System.out.println("after advice");
    }


    /**
     * 定义一个环绕通知
     */
    @Around(value = "execution(* com.wz.spring..*.*Test(..))")
    public void aroundAdvice(ProceedingJoinPoint joinPoint) {
        try {
            System.out.println("around advice begin");
            joinPoint.proceed();
            System.out.println("around advice end");
        } catch (Throwable throwable) {
            throwable.printStackTrace();
        }
    }
}






public class TestImpl implements TestInterface {
    @Override
    public void dosomeTest() {
        System.out.println("dosomeTest execute");
    }

    @Override
    public void doOtherTest() {
        System.out.println("doOtherTest execute");
    }

    @Override
    public void a() {
        System.out.println("a function execute");
    }

    @Override
    public void b() {
        System.out.println("b function execute");
    }
}

配置文件：

输出结果：

around advice begin
before advice
dosomeTest execute
after advice
around advice end
-----
around advice begin
before advice
doOtherTest execute
after advice
around advice end
-----
a function execute
b function execute

2.

AopNamespaceHandler

    public void init() {
        // In 2.0 XSD as well as in 2.5+ XSDs
        registerBeanDefinitionParser("config", new ConfigBeanDefinitionParser());
        registerBeanDefinitionParser("aspectj-autoproxy", new AspectJAutoProxyBeanDefinitionParser());
        registerBeanDefinitionDecorator("scoped-proxy", new ScopedProxyBeanDefinitionDecorator());

        // Only in 2.0 XSD: moved to context namespace in 2.5+
        registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());
    }

class AspectJAutoProxyBeanDefinitionParser implements BeanDefinitionParser {

    /**
     * @param element 包装  标签数据。
     * @param parserContext 它持有一个   readerContext  ，readerContext 它又持有 registry 也就是咱们的 BeanFactory
     */
    @Override
    @Nullable
    public BeanDefinition parse(Element element, ParserContext parserContext) {
        AopNamespaceUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(parserContext, element);
        extendBeanDefinition(element, parserContext);
        return null;
    }

2.1 AopNamespaceUtils#registerAspectJAnnotationAutoProxyCreatorIfNecessary

    public static void registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            ParserContext parserContext, Element sourceElement) {

        BeanDefinition beanDefinition = AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(
                parserContext.getRegistry(), parserContext.extractSource(sourceElement));
        useClassProxyingIfNecessary(parserContext.getRegistry(), sourceElement);
        registerComponentIfNecessary(beanDefinition, parserContext);
    }

    public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(
            BeanDefinitionRegistry registry, @Nullable Object source) {

        return registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
    }

    //参数一：固定类型 AnnotationAwareAspectJAutoProxyCreator  很关键的class，
    // 咱们的Aop功能 全靠这个class了
    //参数二：Spring容器
    //参数三：element
    @Nullable
    private static BeanDefinition registerOrEscalateApcAsRequired(
            Class cls, BeanDefinitionRegistry registry, @Nullable Object source) {

        Assert.notNull(registry, "BeanDefinitionRegistry must not be null");

        //判断容器内是否有 名称 是AUTO_PROXY_CREATOR_BEAN_NAME BD
        // 一般不会走这里，走这里主要原因是 自定义 注解解析器了
        if (registry.containsBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME)) {
            BeanDefinition apcDefinition = registry.getBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME);
            if (!cls.getName().equals(apcDefinition.getBeanClassName())) {
                int currentPriority = findPriorityForClass(apcDefinition.getBeanClassName());
                int requiredPriority = findPriorityForClass(cls);
                if (currentPriority < requiredPriority) {
                    apcDefinition.setBeanClassName(cls.getName());
                }
            }
            return null;
        }

        //创建了一个BD，并且设置class 是 AnnotationAwareAspectJAutoProxyCreator  
        // 最后将这个bd 注册到 容器中了
        RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
        beanDefinition.setSource(source);
        beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
        beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
        return beanDefinition;
    }

再来看看AopNamespaceUtils#useClassProxyingIfNecessary

    // 参数一：Spring容器
    // 参数二：aop标签
    private static void useClassProxyingIfNecessary(BeanDefinitionRegistry registry, @Nullable Element sourceElement) {
        if (sourceElement != null) {
            // proxy-target-class 标签属性：true 表示 AOP 底层实现
            // 采用 cglib，默认这个属性是false
            boolean proxyTargetClass = Boolean.parseBoolean(sourceElement.getAttribute(PROXY_TARGET_CLASS_ATTRIBUTE));
            if (proxyTargetClass) {
                //配置了 proxy-target-class 并且值是 true
                //获取出来AOP相关的这个BD，向这个BD里面添加一个属性 proxyTargetClass=true
                AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
            }
            //expose-proxy 作用就是 将 当前代理对象 暴露到 上下文内，
            // 方便代理对象内部的真实对象 拿到 代理对象。
            boolean exposeProxy = Boolean.parseBoolean(sourceElement.getAttribute(EXPOSE_PROXY_ATTRIBUTE));
            if (exposeProxy) {
                //获取出来AOP相关的这个BD，向这个BD里面添加一个属性 exposeProxy = true
                AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
            }
        }
    }

3.AnnotationAwareAspectJAutoProxyCreator

3.1 AbstractAutoProxyCreator作为InstantiationAwareBeanPostProcessor

这是个短路操作

    @Override
    public Object postProcessBeforeInstantiation(Class beanClass, String beanName) {
        Object cacheKey = getCacheKey(beanClass, beanName);

        if (!StringUtils.hasLength(beanName) || !this.targetSourcedBeans.contains(beanName)) {
            if (this.advisedBeans.containsKey(cacheKey)) {
                return null;
            }
            if (isInfrastructureClass(beanClass) || shouldSkip(beanClass, beanName)) {
                this.advisedBeans.put(cacheKey, Boolean.FALSE);
                return null;
            }
        }

        // Create proxy here if we have a custom TargetSource.
        // Suppresses unnecessary default instantiation of the target bean:
        // The TargetSource will handle target instances in a custom fashion.
        TargetSource targetSource = getCustomTargetSource(beanClass, beanName);
        if (targetSource != null) {
            if (StringUtils.hasLength(beanName)) {
                this.targetSourcedBeans.add(beanName);
            }
            Object[] specificInterceptors = getAdvicesAndAdvisorsForBean(beanClass, beanName, targetSource);
            Object proxy = createProxy(beanClass, beanName, specificInterceptors, targetSource);
            this.proxyTypes.put(cacheKey, proxy.getClass());
            return proxy;
        }

        return null;
    }

在 AbstractAutowireCapableBeanFactory#createBean()中doCreateBean()创建实例之前：

        try {
            // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            //可以通过后处理器，在这一步返回一个代理实例对象..注意，这里的代理对象不是Spring AOP 逻辑实现的地方。
            //instantiation 实例化不要和init 搞混。
            //后处理器调用点：创建实例之前的一个调用点。
            // 它的另外一个作用就是对AOP提供了支持，在这里会将一些不需要被代理的Bean进行标记
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            //条件成立会形成一个短路操作，这里直接返回了.
            if (bean != null) {
                return bean;
            }
        }

3.2 AbstractAutoProxyCreator作为BeanPostProcessor

这个调用位置是在初始化实例后调用的：

    protected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd) {
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction