spring中load-time-weaver静态aop处理，基于aspectJ的静态aop处理

前面我们已经探讨过基于spring的动态aop处理 spring动态aop处理 spring同时也遵循了aop的标准，提供了静态aop的处理方式。
spring的配置增加如下配置开启静态aop：

 <context:load-time-weaver/>

可以看到，这里对应的schema是context，我们在spring-context模块下META-IUNF/spring.handlers中发现内容如下：

http\://www.springframework.org/schema/context=org.springframework.context.config.ContextNamespaceHandler
http\://www.springframework.org/schema/jee=org.springframework.ejb.config.JeeNamespaceHandler
http\://www.springframework.org/schema/lang=org.springframework.scripting.config.LangNamespaceHandler
http\://www.springframework.org/schema/task=org.springframework.scheduling.config.TaskNamespaceHandler
http\://www.springframework.org/schema/cache=org.springframework.cache.config.CacheNamespaceHandler

其中context对应处理类为：org.springframework.context.config.ContextNamespaceHandler：

public class ContextNamespaceHandler extends NamespaceHandlerSupport {@Overridepublic void init() {registerBeanDefinitionParser("property-placeholder", new PropertyPlaceholderBeanDefinitionParser());registerBeanDefinitionParser("property-override", new PropertyOverrideBeanDefinitionParser());registerBeanDefinitionParser("annotation-config", new AnnotationConfigBeanDefinitionParser());registerBeanDefinitionParser("component-scan", new ComponentScanBeanDefinitionParser());registerBeanDefinitionParser("load-time-weaver", new LoadTimeWeaverBeanDefinitionParser());registerBeanDefinitionParser("spring-configured", new SpringConfiguredBeanDefinitionParser());registerBeanDefinitionParser("mbean-export", new MBeanExportBeanDefinitionParser());registerBeanDefinitionParser("mbean-server", new MBeanServerBeanDefinitionParser());}}

load-time-weaver解析类为： LoadTimeWeaverBeanDefinitionParser.解析逻辑主要集中在doParse方法中：


