目錄
3. 創建AnnotationAwareAspectJAutoProxyCreator
4. 註冊AnnotationAwareAspectJAutoProxyCreator
1. 說明
AnnotationAwareAspectJAutoProxyCreator作爲BeanPostProcessor，在IOC容器初始化的時候，先會創建和註冊到IOC容器中；
2. BeanPostProcessor的創建過程
1) . 通過配置類，創建IOC容器
2). 註冊配置類，調用refresh();刷新容器；
3). 刷新容器過程中，通過registerBeanPostProcessors(beanFactory)註冊所有BeanPostProcessor；
3.1) 先獲取ioc容器已經定義了的需要創建對象的所有BeanPostProcessor
3.2) 給容器中加別的BeanPostProcessor
3.3) 優先註冊實現了PriorityOrdered接口的BeanPostProcessor；
3.4) 再給容器中註冊實現了Ordered接口的BeanPostProcessor；
3.5) 註冊沒實現優先級接口的BeanPostProcessor；
註冊BeanPostProcessor的具體代碼實現在org.springframework.context.support.PostProcessorRegistrationDelegate.registerBeanPostProcessors(ConfigurableListableBeanFactory, AbstractApplicationContext)，代碼如下：
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 獲取所有BeanPostProcessor的name，其中就包含“org.springframework.aop.config.internalAutoProxyCreator”
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
// Register BeanPostProcessorChecker that logs an info message when
// a bean is created during BeanPostProcessor instantiation, i.e. when
// a bean is not eligible for getting processed by all BeanPostProcessors.
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
// Separate between BeanPostProcessors that implement PriorityOrdered,
// Ordered, and the rest.
// 分離實現了PriorityOrdered，Ordered和其他剩下的BeanPostProcessor；
// 實現了PriorityOrdered接口的BeanPostProcessor的集合
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
// 內部BeanPostProcessor
List<BeanPostProcessor> internalPostProcessors = new ArrayList<BeanPostProcessor>();
// 實現了Ordered接口的BeanPostProcessor的name集合
List<String> orderedPostProcessorNames = new ArrayList<String>();
// 其他剩下BeanPostProcessor的name集合
List<String> nonOrderedPostProcessorNames = new ArrayList<String>();
for (String ppName : postProcessorNames) {
if (beanFactory.isTypeMatch(ppName, PriorityOrdered.class)) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
priorityOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
else if (beanFactory.isTypeMatch(ppName, Ordered.class)) {
orderedPostProcessorNames.add(ppName);
}
else {
nonOrderedPostProcessorNames.add(ppName);
}
}
// First, register the BeanPostProcessors that implement PriorityOrdered.
// 排序和註冊實現了PriorityOrdered的BeanPostProcessor，優先級最高
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
// Next, register the BeanPostProcessors that implement Ordered.
// 實現了Ordered接口的BeanPostProcessor集合
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : orderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 排序和註冊實現了Ordered的BeanPostProcessor，優先級次之
sortPostProcessors(orderedPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
// Now, register all regular BeanPostProcessors.
// 其他剩下BeanPostProcessor的name集合
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<BeanPostProcessor>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 註冊其他沒有實現PriorityOrdered和Ordered的BeanPostProcessor，優先級再次之
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
// Finally, re-register all internal BeanPostProcessors.
// 註冊實現了內部的BeanPostProcessor，優先級最小
sortPostProcessors(internalPostProcessors, beanFactory);
registerBeanPostProcessors(beanFactory, internalPostProcessors);
// Re-register post-processor for detecting inner beans as ApplicationListeners,
// moving it to the end of the processor chain (for picking up proxies etc).
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
3. 創建AnnotationAwareAspectJAutoProxyCreator
AnnotationAwareAspectJAutoProxyCreator作爲BeanPostProcessor的子類，在註冊BeanPostProcessor的時候，也會將AnnotationAwareAspectJAutoProxyCreator註冊到IOC容器中，所謂註冊，實際上就是創建BeanPostProcessor對象，初始化之後，保存在容器中，這裏就會創建和註冊AnnotationAwareAspectJAutoProxyCreator，name是“org.springframework.aop.config.internalAutoProxyCreator”；
創建AnnotationAwareAspectJAutoProxyCreator的過程如下：
1). 創建AnnotationAwareAspectJAutoProxyCreator的實例
2). populateBean；給AnnotationAwareAspectJAutoProxyCreator的各種屬性賦值
3). initializeBean：初始化AnnotationAwareAspectJAutoProxyCreator；
3.1). invokeAwareMethods()：處理Aware接口的方法回調
3. 2). applyBeanPostProcessorsBeforeInitialization()：應用後置處理器的postProcessBeforeInitialization（）
3. 3). invokeInitMethods()；執行自定義的初始化方法
3. 4). applyBeanPostProcessorsAfterInitialization()；執行後置處理器的postProcessAfterInitialization（）；
4). BeanPostProcessor(AnnotationAwareAspectJAutoProxyCreator)創建成功；--》aspectJAdvisorsBuilder
代碼實現實現在org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.doCreateBean(String, RootBeanDefinition, Object[])，具體代碼如下：
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
throws BeanCreationException {
// Instantiate the bean.
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 創建組件AnnotationAwareAspectJAutoProxyCreator
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
mbd.resolvedTargetType = beanType;
// Allow post-processors to modify the merged bean definition.
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// Eagerly cache singletons to be able to resolve circular references
// even when triggered by lifecycle interfaces like BeanFactoryAware.
boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletonCurrentlyInCreation(beanName));
if (earlySingletonExposure) {
if (logger.isDebugEnabled()) {
logger.debug("Eagerly caching bean '" + beanName +
"' to allow for resolving potential circular references");
}
addSingletonFactory(beanName, new ObjectFactory<Object>() {
@Override
public Object getObject() throws BeansException {
return getEarlyBeanReference(beanName, mbd, bean);
}
});
}
// Initialize the bean instance.
Object exposedObject = bean;
try {
// 給組件AnnotationAwareAspectJAutoProxyCreator賦值
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
//初始化AnnotationAwareAspectJAutoProxyCreator
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
catch (Throwable ex) {
if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
throw (BeanCreationException) ex;
}
else {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
if (earlySingletonReference != null) {
if (exposedObject == bean) {
exposedObject = earlySingletonReference;
}
else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
String[] dependentBeans = getDependentBeans(beanName);
Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
throw new BeanCurrentlyInCreationException(beanName,
"Bean with name '" + beanName + "' has been injected into other beans [" +
StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
"] in its raw version as part of a circular reference, but has eventually been " +
"wrapped. This means that said other beans do not use the final version of the " +
"bean. This is often the result of over-eager type matching - consider using " +
"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
}
}
}
}
// Register bean as disposable.
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
// 返回創建的組件AnnotationAwareAspectJAutoProxyCreator實例；
return exposedObject;
}
其中org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.initializeBean(String, Object, RootBeanDefinition)的實現如下：
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {
// 調用Aware子接口的方法，因爲AnnotationAwareAspectJAutoProxyCreator實現了BeanFactoryAware接口，所以這裏會調用
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 創建對象初始化的時候，執行已經在容器中的所有BeanPostProcessor的postProcessBeforeInitialization
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 調用組件的自定義所有初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
if (mbd == null || !mbd.isSynthetic()) {
// 創建對象初始化的時候，執行已經在容器中的所有BeanPostProcessor的postProcessAfterInitialization
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
在執行initializeBean的invokeAwareMethods方法的時候，調用到AnnotationAwareAspectJAutoProxyCreator的父接口org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator的setBeanFactory方法，具體代碼如下：
@Override
public void setBeanFactory(BeanFactory beanFactory) {
super.setBeanFactory(beanFactory);
if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
throw new IllegalArgumentException(
"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
}
initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}
其中initBeanFactory調用的是org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator.initBeanFactory(ConfigurableListableBeanFactory)，其代碼如下：
@Override
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
super.initBeanFactory(beanFactory);
// 將BeanFatory包裝到ReflectiveAspectJAdvisorFactory和BeanFactoryAspectJAdvisorsBuilderAdapter，並創建對象
if (this.aspectJAdvisorFactory == null) {
this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
}
this.aspectJAdvisorsBuilder =
new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}
到這裏AnnotationAwareAspectJAutoProxyCreator的實例被創建，且Aware相關接口被調用，接下來是把AnnotationAwareAspectJAutoProxyCreator的實例註冊到IOC容器中；
4. 註冊AnnotationAwareAspectJAutoProxyCreator
將AnnotationAwareAspectJAutoProxyCreator註冊到IOC容器中，具體調用在org.springframework.context.support.PostProcessorRegistrationDelegate.registerBeanPostProcessors(ConfigurableListableBeanFactory, AbstractApplicationContext) 的registerBeanPostProcessors方法，具體實現如下：
/**
* Register the given BeanPostProcessor beans.
*/
private static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
for (BeanPostProcessor postProcessor : postProcessors) {
beanFactory.addBeanPostProcessor(postProcessor);
}
}
到這裏，AnnotationAwareAspectJAutoProxyCreator就已經被創建，且調用AnnotationAwareAspectJAutoProxyCreator的Aware相關接口，然後已經註冊到IOC容器中；