load-time-weaver & spring-configured

public class InstrumentationSavingAgent {

    private static volatile Instrumentation instrumentation;

    public static void premain(String agentArgs, Instrumentation inst) {
        instrumentation = inst;
    }

    public static Instrumentation getInstrumentation() {
        return instrumentation;
    }
}	

@Override
protected String getBeanClassName(Element element) {
    // 如果配置了weaver-class属性，那么使用其值
    if (element.hasAttribute(WEAVER_CLASS_ATTRIBUTE)) {
        return element.getAttribute(WEAVER_CLASS_ATTRIBUTE);
    }
    // org.springframework.context.weaving.DefaultContextLoadTimeWeaver
    return DEFAULT_LOAD_TIME_WEAVER_CLASS_NAME;
}

@Override
protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext 	parserContext) {
    // loadTimeWeaver
    return ConfigurableApplicationContext.LOAD_TIME_WEAVER_BEAN_NAME;
}

@Override
protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
    builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
    if (isAspectJWeavingEnabled(element.getAttribute(ASPECTJ_WEAVING_ATTRIBUTE), parserContext)) {
        if (!parserContext.getRegistry().containsBeanDefinition(ASPECTJ_WEAVING_ENABLER_BEAN_NAME)) {
            RootBeanDefinition def = new RootBeanDefinition(ASPECTJ_WEAVING_ENABLER_CLASS_NAME);
            parserContext.registerBeanComponent(
                    new BeanComponentDefinition(def, ASPECTJ_WEAVING_ENABLER_BEAN_NAME));
        }
        if (isBeanConfigurerAspectEnabled(parserContext.getReaderContext().getBeanClassLoader())) {
            new SpringConfiguredBeanDefinitionParser().parse(element, parserContext);
        }
    }
}

protected boolean isAspectJWeavingEnabled(String value, ParserContext parserContext) {
    if ("on".equals(value)) {
        return true;
    } else if ("off".equals(value)) {
        return false;
    } else {
        // 寻找aop.xml
        ClassLoader cl = parserContext.getReaderContext().getResourceLoader().getClassLoader();
        return (cl.getResource(AspectJWeavingEnabler.ASPECTJ_AOP_XML_RESOURCE) != null);
    }
}

registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());

@Override
public BeanDefinition parse(Element element, ParserContext parserContext) {
    // org.springframework.context.config.internalBeanConfigurerAspect
    if (!parserContext.getRegistry().containsBeanDefinition(BEAN_CONFIGURER_ASPECT_BEAN_NAME)) {
        RootBeanDefinition def = new RootBeanDefinition();
         // org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect
        def.setBeanClassName(BEAN_CONFIGURER_ASPECT_CLASS_NAME);
        def.setFactoryMethodName("aspectOf");
        def.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
        def.setSource(parserContext.extractSource(element));
        parserContext.registerBeanComponent(new BeanComponentDefinition
            (def, BEAN_CONFIGURER_ASPECT_BEAN_NAME));
    }
    return null;
}

public pointcut inConfigurableBean() : @this(Configurable);

public pointcut beanConstruction(Object bean) :
            initialization(ConfigurableObject+.new(..)) && this(bean);

private pointcut preConstructionCondition() :
            leastSpecificSuperTypeConstruction() && preConstructionConfiguration();

public pointcut leastSpecificSuperTypeConstruction() : initialization(ConfigurableObject.new(..));

public pointcut preConstructionConfiguration() : preConstructionConfigurationSupport(*);
private pointcut preConstructionConfigurationSupport(Configurable c) : @this(c) && if (c.preConstruction());

private pointcut postConstructionCondition() :
            mostSpecificSubTypeConstruction() && !preConstructionConfiguration();

public pointcut mostSpecificSubTypeConstruction() :
            if (thisJoinPoint.getSignature().getDeclaringType() == thisJoinPoint.getThis().getClass());

before(Object bean) :
    beanConstruction(bean) && preConstructionCondition() && inConfigurableBean()  {
    configureBean(bean);
}

@Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
    enableAspectJWeaving(this.loadTimeWeaver, this.beanClassLoader);
}

public static void enableAspectJWeaving(LoadTimeWeaver weaverToUse, ClassLoader beanClassLoader) {
    // 不为空
    if (weaverToUse == null) {
        if (InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {
            weaverToUse = new InstrumentationLoadTimeWeaver(beanClassLoader);
        }
        else {
            throw new IllegalStateException("No LoadTimeWeaver available");
        }
    }
    weaverToUse.addTransformer(
            new AspectJClassBypassingClassFileTransformer(new ClassPreProcessorAgentAdapter()));
}

// loadTimeWeaver
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {
    beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    // Set a temporary ClassLoader for type matching.
    beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}

@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) {
    if (bean instanceof LoadTimeWeaverAware) {
        LoadTimeWeaver ltw = this.loadTimeWeaver;
        if (ltw == null) {
            Assert.state(this.beanFactory != null,
                "BeanFactory required if no LoadTimeWeaver explicitly specified");
             // 去容器找 
            ltw = this.beanFactory.getBean(
                ConfigurableApplicationContext.LOAD_TIME_WEAVER_BEAN_NAME, LoadTimeWeaver.class);
        }
        ((LoadTimeWeaverAware) bean).setLoadTimeWeaver(ltw);
    }
    return bean;
}

// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);
// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) {
    Object result = existingBean;
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}

public List<BeanPostProcessor> getBeanPostProcessors() {
    return this.beanPostProcessors;
}

beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));

private void invokeAwareMethods(final String beanName, final Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

@Override
public void setBeanClassLoader(ClassLoader classLoader) {
    LoadTimeWeaver serverSpecificLoadTimeWeaver = createServerSpecificLoadTimeWeaver(classLoader);
    if (serverSpecificLoadTimeWeaver != null) {
        this.loadTimeWeaver = serverSpecificLoadTimeWeaver;
    } else if (InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {
        this.loadTimeWeaver = new InstrumentationLoadTimeWeaver(classLoader);
    } else {
        this.loadTimeWeaver = new ReflectiveLoadTimeWeaver(classLoader);
    }
}

protected LoadTimeWeaver createServerSpecificLoadTimeWeaver(ClassLoader classLoader) {
    String name = classLoader.getClass().getName();
    if (name.startsWith("weblogic")) {
        return new WebLogicLoadTimeWeaver(classLoader);
    } else if (name.startsWith("org.glassfish")) {
        return new GlassFishLoadTimeWeaver(classLoader);
    } else if (name.startsWith("org.apache.catalina")) {
        return new TomcatLoadTimeWeaver(classLoader);
    } else if (name.startsWith("org.jboss")) {
        return new JBossLoadTimeWeaver(classLoader);
    } else if (name.startsWith("com.ibm")) {
        return new WebSphereLoadTimeWeaver(classLoader);
    }
    return null;
}

public static boolean isInstrumentationAvailable() {
    return (getInstrumentation() != null);
}

private static Instrumentation getInstrumentation() {
    if (AGENT_CLASS_PRESENT) {
        return InstrumentationAccessor.getInstrumentation();
    } else {
        return null;
    }
}

private static class InstrumentationAccessor {
    public static Instrumentation getInstrumentation() {
        return InstrumentationSavingAgent.getInstrumentation();
    }
}

public ReflectiveLoadTimeWeaver() {
    this(ClassUtils.getDefaultClassLoader());
}

public ReflectiveLoadTimeWeaver(ClassLoader classLoader) {
    Assert.notNull(classLoader, "ClassLoader must not be null");
    this.classLoader = classLoader;
    this.addTransformerMethod = ClassUtils.getMethodIfAvailable(
            this.classLoader.getClass(), ADD_TRANSFORMER_METHOD_NAME, ClassFileTransformer.class);
    if (this.addTransformerMethod == null) {
        throw new IllegalStateException();
    }
}

@Override
public byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,
        ProtectionDomain protectionDomain, byte[] classfileBuffer) {
    // aspectj自身的类无需检测(织入)，直接跳过
    if (className.startsWith("org.aspectj") || className.startsWith("org/aspectj")) {
        return classfileBuffer;
    }
    return this.delegate.transform(loader, className, classBeingRedefined, 
        protectionDomain, classfileBuffer);
}

<aspectj>
    <aspects>
        <aspect name="org.springframework.beans.factory.aspectj.AnnotationBeanConfigurerAspect"/>
        <aspect name="org.springframework.scheduling.aspectj.AnnotationAsyncExecutionAspect"/>
        <aspect name="org.springframework.transaction.aspectj.AnnotationTransactionAspect"/>
        <aspect name="org.springframework.transaction.aspectj.JtaAnnotationTransactionAspect"/>
        <aspect name="org.springframework.cache.aspectj.AnnotationCacheAspect"/>
        <aspect name="org.springframework.cache.aspectj.JCacheCacheAspect"/>
    </aspects>
</aspectj>

private boolean registerDefinitions(final BcelWeaver weaver, final ClassLoader loader, List<Definition> definitions) {
    //对应<weaver options="-verbose">
    registerOptions(weaver, loader, definitions);
    //对应<exclude>标签
    registerAspectExclude(weaver, loader, definitions);
    //对应<include>标签
    registerAspectInclude(weaver, loader, definitions);
    // <aspect>
    success = registerAspects(weaver, loader, definitions);
    registerIncludeExclude(weaver, loader, definitions);
    //对应<dump>标签
    registerDump(weaver, loader, definitions);
    //忽略返回
}