protected String getBeanClassName(Element element) {if (element.hasAttribute(WEAVER_CLASS_ATTRIBUTE)) {return element.getAttribute(WEAVER_CLASS_ATTRIBUTE);}return DEFAULT_LOAD_TIME_WEAVER_CLASS_NAME;}@Overrideprotected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext) {return ConfigurableApplicationContext.LOAD_TIME_WEAVER_BEAN_NAME;}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 {// Determine default...ClassLoader cl = parserContext.getReaderContext().getBeanClassLoader();return (cl != null && cl.getResource(AspectJWeavingEnabler.ASPECTJ_AOP_XML_RESOURCE) != null);}}

判断是否启用AspectJ的逻辑是：

如果配置aspectj-weaving=on则表示开启
如果配置aspectj-weaving=off则表示不开启，关闭
其他情况，判断当前环境下是否存在META-INF/aop.xml,如果存在，表示开启AspectJ

如果确认需要开启AspectJ，则会向IOC容器中，注册org.springframework.context.weaving.AspectJWeavingEnabler和

org.springframework.context.weaving.DefaultContextLoadTimeWeaver

`这里DefaultContextLoadTimeWeaver是默认实现，如果在 \<context:load-time-weaver weaver-class="xxxx.xxx"/> 配置了`weaver-class`这里会注册该类`

这两个对应名称为：
ASPECTJ_WEAVING_ENABLER_BEAN_NAME =
“org.springframework.context.config.internalAspectJWeavingEnabler” -> AspectJWeavingEnabler

上面这几步，完成了AspectJ的相关准备工作，但是并没有进行织入，前面我们在研究spring容器启动过程分析的时候，有一步是进行AspectJ的织入。
spring容器启动过程分析

在AbstactApplicationContext.invokeBeanFactoryPostProcessors时候，会加入LoadTimeWeaverAwareProcessor

 protected void invokeBeanFactoryPostProcessors(ConfigurableListableBeanFactory beanFactory) {PostProcessorRegistrationDelegate.invokeBeanFactoryPostProcessors(beanFactory, getBeanFactoryPostProcessors());// Detect a LoadTimeWeaver and prepare for weaving, if found in the meantime// (e.g. through an @Bean method registered by ConfigurationClassPostProcessor)if (beanFactory.getTempClassLoader() == null && beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) {beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));}}

LoadTimeWeaverAwareProcessor.postProcessBeforeInitialization逻辑：

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {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;}

这里首先会判断当前处理bean是否是LoadTimeWeaverAware，整个spirng中只有前面提到的AspectJWeavingEnabler实现了该接口。
而此时this.loadTimeWeaver并没有实例化，直接通过getBean获取，此时获取的就是之前说过的DefaultContextLoadTimeWeaver(或者手动指定）。
DefaultContextLoadTimeWeaver实现了BeanClassLoaderAware接口，在其setBeanClassLoader逻辑：

// DefaultContextLoadTimeWeaver.java
public void setBeanClassLoader(ClassLoader classLoader) {LoadTimeWeaver serverSpecificLoadTimeWeaver = createServerSpecificLoadTimeWeaver(classLoader);if (serverSpecificLoadTimeWeaver != null) {if (logger.isDebugEnabled()) {logger.debug("Determined server-specific load-time weaver: " +serverSpecificLoadTimeWeaver.getClass().getName());}this.loadTimeWeaver = serverSpecificLoadTimeWeaver;}else if (InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {logger.debug("Found Spring's JVM agent for instrumentation");this.loadTimeWeaver = new InstrumentationLoadTimeWeaver(classLoader);}else {try {this.loadTimeWeaver = new ReflectiveLoadTimeWeaver(classLoader);if (logger.isDebugEnabled()) {logger.debug("Using reflective load-time weaver for class loader: " +this.loadTimeWeaver.getInstrumentableClassLoader().getClass().getName());}}catch (IllegalStateException ex) {throw new IllegalStateException(ex.getMessage() + " Specify a custom LoadTimeWeaver or start your " +"Java virtual machine with Spring's agent: -javaagent:org.springframework.instrument.jar");}}}

其中：

else if (InstrumentationLoadTimeWeaver.isInstrumentationAvailable()) {
logger.debug(“Found Spring’s JVM agent for instrumentation”);
this.loadTimeWeaver = new InstrumentationLoadTimeWeaver(classLoader);
}

经过上述处理后，

AspectJWeavingEnabler.loadTimeWeaver = DefaultContextLoadTimeWeaver

DefaultContextLoadTimeWeaver.loadTimeWeaver = InstrumentationLoadTimeWeaver

AspectJWeavingEnabler同时实现了BeanFactoryPostProcessor，其postProcessBeanFactory实现如下：

// AspectJWeavingEnabler.java
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {enableAspectJWeaving(this.loadTimeWeaver, this.beanClassLoader);}/*** Enable AspectJ weaving with the given {@link LoadTimeWeaver}.* @param weaverToUse the LoadTimeWeaver to apply to (or {@code null} for a default weaver)* @param beanClassLoader the class loader to create a default weaver for (if necessary)*/public static void enableAspectJWeaving(@Nullable LoadTimeWeaver weaverToUse, @Nullable 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()));}/*** ClassFileTransformer decorator that suppresses processing of AspectJ* classes in order to avoid potential LinkageErrors.* @see org.springframework.context.annotation.LoadTimeWeavingConfiguration*/private static class AspectJClassBypassingClassFileTransformer implements ClassFileTransformer {private final ClassFileTransformer delegate;public AspectJClassBypassingClassFileTransformer(ClassFileTransformer delegate) {this.delegate = delegate;}@Overridepublic byte[] transform(ClassLoader loader, String className, Class<?> classBeingRedefined,ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {if (className.startsWith("org.aspectj") || className.startsWith("org/aspectj")) {return classfileBuffer;}// 委托给AspectJ继续处理return this.delegate.transform(loader, className, classBeingRedefined, protectionDomain, classfileBuffer);}}