不得不說,對我們這種平庸的人,學習源碼是痛苦的
接着上文
1. doCreateBean >> applyMergedBeanDefinitionPostProcessors
/**
* 將MergedBeanDefinitionPostProcessors應用於指定的bean定義,
* 調用它們的postProcessMergedBeanDefinition方法。
*/
protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd,
Class<?> beanType, String beanName) {
// 1.獲取BeanFactory中已註冊的BeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof MergedBeanDefinitionPostProcessor) {
// 2.調用MergedBeanDefinitionPostProcessor
// 的postProcessMergedBeanDefinition方法,
// 對指定bean的給定MergedBeanDefinition
// 進行後置處理,@Autowire註解在這邊對元數據進行預解析
MergedBeanDefinitionPostProcessor bdp =
(MergedBeanDefinitionPostProcessor) bp;
bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
}
}
}
2. doCreateBean >> addSingletonFactory
提前曝光 beanName 的 ObjectFactory,用於解決循環引用,我們在preInstantiateSingletons方法中的getSingleton,通過提前曝光的ObjectFactory獲得“不完整”的bean實例,從而解決循環引用的問題,ObjectFactory就是通過這邊的singletonObjects緩存來進行曝光的。
protected void addSingletonFactory(String beanName,
ObjectFactory<?> singletonFactory) {
Assert.notNull(singletonFactory, "Singleton factory must not be null");
synchronized (this.singletonObjects) {
// 1.如果beanName不存在於singletonObjects緩存中
if (!this.singletonObjects.containsKey(beanName)) {
// 2.將beanName和singletonFactory註冊到
// singletonFactories緩存(beanName -> 該beanName的單例工廠)
this.singletonFactories.put(beanName, singletonFactory);
// 3.移除earlySingletonObjects緩存中的beanName
//(beanName -> beanName的早期單例對象)
this.earlySingletonObjects.remove(beanName);
// 4.將beanName註冊到registeredSingletons緩存(已經註冊的單例集合)
this.registeredSingletons.add(beanName);
}
}
}
3. doCreateBean >> getEarlyBeanReference
允許返回指定bean的早期引用,若沒有則直接返回bean
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
Object exposedObject = bean;
// 1.mbd不是合成 && 存在InstantiationAwareBeanPostProcessors
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
// 2.應用所有SmartInstantiationAwareBeanPostProcessor,
// 調用getEarlyBeanReference方法
if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
SmartInstantiationAwareBeanPostProcessor ibp =
(SmartInstantiationAwareBeanPostProcessor) bp;
// 3.允許SmartInstantiationAwareBeanPostProcessor返回指定bean的早期引用
exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
}
}
}
// 4.返回要作爲bean引用公開的對象,
// 如果沒有SmartInstantiationAwareBeanPostProcessor修改,
// 則返回的是入參的bean對象本身
return exposedObject;
}
4. doCreateBean >> populateBean
對bean進行屬性填充
protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
// 1.bw爲空時的處理
if (bw == null) {
if (mbd.hasPropertyValues()) {
// 2.1 如果bw爲空,屬性不爲空,拋異常,無法將屬性值應用於null實例
throw new BeanCreationException(
mbd.getResourceDescription(), beanName,
"Cannot apply property values to null instance");
}
else {
// Skip property population phase for null instance.
// 2.2 如果bw爲空,屬性也爲空,則跳過
return;
}
}
// Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
// state of the bean before properties are set. This can be used, for example,
// to support styles of field injection.
// 2.用於標識是否繼續之後的屬性填充
boolean continueWithPropertyPopulation = true;
// 3.1 如果mbd不是合成的
// && 存在InstantiationAwareBeanPostProcessor,則遍歷處理InstantiationAwareBeanPostProcessor
if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
// 3.2 在bean實例化後,屬性填充之前被調用,
// 允許修改bean的屬性,如果返回false,則跳過之後的屬性填充
if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
// 3.3 如果返回false,將continueWithPropertyPopulation賦值爲false,
// 代表要跳過之後的屬性填充
continueWithPropertyPopulation = false;
break;
}
}
}
}
// 3.4 如果continueWithPropertyPopulation爲false,則跳過之後的屬性填充
if (!continueWithPropertyPopulation) {
return;
}
// 返回此bean的屬性值
PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
int resolvedAutowireMode = mbd.getResolvedAutowireMode();
// 4.解析自動裝配模式爲AUTOWIRE_BY_NAME和AUTOWIRE_BY_TYPE
if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
// Add property values based on autowire by name if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
// 4.1 解析autowireByName的注入
autowireByName(beanName, mbd, bw, newPvs);
}
// Add property values based on autowire by type if applicable.
if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
// 4.2 解析autowireByType的注入
autowireByType(beanName, mbd, bw, newPvs);
}
pvs = newPvs;
}
// 5.BeanFactory是否註冊過InstantiationAwareBeanPostProcessors
boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
// 6.是否需要依賴檢查
boolean needsDepCheck =
(mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);
PropertyDescriptor[] filteredPds = null;
// 7.註冊過InstantiationAwareBeanPostProcessors
if (hasInstAwareBpps) {
if (pvs == null) {
pvs = mbd.getPropertyValues();
}
// 7.1 應用後置處理器InstantiationAwareBeanPostProcessor
for (BeanPostProcessor bp : getBeanPostProcessors()) {
if (bp instanceof InstantiationAwareBeanPostProcessor) {
InstantiationAwareBeanPostProcessor ibp =
(InstantiationAwareBeanPostProcessor) bp;
PropertyValues pvsToUse =
ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
if (filteredPds == null) {
filteredPds =
filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 7.1.1 應用後置處理器InstantiationAwareBeanPostProcessor的方法
// postProcessPropertyValues,進行屬性填充前的再次處理。
// 例子:現在最常用的@Autowire屬性注入就是這邊注入依賴的bean實例對象
pvsToUse = ibp.postProcessPropertyValues(pvs,
filteredPds, bw.getWrappedInstance(), beanName);
if (pvsToUse == null) {
return;
}
}
pvs = pvsToUse;
}
}
}
if (needsDepCheck) {
if (filteredPds == null) {
filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
}
// 7.2 依賴檢查,對應depends-on屬性
checkDependencies(beanName, mbd, filteredPds, pvs);
}
if (pvs != null) {
// 8.將所有PropertyValues中的屬性填充到bean中
applyPropertyValues(beanName, mbd, bw, pvs);
}
}
5. populateBean >>autowireByName
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
// 1.尋找bw中需要依賴注入的屬性
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
for (String propertyName : propertyNames) {
// 2.校驗是否存在beanName=propertyName的bean實例或者BeanDefinition
if (containsBean(propertyName)) {
// 3.獲取propertyName的bean實例對象
Object bean = getBean(propertyName);
// 4.將屬性名和屬性值添加到pvs
pvs.add(propertyName, bean);
// 5.註冊依賴關係到緩存(beanName依賴propertyName)
registerDependentBean(propertyName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Added autowiring by name from bean name '" + beanName +
"' via property '" + propertyName + "' to bean named '" + propertyName + "'");
}
}
else {
if (logger.isTraceEnabled()) {
logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
"' by name: no matching bean found");
}
}
}
}
6. autowireByName >> unsatisfiedNonSimpleProperties
protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
Set<String> result = new TreeSet<>();
// 1.拿到mdb的屬性值
PropertyValues pvs = mbd.getPropertyValues();
// 2.拿到bw的PropertyDescriptors
PropertyDescriptor[] pds = bw.getPropertyDescriptors();
// 3.遍歷bw的PropertyDescriptors
for (PropertyDescriptor pd : pds) {
// 4.pd用於寫入屬性值的方法不爲空
// && pd不是從依賴性檢查中排除的bean屬性
// && pd不包含在pvs裏
// && pd的屬性類型不是“簡單”屬性(基礎類型、枚舉、Number等)
// 4.1 isSimpleProperty: 判斷屬性是不是“簡單”屬性
if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
!BeanUtils.isSimpleProperty(pd.getPropertyType())) {
// 4.2 符合條件,則添加pd的name到result中
result.add(pd.getName());
}
}
return StringUtils.toStringArray(result);
}
7. unsatisfiedNonSimpleProperties >> isSimpleProperty
public static boolean isSimpleProperty(Class<?> type) {
Assert.notNull(type, "'type' must not be null");
// clazz是簡單值類型
// || ( clazz是數組 && clazz的組件類型爲簡單值類型)
// getComponentType:返回數組的組件類型
// 例如: String[] 返回 String.class,如果是非數組,則返回null
return isSimpleValueType(type) || (type.isArray() && isSimpleValueType(type.getComponentType()));
}
public static boolean isSimpleValueType(Class<?> type) {
return (Void.class != type && void.class != type &&
(ClassUtils.isPrimitiveOrWrapper(type) ||
Enum.class.isAssignableFrom(type) ||
CharSequence.class.isAssignableFrom(type) ||
Number.class.isAssignableFrom(type) ||
Date.class.isAssignableFrom(type) ||
Temporal.class.isAssignableFrom(type) ||
URI.class == type ||
URL.class == type ||
Locale.class == type ||
Class.class == type));
}
public static boolean isPrimitiveOrWrapper(Class<?> clazz) {
Assert.notNull(clazz, "Class must not be null");
// clazz爲基礎類型 或者 clazz是基礎類型的封裝類
return (clazz.isPrimitive() || isPrimitiveWrapper(clazz));
}
static {
primitiveWrapperTypeMap.put(Boolean.class, boolean.class);
primitiveWrapperTypeMap.put(Byte.class, byte.class);
primitiveWrapperTypeMap.put(Character.class, char.class);
primitiveWrapperTypeMap.put(Double.class, double.class);
primitiveWrapperTypeMap.put(Float.class, float.class);
primitiveWrapperTypeMap.put(Integer.class, int.class);
primitiveWrapperTypeMap.put(Long.class, long.class);
primitiveWrapperTypeMap.put(Short.class, short.class);
primitiveWrapperTypeMap.put(Void.class, void.class);
...
}
8. autowireByName >> containsBean
@Override
public boolean containsBean(String name) {
// 1.將name轉換爲真正的beanName
String beanName = transformedBeanName(name);
// 2.檢查singletonObjects緩存和beanDefinitionMap緩存中是否存在beanName
if (containsSingleton(beanName) || containsBeanDefinition(beanName)) {
// 3.name不帶&前綴,或者是FactoryBean,則返回true
return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name));
}
// Not found -> check parent.
// 4.沒有找到則檢查parentBeanFactory
BeanFactory parentBeanFactory = getParentBeanFactory();
return (parentBeanFactory != null && parentBeanFactory.containsBean(originalBeanName(name)));
}
9. populateBean >> autowireByType
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
// 1.尋找bw中需要依賴注入的屬性
String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
// 2.遍歷所有需要依賴注入的屬性
for (String propertyName : propertyNames) {
try {
PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
// Don't try autowiring by type for type Object: never makes sense,
// even if it technically is a unsatisfied, non-simple property.
if (Object.class != pd.getPropertyType()) {
// 3.獲取指定屬性的set方法,封裝成MethodParameter(必須有set方法才能通過屬性來注入)
MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
// Do not allow eager init for type matching in case of a prioritized post-processor.
boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
// 4.將MethodParameter的方法參數索引信息封裝成DependencyDescriptor
DependencyDescriptor desc =
new AutowireByTypeDependencyDescriptor(methodParam, eager);
// 5.解析當前屬性所匹配的bean實例,
// 並把解析到的bean實例的beanName存儲在autowiredBeanNames中
Object autowiredArgument =
resolveDependency(desc, beanName, autowiredBeanNames, converter);
if (autowiredArgument != null) {
// 6.如果找到了依賴的bean實例,將屬性名和bean實例放到pvs中
pvs.add(propertyName, autowiredArgument);
}
for (String autowiredBeanName : autowiredBeanNames) {
// 7.註冊依賴關係,beanName依賴autowiredBeanName
registerDependentBean(autowiredBeanName, beanName);
if (logger.isTraceEnabled()) {
logger.trace("Autowiring by type from bean name '"
+ beanName + "' via property '"
+ propertyName + "' to bean named '" + autowiredBeanName + "'");
}
}
autowiredBeanNames.clear();
}
}
catch (BeansException ex) {
throw new UnsatisfiedDependencyException(mbd.getResourceDescription(),
beanName, propertyName, ex);
}
}
}
10. populateBean >> applyPropertyValues
protected void applyPropertyValues(String beanName, BeanDefinition mbd,
BeanWrapper bw, PropertyValues pvs) {
if (pvs.isEmpty()) {
return;
}
if (System.getSecurityManager() != null && bw instanceof BeanWrapperImpl) {
((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
}
MutablePropertyValues mpvs = null;
List<PropertyValue> original;
// 1.獲取屬性值列表
if (pvs instanceof MutablePropertyValues) {
mpvs = (MutablePropertyValues) pvs;
// 1.1 如果mpvs中的值已經被轉換爲對應的類型,那麼可以直接設置到BeanWrapper中
if (mpvs.isConverted()) {
// Shortcut: use the pre-converted values as-is.
try {
bw.setPropertyValues(mpvs);
return;
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName,
"Error setting property values", ex);
}
}
original = mpvs.getPropertyValueList();
}
else {
// 1.2 如果pvs並不是使用MutablePropertyValues封裝的類型,
// 那麼直接使用原始的屬性獲取方法
original = Arrays.asList(pvs.getPropertyValues());
}
TypeConverter converter = getCustomTypeConverter();
if (converter == null) {
converter = bw;
}
// 2.1 獲取對應的解析器
BeanDefinitionValueResolver valueResolver =
new BeanDefinitionValueResolver(this, beanName, mbd, converter);
// Create a deep copy, resolving any references for values.
// 2.2 創建深層拷貝副本,用於存放解析後的屬性值
List<PropertyValue> deepCopy = new ArrayList<>(original.size());
boolean resolveNecessary = false;
// 3.遍歷屬性,將屬性轉換爲對應類的對應屬性的類型
for (PropertyValue pv : original) {
if (pv.isConverted()) {
// 3.1 如果pv已經包含轉換的值,則直接添加到deepCopy
deepCopy.add(pv);
}
else {
// 3.2 否則,進行轉換
// 3.2.1 拿到pv的原始屬性名和屬性值
String propertyName = pv.getName();
Object originalValue = pv.getValue();
if (originalValue == AutowiredPropertyMarker.INSTANCE) {
Method writeMethod = bw.getPropertyDescriptor(propertyName).getWriteMethod();
if (writeMethod == null) {
throw new IllegalArgumentException(
"Autowire marker for property without write method: " + pv);
}
originalValue = new DependencyDescriptor(new MethodParameter(writeMethod, 0), true);
}
// 3.2.2 使用解析器解析原始屬性值
Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
Object convertedValue = resolvedValue;
// 3.2.3 判斷該屬性是否可轉換
boolean convertible = bw.isWritableProperty(propertyName) &&
!PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
if (convertible) {
// 3.2.4 如果可轉換,則轉換指定目標屬性的給定值
convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
}
// Possibly store converted value in merged bean definition,
// in order to avoid re-conversion for every created bean instance.
// 3.2.5 在合併的BeanDefinition中存儲轉換後的值,以避免爲每個創建的bean實例重新轉換
if (resolvedValue == originalValue) {
if (convertible) {
pv.setConvertedValue(convertedValue);
}
deepCopy.add(pv);
}
else if (convertible && originalValue instanceof TypedStringValue &&
!((TypedStringValue) originalValue).isDynamic() &&
!(convertedValue instanceof Collection ||
ObjectUtils.isArray(convertedValue))) {
pv.setConvertedValue(convertedValue);
deepCopy.add(pv);
}
else {
resolveNecessary = true;
deepCopy.add(new PropertyValue(pv, convertedValue));
}
}
}
if (mpvs != null && !resolveNecessary) {
mpvs.setConverted();
}
// Set our (possibly massaged) deep copy.
try {
// 4.設置bean的屬性值爲deepCopy
bw.setPropertyValues(new MutablePropertyValues(deepCopy));
}
catch (BeansException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Error setting property values", ex);
}
}
11. doCreateBean >> initializeBean
執行後置處理器,aop就是在這裏完成的
protected Object initializeBean(final String beanName, final Object bean,
@Nullable RootBeanDefinition mbd) {
// 1.激活Aware方法
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareMethods(beanName, bean);
return null;
}, getAccessControlContext());
}
else {
invokeAwareMethods(beanName, bean);
}
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
// 執行後置處理器的postProcessBeforeInitialization
// 2.在初始化前應用BeanPostProcessor的postProcessBeforeInitialization方法,允許對bean實例進行包裝
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}
try {
// 執行bean的聲明週期回調中的init方法
// 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()) {
//執行後置處理器的postProcessAfterInitialization方法
// 4.在初始化後應用BeanPostProcessor的postProcessAfterInitialization方法,允許對bean實例進行包裝
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
// 5.返回wrappedBean
return wrappedBean;
}
12. initializeBean >> invokeAwareMethods
private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
// BeanNameAware: 實現此接口的類想要拿到beanName,因此我們在這邊賦值給它
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
// BeanClassLoaderAware:實現此接口的類想要拿到beanClassLoader,因此我們在這邊賦值給它
if (bean instanceof BeanClassLoaderAware) {
ClassLoader bcl = getBeanClassLoader();
if (bcl != null) {
((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
}
}
// BeanFactoryAware: 實現此接口的類想要拿到 BeanFactory,因此我們在這邊賦值給它
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}
13. initializeBean >> applyBeanPostProcessorsBeforeInitialization
@Override
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// 1.遍歷所有註冊的BeanPostProcessor實現類,調用postProcessBeforeInitialization方法
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 2.在bean初始化方法執行前,調用postProcessBeforeInitialization方法
Object current = processor.postProcessBeforeInitialization(result, beanName);
if (current == null) {
return result;
}
result = current;
}
return result;
}
14. initializeBean >> postProcessBeforeInitialization
ApplicationContextAwareProcessor.postProcessBeforeInitialization
@Override
@Nullable
public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
return bean;
}
AccessControlContext acc = null;
if (System.getSecurityManager() != null) {
acc = this.applicationContext.getBeanFactory().getAccessControlContext();
}
if (acc != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
invokeAwareInterfaces(bean);
return null;
}, acc);
}
else {
// 調用Aware接口
invokeAwareInterfaces(bean);
}
return bean;
}
private void invokeAwareInterfaces(Object bean) {
if (bean instanceof EnvironmentAware) {
((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
}
if (bean instanceof EmbeddedValueResolverAware) {
((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
}
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).
setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
}
15. initializeBean >> invokeInitMethods
執行bean的聲明週期回調中的init方法
protected void invokeInitMethods(String beanName, final Object bean, @Nullable RootBeanDefinition mbd)
throws Throwable {
// 1.首先檢查bean是否實現了InitializingBean接口,如果是的話調用afterPropertiesSet方法
boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null ||
!mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isTraceEnabled()) {
logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
// 2.調用afterPropertiesSet方法
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
((InitializingBean) bean).afterPropertiesSet();
return null;
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {
((InitializingBean) bean).afterPropertiesSet();
}
}
if (mbd != null && bean.getClass() != NullBean.class) {
String initMethodName = mbd.getInitMethodName();
if (StringUtils.hasLength(initMethodName) &&
!(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
// 3.調用自定義初始化方法
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}
16. invokeInitMethods >> invokeCustomInitMethod
protected void invokeCustomInitMethod(String beanName, final Object bean, RootBeanDefinition mbd)
throws Throwable {
// 1.拿到初始化方法的方法名
String initMethodName = mbd.getInitMethodName();
Assert.state(initMethodName != null, "No init method set");
// 2.根據方法名拿到方法
Method initMethod = (mbd.isNonPublicAccessAllowed() ?
BeanUtils.findMethod(bean.getClass(), initMethodName) :
ClassUtils.getMethodIfAvailable(bean.getClass(), initMethodName));
if (initMethod == null) {
// 3.如果不存在initMethodName對應的方法,並且是強制執行初始化方法(默認爲強制), 則拋出異常
if (mbd.isEnforceInitMethod()) {
throw new BeanDefinitionValidationException("Could not find an init method named '" +
initMethodName + "' on bean with name '" + beanName + "'");
}
else {
if (logger.isTraceEnabled()) {
logger.trace("No default init method named '" + initMethodName +
"' found on bean with name '" + beanName + "'");
}
// Ignore non-existent default lifecycle methods.
return;
}
}
if (logger.isTraceEnabled()) {
logger.trace("Invoking init method '"
+ initMethodName + "' on bean with name '" + beanName + "'");
}
Method methodToInvoke = ClassUtils.getInterfaceMethodIfPossible(initMethod);
// 4.調用初始化方法
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
ReflectionUtils.makeAccessible(methodToInvoke);
return null;
});
try {
AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () ->
methodToInvoke.invoke(bean), getAccessControlContext());
}
catch (PrivilegedActionException pae) {
InvocationTargetException ex = (InvocationTargetException) pae.getException();
throw ex.getTargetException();
}
}
else {
try {
ReflectionUtils.makeAccessible(methodToInvoke);
methodToInvoke.invoke(bean);
}
catch (InvocationTargetException ex) {
throw ex.getTargetException();
}
}
}
17. initializeBean >> applyBeanPostProcessorsAfterInitialization
@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
Object result = existingBean;
// 1.遍歷所有註冊的BeanPostProcessor實現類,調用postProcessAfterInitialization方法
for (BeanPostProcessor processor : getBeanPostProcessors()) {
// 2.在bean初始化後,調用postProcessAfterInitialization方法
Object current = processor.postProcessAfterInitialization(result, beanName);
if (current == null) {
// 3.如果返回null,則不會調用後續的BeanPostProcessors
return result;
}
result = current;
}
return result;
}
18. doCreateBean >> registerDisposableBeanIfNecessary
註冊用於銷燬的bean,執行銷燬操作的有三種:自定義destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor
protected void registerDisposableBeanIfNecessary(String beanName,
Object bean, RootBeanDefinition mbd) {
AccessControlContext acc =
(System.getSecurityManager() != null ? getAccessControlContext() : null);
// 1.mbd的scope不是prototype && 給定的bean需要在關閉時銷燬
if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
// 2.單例模式下注冊用於銷燬的bean到disposableBeans緩存,執行給定bean的所有銷燬工作:
if (mbd.isSingleton()) {
// Register a DisposableBean implementation that performs all destruction
// work for the given bean: DestructionAwareBeanPostProcessors,
// DisposableBean interface, custom destroy method.
// 2.1 DisposableBeanAdapter:使用DisposableBeanAdapter來封裝用於銷燬的bean
registerDisposableBean(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
else {
// A bean with a custom scope...
// 3.自定義scope處理
Scope scope = this.scopes.get(mbd.getScope());
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name '"
+ mbd.getScope() + "'");
}
scope.registerDestructionCallback(beanName,
new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
}
}
}
19. registerDisposableBeanIfNecessary >> requiresDestruction
protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd) {
// 1.DisposableBeanAdapter.hasDestroyMethod(bean, mbd):判斷bean是否有destroy方法
// 2.hasDestructionAwareBeanPostProcessors():
// 判斷當前BeanFactory是否註冊過DestructionAwareBeanPostProcessor
// 3.DisposableBeanAdapter.hasApplicableProcessors:
// 是否存在適用於bean的DestructionAwareBeanPostProcessor
return (bean.getClass() != NullBean.class &&
(DisposableBeanAdapter.hasDestroyMethod(bean, mbd) ||
(hasDestructionAwareBeanPostProcessors() &&
DisposableBeanAdapter.hasApplicableProcessors(bean, getBeanPostProcessors()))));
}
20. requiresDestruction >> hasDestroyMethod
public static boolean hasDestroyMethod(Object bean, RootBeanDefinition beanDefinition) {
if (bean instanceof DisposableBean || bean instanceof AutoCloseable) {
// 1.如果bean實現了DisposableBean接口 或者 bean是AutoCloseable實例,則返回true
return true;
}
// 2.拿到bean自定義的destroy方法名
String destroyMethodName = beanDefinition.getDestroyMethodName();
if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName)) {
// 3.如果自定義的destroy方法名爲“(inferred)”(該名字代表需要我們自己去推測destroy的方法名),
// 則檢查該bean是否存在方法名爲“close”或“shutdown”的方法,如果存在,則返回true
return (ClassUtils.hasMethod(bean.getClass(), CLOSE_METHOD_NAME) ||
ClassUtils.hasMethod(bean.getClass(), SHUTDOWN_METHOD_NAME));
}
// 4.如果destroyMethodName不爲空,則返回true
return StringUtils.hasLength(destroyMethodName);
}
21. requiresDestruction >> hasApplicableProcessors
public static boolean hasApplicableProcessors(Object bean, List<BeanPostProcessor> postProcessors) {
if (!CollectionUtils.isEmpty(postProcessors)) {
// 1.遍歷所有的BeanPostProcessor
for (BeanPostProcessor processor : postProcessors) {
// 2.如果processor是DestructionAwareBeanPostProcessor
if (processor instanceof DestructionAwareBeanPostProcessor) {
DestructionAwareBeanPostProcessor dabpp =
(DestructionAwareBeanPostProcessor) processor;
if (dabpp.requiresDestruction(bean)) {
// 3.如果給定的bean實例需要通過此後處理器進行銷燬,則返回true
return true;
}
}
}
}
return false;
}
22.registerDisposableBeanIfNecessary >> DisposableBeanAdapter
public DisposableBeanAdapter(Object bean, String beanName, RootBeanDefinition beanDefinition,
List<BeanPostProcessor> postProcessors, @Nullable AccessControlContext acc) {
Assert.notNull(bean, "Disposable bean must not be null");
this.bean = bean;
this.beanName = beanName;
// 1.判斷bean是否需要調用DisposableBean的destroy方法
this.invokeDisposableBean =
(this.bean instanceof DisposableBean &&
!beanDefinition.isExternallyManagedDestroyMethod("destroy"));
this.nonPublicAccessAllowed = beanDefinition.isNonPublicAccessAllowed();
this.acc = acc;
// 2.拿到自定義的destroy方法名
String destroyMethodName = inferDestroyMethodIfNecessary(bean, beanDefinition);
if (destroyMethodName != null && !(this.invokeDisposableBean &&
"destroy".equals(destroyMethodName)) &&
!beanDefinition.isExternallyManagedDestroyMethod(destroyMethodName)) {
this.destroyMethodName = destroyMethodName;
// 3.拿到自定義的destroy方法,賦值給this.destroyMethod
Method destroyMethod = determineDestroyMethod(destroyMethodName);
if (destroyMethod == null) {
if (beanDefinition.isEnforceDestroyMethod()) {
// 4.如果destroy方法名爲空,並且enforceDestroyMethod爲true,則拋出異常
throw new BeanDefinitionValidationException(
"Could not find a destroy method named '" +
destroyMethodName + "' on bean with name '" + beanName + "'");
}
}
else {
// 5.拿到destroy方法的參數類型數組
Class<?>[] paramTypes = destroyMethod.getParameterTypes();
if (paramTypes.length > 1) {
// 6.如果destroy方法的參數大於1個,則拋出異常
throw new BeanDefinitionValidationException(
"Method '" + destroyMethodName + "' of bean '" + beanName
+ "' has more than one parameter - not supported as destroy method");
}
else if (paramTypes.length == 1 && boolean.class != paramTypes[0]) {
// 7.如果destroy方法的參數爲1個,並且該參數的類型不爲boolean,則拋出異常
throw new BeanDefinitionValidationException("Method '" + destroyMethodName
+ "' of bean '" + beanName
+ "' has a non-boolean parameter - not supported as destroy method");
}
destroyMethod = ClassUtils.getInterfaceMethodIfPossible(destroyMethod);
}
this.destroyMethod = destroyMethod;
}
// 8.查找DestructionAwareBeanPostProcessors,並賦值給this.beanPostProcessors
this.beanPostProcessors = filterPostProcessors(postProcessors, bean);
}
23.DisposableBeanAdapter >> inferDestroyMethodIfNecessary
@Nullable
private String inferDestroyMethodIfNecessary(Object bean, RootBeanDefinition beanDefinition) {
// 1.拿到beanDefinition的destroy方法名
String destroyMethodName = beanDefinition.getDestroyMethodName();
// 2.如果destroy方法名爲“(inferred)”|| destroyMethodName爲null,並且bean是AutoCloseable實例
if (AbstractBeanDefinition.INFER_METHOD.equals(destroyMethodName) ||
(destroyMethodName == null && bean instanceof AutoCloseable)) {
// Only perform destroy method inference or Closeable detection
// in case of the bean not explicitly implementing DisposableBean
// 3.如果bean沒有實現DisposableBean接口,則嘗試推測destroy方法的名字
if (!(bean instanceof DisposableBean)) {
try {
// 4.嘗試在bean中尋找方法名爲close的方法作爲destroy方法
return bean.getClass().getMethod(CLOSE_METHOD_NAME).getName();
}
catch (NoSuchMethodException ex) {
try {
// 5.嘗試在bean中尋找方法名爲close的方法作爲shutdown方法
return bean.getClass().getMethod(SHUTDOWN_METHOD_NAME).getName();
}
catch (NoSuchMethodException ex2) {
// no candidate destroy method found
}
}
}
// 6.如果沒有找到,則返回null
return null;
}
return (StringUtils.hasLength(destroyMethodName) ? destroyMethodName : null);
}
24.DisposableBeanAdapter >> filterPostProcessors
@Nullable
private List<DestructionAwareBeanPostProcessor> filterPostProcessors(
List<BeanPostProcessor> processors, Object bean) {
List<DestructionAwareBeanPostProcessor> filteredPostProcessors = null;
if (!CollectionUtils.isEmpty(processors)) {
filteredPostProcessors = new ArrayList<>(processors.size());
// 1.遍歷所有的BeanPostProcessor
for (BeanPostProcessor processor : processors) {
// 2.如果processor是DestructionAwareBeanPostProcessor
if (processor instanceof DestructionAwareBeanPostProcessor) {
DestructionAwareBeanPostProcessor dabpp =
(DestructionAwareBeanPostProcessor) processor;
if (dabpp.requiresDestruction(bean)) {
// 3.如果給定的bean實例需要通過此後處理器進行銷燬,則添加到filteredPostProcessors
filteredPostProcessors.add(dabpp);
}
}
}
}
return filteredPostProcessors;
}
單元測試
留個坑。。
總結
spring初期初始化,最後幾篇文章都是參考程序員囧輝的,之所以沒改成轉載,是因爲後續要添加更多的理解,以及相關測試代碼,還有自己的東西, 所以。
在 finishBeanFactoryInitialization 方法中,我們主要做了以下操作:
- 將之前解析的 BeanDefinition 進一步處理,將有父 BeanDefinition 的進行合併,獲得 MergedBeanDefinition
- 嘗試從緩存獲取 bean 實例
- 處理特殊的 bean —— FactoryBean 的創建
- 創建 bean 實例
- 循環引用的處理
- bean 實例屬性填充
- bean 實例的初始化
- BeanPostProcessor 的各種擴展應用
參考
https://blog.csdn.net/v123411739/article/details/88077817