bean的加載步驟：
MyTestBean bean = (MyTestBean) bf.getBean("myTestBean");
步驟：
(1) 轉換對應的beanName
?name="&aa"=>name="aa" || A->B->C=>C
(2) 嘗試從緩存中加載單例
?singletonFactories集合緩存ObjectFactory
(3) bean的實例化
?getObjectForBeanInstance(sharedInstance, name, beanName, mbd)
(4) 原型模式的依賴檢查
?A有B屬性，B有A屬性，屬性循環依賴
?isPrototypeCurrentlyInCreation(beanName)
(5) 檢測parentBeanFactory
(6) 將存儲XML配置文件的GernericBeanDefinition轉換為RootBeanDefinition
(7) 尋找依賴
(8) 針對不同的scope進行bean的創建
?scope="singleton||prototype||other"
(9) 類型轉換
?return (T) bean;
代碼實現如下：
(1) 轉換對應的beanName String beanName = transformedBeanName(name); (2) 嘗試從緩存中加載單例 T doGetBean(args ...){Object bean; sharedInstance = getSingleton(beanName);(3) bean的實例化if (!sharedInstance) { // 非單例bean = getObjectForBeanInstance(beanName, mbd, args);} else { // 單例(4) 原型模式的依賴檢查if (isPrototypeCurrentlyInCreation(beanName)) throw e;(5) 檢測parentBeanFactoryBeanFactory parentBeanFactory = getParentBeanFactory();if (parentBeanFactory != null) {nameToLoopup = orginalBeanName(name);// 遞歸到BeanFactory中尋找return parentBeanFactory.getBean(nameToLoopup, args);}(6) 將存儲XML配置文件的GernericBeanDefinition轉換為RootBeanDefinitionfinal RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);checkMergedBeanDefinition(mbd, beanName, args);(7) 尋找依賴// 存在依賴，遞歸實例化beanString[] dependsOn = mbd.getDependsOn();if (dependsOn != null) {for (String dependsOnBean : dependsOn){getBean(dependsOnBean);registerDependentBean(dependsOnBean);}}(8) 針對不同的scope進行bean的創建// 實例化mbd本身if (mbd.isSingleton()){sharedInstance = getSingleton(beanName, new ObjectFactory<Object>(){getObject() {try {return createBean(beanName, mbd, args);} catch(e) {destoryName(beanName);throw e;}}});bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);} else if (mbd.isPrototype()) {prototypeInstance;try {beforePrototypeCreation(beanName);prototypeInstance = createBean(beanName, mbd, args);} finally {afterPrototypeCreation(beanName);}bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);} else {// 指定的scope上實例化beanString scopeName = mbd.getScope();final Scope scope = this.scopes.get(scopeName);scopeInstance = scope.get(beanName, new ObjectFactory<Object>() {getObject() {try {return createBean(beanName, mbd, args);} finally {afterPrototypeCreation(beanName);}}});bean = getObjectForBeanInstance(scopeInstance, name, beanName, mbd);}}(9) 類型轉換if (requriedType != null) {return getTypeConverter().convertIfNecessary(bean, requiredType);}return (T) bean; }
1.?FactoryBean接口類
FactoryBean|-- T getObject(); // |-- Class<?> getObjectType();|-- boolean isSingleton(); CarFactoryBean implements FactoryBean<Car> {Car getObject() {Car car = new Car();String[] infos = carInfo.split(",");car.setBrand(infos[0]);car.setMaxSpeed(Integer.valueOf(infos[1]));car.setPrice(Double.valueOf(infos[2]));return car;}String carInfo;// setter、getter方法 isSingleton() {return false;} } <!-- srping-bean.xml --> <bean id="car" class="com.test.CarFactoryBean" carInfo="跑車,400,2000"/> 代碼實現：getBean("car") -> spring發現CarFactoryBean implements FactoryBean接口，容器調用接口方法CarFactoryBean#getObject()返回getBean("&car") -> CarFactoryBean
2.?緩存中獲取單例
Object getSingleton(String beanName) {return getSingleton(beanName, true); } Object getSingleton(beanName, allowEarlyReference) {// 檢查緩存是否存在Object singletonObject = this.singletonObjects.get(beanName);if (null == getSingleton) {synchronized(this.singletonObjects) {singletonObject = this.earlySingletonObjects.get(beanName);if (singletonObject == null && allowEarlyReference) {// 當某些方法需要提前初始化的時候會調用addSingletonFactory方法將對應的ObjectFactory初始化策略存儲在singletongFactoriesObjectFactory singletonFactory = this.singletonFactories.get(beanName);if (singletonFactory != null) {// 調用預先設定的getObject方法singletonObject = singletonFactory.getObject();// 記錄在緩存中，earlySingletonObjects與singletonFactories互斥this.earlySingletonObjects.put(beanName, singletonObject);this.singletonFactories.remove(beanName);}}}}return singletonObject != NULL_OBJECT ? singletonObject : null; }
javabean是啥。3.?從bean的實例中獲取對象
(1) 對FactoryBean做正確性的驗證 (2) 對非FactoryBean不做任務處理 (3) 對bean進行轉換 (4) 將從Factory中解析bean的工作委托給getObjectFromFactoryBeangetObjectForBeanInstance(beanInstance, name, beanName, mbd) {// &testBeanFactoryif (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {throw e;}// &testBeanFactoryif (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {return beanInstance;}// 加載factoryBeanObject object = null;if (mbd == null) {// 嘗試從緩存中加載beanobject = getCachedObjectForFactoryBean(beanName);}if (object == null) {FactoryBean<?> factory = (FactoryBean<?>) beanInstance;if (mbd == null && containsBeanDefinition(beanName)) {mbd = getMergedLocalBeanDefinition(beanName);}// 是否是用戶定義的而不是應用程序本身定義的boolean synthetic = (mbd != null && mbd.isSynthetic());object = getObjectFromFactoryBean(factory, beanName, !synthetic);} } getObjectFromFactoryBean(factory, beanName, shouldPostProcess) {// 如果是單例if (factory.isSingleton() && containsSingleton(beanName)) {synchronized(getSingletonMutex()) {Object object = this.factoryBeanObjectCache.get(beanName);if (object == null) {object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);this.factoryBeanObjectCache.put(beanName, object);}return object;}} else {return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);} } doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess) {Object object = null;try {if (System.getSecurityManager() != null) { // 權限驗證try {Object = AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){run() {return factory.getObject();}});} catch (e) {throw e;}} else {object = factory.getObject();}} catch (e) {throw e;}if (object != null && shouldPostProcess) {try {object = postProcessObjectFromFactoryBean(object, beanName);} catch (e) {throw e;}}return object; } postProcessObjectFromFactoryBean(object, beanName) {return applyBeanPostProcessorsAfterInitialization(object, beanName); } applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {Object result = existingBean;for (BeanPostProcessor beanPostProcessor : getBeanPostProcessors()) {result = beanPostProcessor.postProcessorsAfterInitialization(result, beanName);return result;}return result; }
4.?獲取單例
(1) 檢查緩存是否已經加載過 (2) 若沒有加載，則記錄beanName的正在加載狀態 (3) 加載單例前記錄加載狀態 (4) 通過調用參數傳入的ObjectFactory的個體Object實例化bean (5) 加載單例后的處理方法調用 (6) 將結果記錄到繳存并刪除加載bean過程中所記錄的各種輔助狀態 (7) 返回處理結果 getSingleton(beanName, new ObjectFactory) {synchronized (this.singletonObjects) {Object singletonObject = this.singletonObjects.get(beanName);if (singletonObject == null) {beforeSingletonCreation(beanName);try {singletonObject = singletonFactory.getObject();} catch (e) {throw e;} finally {afterSingletonCreation(beanName);}// 加入緩存 addSingleton(beanName, singletonObject);}}return (singletonObject != NULL_OBJECT ? singletonObject : null) } beforeSingletonCreation(beanName) {if (!this.singletonsCurrentlyCreation.add(beanName)) { // 將當前正要創建的bean記錄在緩存中，這樣便可以對循環依賴進行檢測throw e;} } afterSingletonCreation(beanName) {if (!this.singletonsCurrentlyCreation.remove(beanName)) { // 加載結束后，移除緩存中對該bean正在加載狀態的記錄throw e;} } addSingleton(beanName, singletonObject) {synchronized (this.singletonObjects) {// 將結果記錄到緩存，并刪除加載bean過程中所記錄的輔助狀態this.singletonObjects.put(beanName, singletonObject);this.singletonFatories.remove(beanName);this.earlySingletonObjects.remove(beanName);this.registeredSingletons.add(beanName);} } getSingleton(beanName, new ObjectFactory<Object>(){public Object getObject() {try {return createBean(beanName, mbd, args);} catch (e) {throw e;}} });
5.?準備創建bean
(1) 根據設置的class屬性，或者根據className來解析class (2) 對override屬性進行標記及驗證 (3) 應用初始化前的后處理器，解析指定bean是否存在初始化前的短路操作 (4) 創建bean createBean(beanName, mbd, args) {// 根據設置的class屬性，或者根據className來解析class resolveBeanClass(mbd, beanName);// 對override屬性進行標記及驗證try {mbd.prepareMethodOverrides();} catch (e) {throw e;}// 給BeanPostProcessors一個機會返回代理來替代真正的實例Object bean = resolveBeforeInstantiation(beanName, mbd);if (bean != null) {return bean;}// 創建beanObject beanInstance = doCreateBean(beanName, mbd, args);return beanInstance; }prepareMethodOverrides() {MethodOverrides methodOverrides = getMethodOverrides();for (MethodOverride mo : MethodOverrides) {prepareMethodOverride(mo);} } // lookup-method、replace-method屬性 prepareMethodOverride(mo) {// 獲取對應類中對應方法名的個數int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());if (count == 0) {throw e;} else if (count == 1) {// 標記未被覆蓋，避免參數類型檢查的開銷mo.setOverloaded(false);} } |-- 實例化前置處理 resolveBeforeInstantiation(beanName, mbd) {Object bean = null;try {bean = applyBeanPostProcessorsBeforeInitialization(mbd.getBeanClass(), beanName);if (bean != null) {bean = applyBeanPostProcessorsAfterInitialization(mbd.getBeanClass(), beanName);}mbd.beforeInstantiationResolved = (bean != null);} catch (e) {throw e;}return bean; } |-- 實例化前的處理器應用 applyBeanPostProcessorsBeforeInitialization(beanClass, beanName) {for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor)bp;Object result = ibp.postProcessorsBeforeInitialization(beanClass, beanName);if (result != null) {return result;}}}return null; } |-- 實例化后的處理器應用 applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {Object result = existingBean;for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {Object result = beanProcessor.postProcessorsAfterInitialization(result, beanName);if (result != null) {return result;}}return result; }
6.?循環依賴
(1) 循環依賴定義：循環依賴就是循環引用，就是存在2個或多個bean相互之間的持有對方，如：A->B->C->A，A->B->A (2) 循環依賴的類型：構造器循環依賴、setter循環依賴 5.6.1 構造器循環依賴處理TestA、TestB、TestCTestA -> 查找“當前創建bean池”，如果沒發現則繼續準備構造器參數“testB”，并將“testA”標識符放到“當前創建bean池”TestB -> 查找“當前創建bean池”，如果沒發現則繼續準備構造器參數“testC”，并將“testB”標識符放到“當前創建bean池”TestC -> 查找“當前創建bean池”，如果沒發現則繼續準備構造器參數“testA”，并將“testC”標識符放到“當前創建bean池”準備構造器參數“testA”時，發現該 bean的標識符在“當前創建bean池”存在，拋出BeanCurrentlyInCreationException。5.6.2 setter循環依賴處理TestA、TestB、TestCTestA -> 暴露ObjectFactory工廠，并將“testA”標識符放到“當前創建bean池”，然后進行setter注入“testB”TestB -> 暴露ObjectFactory工廠，并將“testB”標識符放到“當前創建bean池”，然后進行setter注入“testC”TestC -> 暴露ObjectFactory工廠，并將“testC”標識符放到“當前創建bean池”，然后進行setter注入“testA”，進入注入“TestA”時由于提前暴露了“ObjectFactory”工廠，從而使用它返回提前暴露一個創建中的bean。最后依賴注入"TestB"、"TestA"，完成setter注入。5.6.3 prototype范圍的依賴處理scope="prototpye" -> 由于prototpye作用域無法完成依賴注入，spring容器不進行緩存prototype作用域的bean，因此無法提前暴露一個創建中的bean。scope="singleton" -> setAllowCircularReferences(false); // 禁用循環引用
7.?創建bean
(1) 如果是單例則需要首先清除緩存 (2) 實例化bean，將BeanDefinition轉換為BeanWrapper (3) MergedBeanDefinitionPostProccessor的應用 (4) 依賴處理 (5) 屬性填充 (6) 循環依賴檢查 (7) 注冊DisposableBean (8) 完成創建并返回 protected Object doCreateBean(final String beanName, final RooBeanDefinition mbd, final Object[] args) {BeanWrapper instanceWrapper = null;// 如果是單例則需要首先清除緩存if (mbd.isSingleton()) {instanceWrapper = this.factoryBeanObjectCache.remove(beanName);}// 實例化bean，將BeanDefinition轉換為BeanWrapperif (instanceWrapper == null) {instanceWrapper = createBeanInstance(beanName, mbd, args);}final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);// MergedBeanDefinitionPostProccessor的應用 synchronized (mbd.postProcessingLock) {if (!mbd.postProcessed) {applyMergedBeanDefinitionPostProccessor(mbd, beanType, beanName);}}// 依賴處理// 是否需要提前暴露（單例&循環引用&當前bean正在創建中）boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences && isSingletongCurrentlyInCreation(beanName));if (earlySingletonExposure) {// 為避免循環依賴，在bean初始化完成前將創建實例的ObjectFactory加入工廠addSingletonFactory(beanName, new ObjectFactory(){public Object getObject() throw e {// 對bean的再一次依賴引用return getEarlyBeanReferences(beanName, mbd, bean);}});}Object exposedObject = bean;// 屬性填充try {populateBean(beanName, mbd, instanceWrapper);if (exposedObject != null) {// 調用初始化方法，init-methodexposedObject = initializeBean(beanName, exposedObject, mbd);}} catch (e) {throw e;}// 循環依賴檢查if (earlySingletonExposure) {Object earlySingletonReference = getSingleton(beanName, false);if (earlySingletonReference != null) {// exposedObject沒有在初始化方法改變，說明沒有被增強if (exposedObject == null) {exposedObject = earlySingletonReference;} else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {String[] dependentBeans = getDependentBeans(beanName);Set<String> actualDependentBeans = new LinkedHashSet<String>();for (String dependentBean : dependentBean) {// 檢測依賴if (!removeSingletonIfCreateForTypeCheckOnly(dependentBean)) {actualDependentBeans.add(dependentBean);}}if (!actualDependentBeans.isEmpty()) {throw e; }}}}// 注冊DisposableBeantry {registerDisposableBeanIfNecessary(beanName, bean, mbd);} catch (e) {throw e;}return exposedObject; }
@bean？7.1?屬性的注入
(1) InstantiationAwareBeanPostProcessor處理器的postProcessAfterInstantiation函數的應用，此函數可以控制程序是否繼續進行屬性填充 (2) 根據類型，提取依賴bean，并統一存入PropertyValues中。 (3) 應用InstantiationAwareBeanPostProcessor處理器的postProcessPropertyValues方法，對屬性獲取完畢填充前對屬性的再次處理，RequiredAnnotationBeanPostProcessor對屬性的驗證 (4) 將所有PropertyValues中的屬性填充至BeanWrapper中 populateBean(beanName, mbd, bw) {PropertyValues pvs = mbd.getPropertyValues();if (bw == null) {if (!pvs.isEmpty()) {throw e;} else {// 沒有屬性填充return ;}}boolean continueWithPropertyPopulation = true;for (BeanPostProcessor bp : getBeanPostProcessors()) {if (bp instanceof InstantiationAwareBeanPostProcessor) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;// 返回值是否繼續填充beanif (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {continueWithPropertyPopulation = false;break;}}}// 如果后處理器發出停止填充命令則終止后續的執行if (!continueWithPropertyPopulation) {return;}if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_NAME || mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_TYPE) {MutablePropertyValues newPvs = new MutablePropertyValues(pvs);if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_NAME) {autowireByName(beanName, mbd, bw, newPvs);}if (mbd.getResolvedAutowireMode() == RooBeanDefinition.AUTOWIRE_BY_TYPE) {autowireByType(beanName, mbd, bw, newPvs);}pvs = newPvs;}// 后處理器已經初始化boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();// 需要檢查依賴boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);if (hasInstAwareBpps || needsDepCheck) {PropertyDescriptor[] filteredPds = filterPropertyDescriptionsForDependencyCheck(bw);if (hasInstAwareBpps) {for (BeanPostProcessor bp : getBeanPostProcessors()) {InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;// 對所有需要依賴檢查的屬性進行后處理pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);if (pvs == null) {return;}}} if (needsDepCheck) {checkDependences(beanName, mbd, filteredPds, pvs);}}// 將屬性應用到bean中 applyPropertyValues(beanName, mbd, bw, pvs); } // 根據name注入屬性 autowireByName(beanName, mbd, bw, newPvs) {String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);for (String propertyName : propertyNames) {if (containsBean(propertyName)) {// 遞歸初始化相關的beanObject bean = getBean(propertyName);pvs.add(propertyName, bean);// 注冊依賴 registerDependentBean(propertyName, beanName);} else {if (logger.isTraceEnabled()) {logger.trace(...);}}} } // 根據type注入屬性 autowireByType(beanName, mbd, BeanWrapper bw, newPvs) {try {TypeConverter converter = getCustomTypeConverter();if (converter == null) {converter = bw;}Set<String> autowiredBeanNames = new LinkedHashSet<String>(4);// 尋找bw中需要依賴注入的屬性String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);for (String propertyName : propertyNames) {PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);if (!Object.calss.equals(pd.getProperType())) {// 探測指定的set方法MethodParamter methodParam = BeanUtils.getWriteMethodParamter(pd);boolean eager = PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());PropertyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);// 解析指定的屬性所匹配的值，并把解析到的屬性的名稱存儲在autowiredBeanNames中，當屬性存在多個封裝bean時：// @Autowired private List<A> aList; 將會找到所有匹配A類型的bean將其注入Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);if (autowiredArgument != null) {pvs.add(propertyName, autowiredArgument);}for (String autowiredBeanName : autowiredBeanNames) {// 注冊依賴 registerBeanDefinition(autowiredBeanName, beanName);}autowiredBeanNames.clear();}}} catch (e) {throw e;} } resolveDependency(descriptor, beanName, Set<String> autowiredBeanNames, typeConverter) {descriptor.initParamterNameDisconvery(getParamterNameDisconverer());// ObjectFactory類注入的特殊處理if (descriptor.getDependencyType().equals(ObjectFactory.class)) {return new DependencyObjectFactory(descriptor, beanName);}else if (... eq javaxInjectProviderClass) {return new DependencyObjectFactory().createDependencyProvider(descriptor, beanName);}else {// 通用邏輯處理return doResolvedDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter);} } doResolvedDependency(descriptor, descriptor.getDependencyType(), beanName, autowiredBeanNames, typeConverter) {// 用于支持spring中新增的注解@valueObject value = getAutowireCandidateResolver().getSuggestedValue(descriptor);if (value != null) {if (value instanceof String) {value = evaluateBeanDefinitionString(strVal, bd);}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());return converter.convertIfNecessary(value, type);}// 屬性是數組類型if (type.isArray()) { // 數組類型Class<?> componentType = type.getComponentType();Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);if (matchingBeans.isEmpty()) {if (descriptor.isRequired()) {raiseNoSuchBeanDefinitionException(componentType, componentType.getName(), descriptor);}return null;}if (autowiredBeanNames != null) {autowiredBeanNames.addAll(matchingBeans.keySet());}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());return converter.convertIfNecessary(matchingBeans.values(), type);}else if (Collection.class.isAssignableFrom(type) && type.isInterface()) {// 集合類型Class<?> elementType = descriptor.getCollectionType();if (elementType == null) {if (descriptor.isRequired()) {throw e;}return null;}Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);if (matchingBeans.isEmpty()) {throw e;}if (autowiredBeanNames != null) {autowiredBeanNames.addAll(matchingBeans.keySet());}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());return converter.convertIfNecessary(matchingBeans.values(), type);} else if (Map.class.isAssignableFrom(type) && type.isInterface()) {// Map類型Class<?> keyType = descriptor.getMapKeyType();if (keyType == null) {if (descriptor.isRequired()) {throw e;}return null;}Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);if (matchingBeans.isEmpty()) {throw e;}if (autowiredBeanNames != null) {autowiredBeanNames.addAll(matchingBeans.keySet());}TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());return converter.convertIfNecessary(matchingBeans.values(), type);}else {Map<String,Object> matchingBeans = findAutowireCandidates(beanName, componentType, descriptor);if (matchingBeans.isEmpty()) {throw e;}if (matchingBeans.size() > 1) {String primaryBeanName = determinePrimaryCandidate(matchingBeans, descriptor);if (primaryBeanName == null) {throw e;}if (autowiredBeanNames != null) {autowiredBeanNames.add(primaryBeanName);}return matchingBeans.get(primaryBeanName);}// 已經可以確定只有一個匹配項Map.Entry<String,Object> entry = matchingBeans.entrySet().iterator().next();if (autowiredBeanNames != null) {autowiredBeanNames.add(entry.getKey());}return entry.getValue();} } // 將屬性應用到bean中 applyPropertyValues(beanName, mbd, bw, pvs) {if (pvs == null || pvs.isEmpty()) {return;}MutablePropertyValues mpvs = null;List<PropertyValue> original;if (bw instancof BeanWrapperImpl) {((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());}if (pvs instanceof MutablePropertyValues) {mpvs = (MutablePropertyValues) pvs;// 如果mpvs中的值已經被轉換為對應的類型那么可以直接設置到beanWrapper中try {if (mpvs.isConverted()) {bw.setPropertyValues(mpvs);return;}} catch (e) {throw e;}original = mpvs.getPropertyValueList();} else {// 非MutablePropertyValues封裝的類型，那么直接使用原始的屬性獲取方法original = Arrays.asList(pvs.getPropertyValues());}TypeConverter converter = getCustomTypeConverter();if (converter == null) {converter = bw;}// 獲取對應的解析器BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);// Create a deep copy, resolving any references for values.List<PropertyValue> deepCopy = new ArrayList<String>(original.size());boolean resolveNecessary = false;for (PropertyValue pv : original) {if (pv.isConverted()) {deepCopy.add(pv);} else {String propertyName = pd.getName();Object originalValue = pd.getValue();Object resolvedValue = valueResolver.resolveValueIfNecessay(pv, originalValue);Object convertedValue = resolvedValue;boolean convertible = (bw.isWritableProperty(propertyName) && !PropertyUtils.isNestedIndexedProperty(propertyName));if (convertible) {convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);}if (convertedValue == 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();}try {bw.setPropertyValues(new MutablePropertyValues(deepCopy));} catch (e) {throw e;} }
8.?初始化bean
// spring容器已經執行過bean的實例化，并且進行了屬性填充，而就是這時將會調用用戶設定的初始化方法 initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {if (System.getSecurityMananger() != null) {AccessController.doPrivileged(new PrivilegedAction<Object>(){Object run() {invokeAwareMethods(beanName, bean);return null;}});} else {// 對特殊的bean處理：Aware、BeanClassLoaderAware、BeanFactoryAware invokeAwareMethods(beanName, bean);}Object wrappedBean = bean;if (mbd != null || !mbd.isSynthetic()) {// 應用前處理器wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);}try {// 激活用戶自定義的init方法 invokeInitMethod(beanName, wrappedBean, mbd);} catch (e) {throw e;}if (mbd != null || !mbd.isSynthetic()) {// 后處理器應用wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);}return wrappedBean; } 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);}} } // 處理器應用 applyBeanPostProcessorsBeforeInitialization(existingBean, beanName) {Object result = existingBean;for ( BeanPostProcessor beanProcessor : getBeanPostProcessors()) {result = beanProcessor.postProcessBeforeInitialization(result, beanName);if (result == null) {return result;}}return result; } applyBeanPostProcessorsAfterInitialization(existingBean, beanName) {Object result = existingBean;for ( BeanPostProcessor beanProcessor : getBeanPostProcessors()) {result = beanProcessor.postProcessAfterInitialization(result, beanName);if (result == null) {return result;}}return result; } // 激活用戶自定義的init方法 invokeInitMethod(beanName, bean, mbd) {// 檢查是否是InitializingBean，如果是則調用afterPropertiesSet方法boolean isInitializingBean = (bean istanceof InitializingBean);if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {if (System.getSecurityManager() != null) {try {AccessController.doPrivileged(new PrivilegedExceptionAction<Object>(){Object run() {((InitializingBean) bean).afterPropertiesSet();return null;}});} catch (e) {throw e;}} else {((InitializingBean) bean).afterPropertiesSet();}}if (mbd != null) {String initMethodName = mbd.getInitMethodName();if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName))&& !mbd.isExternallyManagedInitMethod(initMethodName)) {// 調用自定義初始化方法 invokeCustomInitMethod(beanName, bean, mbd);}} }
9.?注冊DisposableBean
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);if (!mbd.isPrototype() && requiredDestruction(bean, mbd)) {if (mbd.isSingleton()) {// 單例模式下需要注冊需要銷毀的bean，此方法中會處理實現DisposableBean的bean，// 并且對所有的bean使用DestrunctionAwareBeanPostProccessors處理// DisposableBean DestrunctionAwareBeanPostProccessorsregisterDisposableBean(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));} else {scope scope = this.scopes.get(mgd.getScope());if (scope == null) {throw e;}scope.registerDestructionCallback(beanName, new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));}} }
?
![在ASP.NET中防止注入攻击[翻译]](https://www.cnblogs.com/Images/OutliningIndicators/None.gif)
