下面的源碼分析基於Spring版本 5.0.6.RELEASE
目錄
分析創建和註冊AnnotationAwareAspectJAutoProxyCreator的流程
2、接下來重點研究 AnnotationAwareAspectJAutoProxyCreator的創建過程
3、我們來展開分析一下做爲beanPostProcessor後置處理器，究竟做了哪些工作；做爲BeanFactoryAware又做了哪些工作：
3.3、分析方法 registerBeanPostProcessors(beanFactory) ;
3.3.1、創建 internalAutoProxyCreatorr
3.3.2、初始化實例 internalAutoProxyCreator
3.3.3、註冊實現了Ordered接口的BeanPostProcessor；
分析創建和註冊AnnotationAwareAspectJAutoProxyCreator的流程
AnnotationAwareAspectJAutoProxyCreator 翻譯過來其實就叫做 ”註解裝配模式的ASPECT切面自動代理創建器”組件@EnableAspectJAutoProxy 核心從這個入手,AOP整個功能要啓作用,就靠這個註解
1、瞧瞧這個註解都有啥
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
// 關注這個引入的類，這是整個AOP的入口
@Import(AspectJAutoProxyRegistrar.class)
public @interface EnableAspectJAutoProxy {
/**
* 採用JDK動態代理織入增強(實現接口的方式)；如果設爲true，則採用CGLIB動態代理織入增強
*/
boolean proxyTargetClass() default false;
/**
* 通過aop框架暴露該代理對象，讓aopContext能夠訪問
*/
boolean exposeProxy() default false;
}
當 AbstractApplicationContext 執行 refresh()方法時，在 invokeBeanFactoryPostProcessors(beanFactory) 方法執行時會回調所有實現了接口 ImportBeanDefinitionRegistrar 的 registerBeanDefinitions 方法
class AspectJAutoProxyRegistrar implements ImportBeanDefinitionRegistrar {
@Override
public void registerBeanDefinitions(
AnnotationMetadata importingClassMetadata, BeanDefinitionRegistry registry) {
// 註冊組件 AnnotationAwareAspectJAutoProxyCreator.class，關注這行
AopConfigUtils.registerAspectJAnnotationAutoProxyCreatorIfNecessary(registry);
AnnotationAttributes enableAspectJAutoProxy =
AnnotationConfigUtils.attributesFor(importingClassMetadata, EnableAspectJAutoProxy.class);
if (enableAspectJAutoProxy != null) {
if (enableAspectJAutoProxy.getBoolean("proxyTargetClass")) {
AopConfigUtils.forceAutoProxyCreatorToUseClassProxying(registry);
}
if (enableAspectJAutoProxy.getBoolean("exposeProxy")) {
AopConfigUtils.forceAutoProxyCreatorToExposeProxy(registry);
}
}
}
}
// org.springframework.aop.config.AopConfigUtils.java line 103 ，註冊組件
public static BeanDefinition registerAspectJAnnotationAutoProxyCreatorIfNecessary(BeanDefinitionRegistry registry,
@Nullable Object source) {
return
// 註冊或升級 AnnotationAwareAspectJAutoProxyCreator.class，第一次我們只關注註冊
registerOrEscalateApcAsRequired(AnnotationAwareAspectJAutoProxyCreator.class, registry, source);
}
跟進代碼看看，這裏會註冊一個名爲 org.springframework.aop.config.internalAutoProxyCreator 的組件
private static BeanDefinition registerOrEscalateApcAsRequired(Class<?> cls, BeanDefinitionRegistry registry,
@Nullable Object source) {
Assert.notNull(registry, "BeanDefinitionRegistry must not be null");
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;
}
RootBeanDefinition beanDefinition = new RootBeanDefinition(cls);
beanDefinition.setSource(source);
beanDefinition.getPropertyValues().add("order", Ordered.HIGHEST_PRECEDENCE);
beanDefinition.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
// 真正註冊組件的地方，該常量名爲：org.springframework.aop.config.internalAutoProxyCreator
registry.registerBeanDefinition(AUTO_PROXY_CREATOR_BEAN_NAME, beanDefinition);
return beanDefinition;
}
2、接下來重點研究 AnnotationAwareAspectJAutoProxyCreator的創建過程
先來一張類繼承關係圖
SmartInstantiationAwareBeanPostProcessor: bean的後置處理器；
BeanFactoryAware 能把beanFacotry bean工廠傳進來 ；
通過分析以上的bean繼承關係我們發現,具有BeanPostProcessor特點, 也有Aware接口的特點, 實現了BeanFactoryAware 接口；
3、我們來展開分析一下做爲beanPostProcessor後置處理器，究竟做了哪些工作；做爲BeanFactoryAware又做了哪些工作：
3.1、register()傳入配置類，準備創建ioc容器
// org.springframework.context.annotation.AnnotationConfigApplicationContext line 87
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
// 註冊配置類，跟進去看
register(annotatedClasses);
refresh();
}
// org.springframework.context.annotation.AnnotatedBeanDefinitionReader line 213
<T> void doRegisterBean(Class<T> annotatedClass, @Nullable Supplier<T> instanceSupplier, @Nullable String name,
@Nullable Class<? extends Annotation>[] qualifiers, BeanDefinitionCustomizer... definitionCustomizers) {
AnnotatedGenericBeanDefinition abd = new AnnotatedGenericBeanDefinition(annotatedClass);
if (this.conditionEvaluator.shouldSkip(abd.getMetadata())) {
return;
}
abd.setInstanceSupplier(instanceSupplier);
ScopeMetadata scopeMetadata = this.scopeMetadataResolver.resolveScopeMetadata(abd);
abd.setScope(scopeMetadata.getScopeName());
String beanName = (name != null ? name : this.beanNameGenerator.generateBeanName(abd, this.registry));
AnnotationConfigUtils.processCommonDefinitionAnnotations(abd);
if (qualifiers != null) {
for (Class<? extends Annotation> qualifier : qualifiers) {
if (Primary.class == qualifier) {
abd.setPrimary(true);
}
else if (Lazy.class == qualifier) {
abd.setLazyInit(true);
}
else {
abd.addQualifier(new AutowireCandidateQualifier(qualifier));
}
}
}
for (BeanDefinitionCustomizer customizer : definitionCustomizers) {
customizer.customize(abd);
}
BeanDefinitionHolder definitionHolder = new BeanDefinitionHolder(abd, beanName);
definitionHolder = AnnotationConfigUtils.applyScopedProxyMode(scopeMetadata, definitionHolder, this.registry);
// 註冊BeanDefinition
BeanDefinitionReaderUtils.registerBeanDefinition(definitionHolder, this.registry);
}
3.2、調用refresh（）刷新創建容器；
// org.springframework.context.annotation.AnnotationConfigApplicationContext line 88
public AnnotationConfigApplicationContext(Class<?>... annotatedClasses) {
this();
register(annotatedClasses);
// 刷新創建容器
refresh();
}
public void refresh() throws BeansException, IllegalStateException {
// 來個鎖，不然 refresh() 還沒結束，你又來個啓動或銷燬容器的操作，那不就亂套了嘛
synchronized (this.startupShutdownMonitor) {
// 準備工作，記錄下容器的啓動時間、標記“已啓動”狀態、處理配置文件中的佔位符
prepareRefresh();
// ☆☆，這步完成後，配置文件就會解析成一個個 Bean 定義，註冊到 BeanFactory 中，
// 當然，這裏說的 Bean 還沒有初始化，只是配置信息都提取出來了，
// 註冊也只是將這些信息都保存到了ioc容器中
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
// 設置 BeanFactory 的類加載器，添加幾個 BeanPostProcessor，手動註冊幾個特殊的 bean
prepareBeanFactory(beanFactory);
try {
// 這裏是提供給子類的擴展點，到這裏的時候，所有的 Bean 都加載、註冊完成了，但是都還沒有初始化
// 具體的子類可以在這步的時候添加一些特殊的 BeanFactoryPostProcessor 的實現類或做點什麼事
postProcessBeanFactory(beanFactory);
// 調用 BeanFactoryPostProcessor 各個實現類的 postProcessBeanFactory(factory) 方法
invokeBeanFactoryPostProcessors(beanFactory);
// 註冊 BeanPostProcessor 的實現類，注意看和 BeanFactoryPostProcessor 的區別
// BeanPostProcessor接口有兩個方法: postProcessBeforeInitialization 和 postProcessAfterInitialization
// 而BeanFactoryPostProcessor接口只有一個方法：postProcessBeanFactory
// 兩個方法分別在 Bean 初始化之前和初始化之後得到執行。注意，到這裏 Bean 還沒初始化
registerBeanPostProcessors(beanFactory);
// 初始化當前 ApplicationContext 的 MessageSource，國際化相關代碼略過不談
initMessageSource();
// 初始化當前 ApplicationContext 的事件廣播器，這裏也不展開了
initApplicationEventMulticaster();
// 典型的模板方法，具體的子類可以在這裏初始化一些特殊的 Bean（在初始化 singleton beans 之前）
onRefresh();
// 註冊事件監聽器，監聽器需要實現 ApplicationListener 接口。這也不是我們的重點，過
registerListeners();
// ★★★★，初始化所有的 singleton beans，lazy-init 的除外，圈起來，重點必考題
finishBeanFactoryInitialization(beanFactory);
// 最後，廣播事件，ApplicationContext 初始化完成
finishRefresh();
}
catch (BeansException ex) {
if (logger.isWarnEnabled()) {
logger.warn("Exception encountered during context initialization - " +
"cancelling refresh attempt: " + ex);
}
// 銷燬已經初始化的 singleton 的 Beans，以免有些 bean 會一直佔用資源
destroyBeans();
// Reset 'active' flag.
cancelRefresh(ex);
// Propagate exception to caller.
throw ex;
}
finally {
// Reset common introspection caches in Spring's core, since we
// might not ever need metadata for singleton beans anymore...
resetCommonCaches();
}
}
}
3.3、分析方法 registerBeanPostProcessors(beanFactory) ;
註冊bean的後置處理器，用來攔截其他bean的創建(主要關注在哪裏註冊AnnotationAwareAspectJAutoProxyCreator)；
protected void registerBeanPostProcessors(ConfigurableListableBeanFactory beanFactory) {
PostProcessorRegistrationDelegate.registerBeanPostProcessors(beanFactory, this);
}
- 先獲取ioc容器已經定義了的需要創建對象的所有BeanPostProcessor
- 給容器中加別的BeanPostProcessor
- 優先註冊實現了PriorityOrdered接口的BeanPostProcessor；
-
創建後置處理器 internalAutoProxyCreator
- 註冊實現了Ordered接口的BeanPostProcessor；
- 註冊沒實現優先級接口的BeanPostProcessor；
- 最後註冊Spring內部的BeanPostProcessor；
// org.springframework.context.support.PostProcessorRegistrationDelegate line 186
public static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, AbstractApplicationContext applicationContext) {
// 1）、 先獲取ioc容器已經定義了的需要創建對象的所有BeanPostProcessor
String[] postProcessorNames = beanFactory.getBeanNamesForType(BeanPostProcessor.class, true, false);
int beanProcessorTargetCount = beanFactory.getBeanPostProcessorCount() + 1 + postProcessorNames.length;
// 2）、給容器中加額外的BeanPostProcessor
beanFactory.addBeanPostProcessor(new BeanPostProcessorChecker(beanFactory, beanProcessorTargetCount));
List<BeanPostProcessor> priorityOrderedPostProcessors = new ArrayList<>();
List<BeanPostProcessor> internalPostProcessors = new ArrayList<>();
List<String> orderedPostProcessorNames = new ArrayList<>();
List<String> nonOrderedPostProcessorNames = new ArrayList<>();
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);
}
}
sortPostProcessors(priorityOrderedPostProcessors, beanFactory);
// 3）、優先註冊實現了PriorityOrdered接口的BeanPostProcessor；
registerBeanPostProcessors(beanFactory, priorityOrderedPostProcessors);
List<BeanPostProcessor> orderedPostProcessors = new ArrayList<>();
for (String ppName : orderedPostProcessorNames) {
// 4）、☆☆☆ 創建後置處理器 internalAutoProxyCreator，下文會單獨講解
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
orderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
sortPostProcessors(orderedPostProcessors, beanFactory);
/* 5）、☆再給容器中註冊實現了Ordered接口的BeanPostProcessor,其中 AnnotationAwareAspectJAutoProxyCreator 就是在這裏進行註冊的*/
registerBeanPostProcessors(beanFactory, orderedPostProcessors);
List<BeanPostProcessor> nonOrderedPostProcessors = new ArrayList<>();
for (String ppName : nonOrderedPostProcessorNames) {
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);
nonOrderedPostProcessors.add(pp);
if (pp instanceof MergedBeanDefinitionPostProcessor) {
internalPostProcessors.add(pp);
}
}
// 6）、註冊沒實現優先級接口的BeanPostProcessor；
registerBeanPostProcessors(beanFactory, nonOrderedPostProcessors);
sortPostProcessors(internalPostProcessors, beanFactory);
// 7）、註冊Spring已經創建好的BeanPostProcessor；
registerBeanPostProcessors(beanFactory, internalPostProcessors);
beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(applicationContext));
}
接下來分三個步驟講解，分別是創建實例，初始化實例，初始化包含（應用工廠回調以及init方法和bean後處理器）；這兩個小步驟是上文中的 創建後置處理器 internalAutoProxyCreator 的拆分；然後講解 註冊實現了Ordered接口的BeanPostProcessor；
3.3.1、創建 internalAutoProxyCreatorr
【其實就是AnnotationAwareAspectJAutoProxyCreator】，代碼跟到上述代碼中提到的第4）點，對應代碼
BeanPostProcessor pp = beanFactory.getBean(ppName, BeanPostProcessor.class);跟進去瞅瞅；
// org.springframework.beans.factory.support.AbstractBeanFactory line 239
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
final String beanName = transformedBeanName(name);
Object bean;
// 容器此時還沒有該Bean,返回 null
Object sharedInstance = getSingleton(beanName);
// 此處忽略部分代碼 ···
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// 調用父類的父類的方法創建bean
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// 此處忽略部分代碼 ···
}
這裏看一下Bean工廠的繼承關係，當前Bean工廠爲 強悍的DefaultListableBeanFactory，向上轉型成 AbstractBeanFactory，執行AbstractBeanFactory的方法 createBean(beanName, mbd, args)，該方法是在其父類的父類 DefaultSingletonBeanRegistry 中定義的，被其子類 AbstractAutowireCapableBeanFactory 重寫，所以下面關注 AbstractAutowireCapableBeanFactory 這個類；
我們看看類 AbstractAutowireCapableBeanFactory 的 方法
createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 501
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
throws BeanCreationException {
if (logger.isDebugEnabled()) {
logger.debug("Creating instance of bean '" + beanName + "'");
}
RootBeanDefinition mbdToUse = mbd;
// 解析bean的類型
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 處理override method方法
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 返回代理對象，AOP的實現基礎就是基於這裏來實現的，後續講被切面攔截的對象創建時會詳細講解，這裏暫時略過
Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
if (bean != null) {
return bean;
}
}
catch (Throwable ex) {
throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
"BeanPostProcessor before instantiation of bean failed", ex);
}
try {
// ☆☆☆☆ 創建對象，此時beanName = "org.springframework.aop.config.internalAutoProxyCreator",args = null;
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean '" + beanName + "'");
}
return beanInstance;
}
// catch 部分代碼省略···
}
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 532
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// bean實例包裝類，用於操作bean的屬性
BeanWrapper instanceWrapper = null;
// 如果是單例的話，則先把工廠bean緩存中的同名bean清除
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// ☆☆ 創建bean實例，下面的代碼會講解，看看註釋瞭解即可。
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
final Object bean = instanceWrapper.getWrappedInstance();
// 獲取BeanWrapper中封裝的bean的Class
Class<?> beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
synchronized (mbd.postProcessingLock) {
if (!mbd.postProcessed) {
try {
// bean 的生命週期之一。如果實現了MergedBeanDefinitionPostProcessor會在這裏調用postProcessMergedBeanDefinition方法
applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
}
catch (Throwable ex) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Post-processing of merged bean definition failed", ex);
}
mbd.postProcessed = true;
}
}
// 如果RootBeanDefinition是單例的，並且開啓了自動嘗試解析bean之間的循環引用，並且當前bean正在創建中，則將其加入單例工廠緩存singletonFactories中，是個Map<String, ObjectFactory<?>>
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");
}
/* 將 org.springframework.aop.config.internalAutoProxyCreator 加入單例工廠緩存singletonFactories，以下截取了主要代碼進行展示
this.singletonFactories.put(beanName, singletonFactory);
this.earlySingletonObjects.remove(beanName);
this.registeredSingletons.add(beanName);
*/
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 對已有的bean的實例初始化 一般情況下依賴注入就在這裏發生
Object exposedObject = bean;
try {
// 填充bean的屬性
populateBean(beanName, mbd, instanceWrapper);
// ☆☆☆ 初始化bean的實例，應用工廠回調以及init方法和bean後處理器
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) {
// 從BeanFactory的單例緩存中獲取bean的實例
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<>(dependentBeans.length);
// 處理循環依賴
for (String dependentBean : dependentBeans) {
if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
actualDependentBeans.add(dependentBean);
}
}
if (!actualDependentBeans.isEmpty()) {
// throw 部分代碼省略···
}
}
}
}
// 註冊bean的銷燬邏輯
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
接着上述代碼中的 帶有註釋【☆☆ 創建bean實例】的行，簡單講解下
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 1135
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 此處 beanClass = org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// 中間省略大量代碼，最終會執行到這行，即使用無參構造函數創建Bean
return instantiateBean(beanName, mbd);
}
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 1228
protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
try {
Object beanInstance;
final BeanFactory parent = this;
if (System.getSecurityManager() != null) {
beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
getInstantiationStrategy().instantiate(mbd, beanName, parent),
getAccessControlContext());
}
else {
// 實例化bean,跟上節奏，別掉隊
beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
}
// 將實例化的 bean 進行包裝
BeanWrapper bw = new BeanWrapperImpl(beanInstance);
initBeanWrapper(bw);
return bw;
}
// catch 部分代碼省略···
}
// 此時代碼跳轉到了 org.springframework.beans.factory.support.SimpleInstantiationStrategy.java line 61
public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
if (!bd.hasMethodOverrides()) {
Constructor<?> constructorToUse;
// 省略部分代碼 ···
// 使用 springframework 內部工具類創建實例，跟進去看看
return BeanUtils.instantiateClass(constructorToUse);
}
else {
return instantiateWithMethodInjection(bd, beanName, owner);
}
}
// org.springframework.beans.BeanUtils line 170
public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
Assert.notNull(ctor, "Constructor must not be null");
try {
ReflectionUtils.makeAccessible(ctor);
// 跟進 ctor.newInstance(args)
return (KotlinDetector.isKotlinType(ctor.getDeclaringClass()) ?
KotlinDelegate.instantiateClass(ctor, args) : ctor.newInstance(args));
}
// catch 異常部分代碼略
}
// java.lang.reflect.Constructor.java line 423
public T newInstance(Object ... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{
// 省略部分代碼···
@SuppressWarnings("unchecked")
// 創建 bean 的終點站到啦！！！這裏利用java 反射原理創建實例
T inst = (T) ca.newInstance(initargs);
return inst;
}
到此爲止，實例已經創建完畢，接下來我看看bean 的初始化
3.3.2、初始化實例 internalAutoProxyCreator
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
// 3.3.2.1：處理Aware接口的方法回調
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 3.3.2.2：應用後置處理器的postProcessBeforeInitialization（）
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 3.3.2.3：執行自定義的初始化方法
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()) {
// 3.3.2.4：執行後置處理器的postProcessAfterInitialization（）；
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}
分別解析一下上述代碼中含註釋的部分
3.3.2.1、處理Aware接口的方法回調
private void invokeAwareMethods(final String beanName, final Object bean) {
// 如果沒有實現Aware接口，直接退出方法了；這裏顯然是實現了
if (bean instanceof Aware) {
// 沒有實現 BeanNameAware
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
// 判斷成功，設置類加載器
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
// ☆☆ 判斷成功，設置 bean 工廠
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
// org.springframework.aop.framework.autoproxy.AbstractAdvisorAutoProxyCreator.java line 57
public void setBeanFactory(BeanFactory beanFactory) {
// 調用父類方法設置工廠
super.setBeanFactory(beanFactory);
if (!(beanFactory instanceof ConfigurableListableBeanFactory)) {
throw new IllegalArgumentException(
"AdvisorAutoProxyCreator requires a ConfigurableListableBeanFactory: " + beanFactory);
}
// 初始化 bean 工廠，跟進去摟一眼
initBeanFactory((ConfigurableListableBeanFactory) beanFactory);
}
// org.springframework.aop.aspectj.annotation.AnnotationAwareAspectJAutoProxyCreator.java line 79
protected void initBeanFactory(ConfigurableListableBeanFactory beanFactory) {
super.initBeanFactory(beanFactory);
if (this.aspectJAdvisorFactory == null) {
// 創建了ReflectiveAspectJAdvisorFactory反射機制,相當於把aspectJAdvisorFactory對象通知工廠
this.aspectJAdvisorFactory = new ReflectiveAspectJAdvisorFactory(beanFactory);
}
// 通知適配器,相當於aspectJAdvisorFactory通知到構建器的適配器, 把aspectJAdvisorFactory重新包裝了一下
this.aspectJAdvisorsBuilder =
new BeanFactoryAspectJAdvisorsBuilderAdapter(beanFactory, this.aspectJAdvisorFactory);
}
3.3.2.2、應用後置處理器的postProcessBeforeInitialization();
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 417
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
/*在這裏接收來自Spring內部的後置處理器的洗禮（postProcessBefore），後置處理大禮包走起
org.springframework.context.support.ApplicationContextAwareProcessor
org.springframework.context.support.ApplicationListenerDetector
org.springframework.context.annotation.ConfigurationClassPostProcessor
org.springframework.context.support.PostProcessorRegistrationDelegate
org.springframework.context.annotation.CommonAnnotationBeanPostProcessor
org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor
*/
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
Object current = beanProcessor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
3.3.2.3、執行自定義的初始化方法
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 1745
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
// 省略部分代碼···
if (mbd != null && bean.getClass() != NullBean.class) {
// 其實就是聲明@Bean註解的時候,指定初始化方法或銷燬方法是什麼,在這裏執行；當前實例類沒有設置初始化方法，這裏跳過
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
3.3.2.4、執行後置處理器的postProcessAfterInitialization();
// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory.java line 432
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
// 同上，在這裏接收來自Spring內部的後置處理器的洗禮（postProcessAfter）
Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
好了，實例已經創建和初始化完畢了，接下來看看最後一步，
3.3.3、註冊實現了Ordered接口的BeanPostProcessor；
代碼回到 org.springframework.context.support.PostProcessorRegistrationDelegate line 233
registerBeanPostProcessors(beanFactory, internalPostProcessors);
如果到現在頭還沒暈，恭喜你，獲得最強大腦榮譽勳章一枚！深吸一口氣，馬上就結束了，跟進去看看
private static void registerBeanPostProcessors(
ConfigurableListableBeanFactory beanFactory, List<BeanPostProcessor> postProcessors) {
// 將創建成功的BeanPostProcessor對象加入工廠,AOP核心對象創建完成
for (BeanPostProcessor postProcessor : postProcessors) {
beanFactory.addBeanPostProcessor(postProcessor);
}
}