資訊專欄INFORMATION COLUMN
摘要：判斷調(diào)用哪個(gè)構(gòu)造方法的過程會采用緩存機(jī)制，如果已經(jīng)解析過則不需要重復(fù)解析而是從中的屬性緩存的值去取，否則需再次解析。
Spring是一個(gè)開源的設(shè)計(jì)層面框架，解決了業(yè)務(wù)邏輯層和其他各層的松耦合問題，將面向接口的編程思想貫穿整個(gè)系統(tǒng)應(yīng)用，同時(shí)它也是Java工作中必備技能之一...前言
在 Spring解密 - XML解析 與 Bean注冊 中，講了 Bean的解析，本章將詳細(xì)講解Spring中Bean的加載過程，相比解析而言，加載稍微復(fù)雜一點(diǎn).
入口public class Application {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("bean.xml");
Person person = context.getBean("person", Person.class);
System.out.println(person.toString());
}
}
重點(diǎn)分析 context.getBean();
解密在分析 Bean 的加載過程前，我們看看 BeanFactory 的由來，以及 getBean 所屬的類是誰。磨刀不誤砍柴工
BeanFactory 的由來1.查看getBean()的源碼，此處的 getBeanFactory() 是怎么來的？
public class AbstractApplicationContext{
@Override
public T getBean(String name, @Nullable Class requiredType) throws BeansException {
assertBeanFactoryActive();
// getBeanFactory() 是怎么來的？我們接著看
return getBeanFactory().getBean(name, requiredType);
}
}
2.應(yīng)用程序的上下文
在 new ClassPathXmlApplicationContext("bean.xml"); 中，跳轉(zhuǎn)到重載的構(gòu)造方法中，我們會發(fā)現(xiàn)如下代碼
public class ClassPathXmlApplicationContext {
public ClassPathXmlApplicationContext(
String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
throws BeansException {
super(parent);
// 解析 bean.xml 文件
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}
}
它的目的是將普通路徑解析為 類(classpath) 路徑資源名稱。多個(gè)配置文件的情況下，后加載的 Bean 會覆蓋先前定義好的 Bean，這樣做的目的是為了通過額外的XML文件來特意重寫某個(gè) Bean。這里我們可以看到調(diào)用了一個(gè) refresh()，它的作用是什么呢？
3.初始化
刷新容器
public class AbstractApplicationContext {
@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// 準(zhǔn)備刷新上下文
prepareRefresh();
// 通知子類，刷新內(nèi)部 BeanFactory（創(chuàng)建 BeanFactory 的入口）
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
}
}
protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
// 跟蹤該方法
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();
if (logger.isDebugEnabled()) {
logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);
}
return beanFactory;
}
}
初次加載完 bean.xml 后，肯定會進(jìn)入到 refresh() 方法中，這個(gè)時(shí)候會做容器初始化的工作，也就是 標(biāo)簽解析、Bean加載 等等工作，由于本章重點(diǎn)介紹 Bean加載，所以只貼了少量代碼（看官莫急）
創(chuàng)建 DefaultListableBeanFactory
public class AbstractRefreshableApplicationContext {
@Override
protected final void refreshBeanFactory() throws BeansException {
// 判斷是否存在
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
// 創(chuàng)建 DefaultListableBeanFactory
DefaultListableBeanFactory beanFactory = createBeanFactory();
beanFactory.setSerializationId(getId());
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);
synchronized (this.beanFactoryMonitor) {
// 然后賦值給 beanFactory 變量
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
}
}
// 提取 BeanFactory
@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
synchronized (this.beanFactoryMonitor) {
if (this.beanFactory == null) {
throw new IllegalStateException("BeanFactory not initialized or already closed - " +
"call "refresh" before accessing beans via the ApplicationContext");
}
return this.beanFactory;
}
}
}
從上面的代碼塊中，我們可以看到 如果已經(jīng)存在 beanFactory，將銷毀舊的實(shí)例，然后在創(chuàng)建新的 DefaultListableBeanFactory，最后 getBeanFactory() 就可以正常使用了。
Bean 加載整個(gè) Bean 的裝載過程中，重點(diǎn)圍繞 AbstractBeanFactory，只要把它搞定剩下的就輕松了
public abstract class AbstractBeanFactory {
@Override
public Object getBean(String name) throws BeansException {
return doGetBean(name, null, null, false);
}
protected T doGetBean(final String name, @Nullable final Class requiredType,
@Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
// 別名轉(zhuǎn)換
final String beanName = transformedBeanName(name);
Object bean;
// 檢查緩存中是否存在 該 Bean 的單例（Bean默認(rèn)的Scope = singleton）
// 比如容器初始化的時(shí)候或者其他地方調(diào)用過getBean，已經(jīng)完成了初始化
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null && args == null) {
if (logger.isDebugEnabled()) {
if (isSingletonCurrentlyInCreation(beanName)) {
logger.debug("Returning eagerly cached instance of singleton bean "" + beanName +
"" that is not fully initialized yet - a consequence of a circular reference");
}
else {
logger.debug("Returning cached instance of singleton bean "" + beanName + """);
}
}
// 返回實(shí)例，F(xiàn)actoryBean 的情況下，并不是直接返回實(shí)例本身而是返回指定方法返回的實(shí)例
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}
else {
// 存在循環(huán)依賴則報(bào)錯(cuò)
if (isPrototypeCurrentlyInCreation(beanName)) {
throw new BeanCurrentlyInCreationException(beanName);
}
// 判斷工廠中是否含有當(dāng)前 Bean 的定義
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
// 如果沒有，查詢父工廠
String nameToLookup = originalBeanName(name);
if (parentBeanFactory instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
nameToLookup, requiredType, args, typeCheckOnly);
}
else if (args != null) {
// 執(zhí)行帶有 args 參數(shù)的 getBean 方法
return (T) parentBeanFactory.getBean(nameToLookup, args);
}
else {
// 如果沒有參數(shù)，執(zhí)行標(biāo)準(zhǔn)的 getBean 方法
return parentBeanFactory.getBean(nameToLookup, requiredType);
}
}
if (!typeCheckOnly) { // 如果不是做類型檢查，則需要標(biāo)記此 Bean 正在創(chuàng)建之中
markBeanAsCreated(beanName);
}
try {
// 將存儲XML配置文件的GernericBeanDefinition轉(zhuǎn)換成RootBeanDefinition，如果BeanName是子Bean的話會合并父類的相關(guān)屬性
final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);
// 獲取依賴的 Bean
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dep : dependsOn) {
if (isDependent(beanName, dep)) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Circular depends-on relationship between "" + beanName + "" and "" + dep + """);
}
registerDependentBean(dep, beanName);
getBean(dep);
}
}
// 終于開始創(chuàng)建 Bean 實(shí)例了，如果是單例的，那么會創(chuàng)建一個(gè)單例的匿名工廠，
// 如果是原型模式的，則不需要?jiǎng)?chuàng)建單例的工廠的，其他的如 request、session 作用域的，則根據(jù)自身的需要
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
return createBean(beanName, mbd, args);// 調(diào)用默認(rèn)構(gòu)造函數(shù)，有興趣自己跟進(jìn)下代碼
}
catch (BeansException ex) {
// Explicitly remove instance from singleton cache: It might have been put there
// eagerly by the creation process, to allow for circular reference resolution.
// Also remove any beans that received a temporary reference to the bean.
destroySingleton(beanName);
throw ex;
}
});
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
else if (mbd.isPrototype()) {
// It"s a prototype -> create a new instance.
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
else {
String scopeName = mbd.getScope();
final Scope scope = this.scopes.get(scopeName);
if (scope == null) {
throw new IllegalStateException("No Scope registered for scope name "" + scopeName + """);
}
try {
Object scopedInstance = scope.get(beanName, () -> {
beforePrototypeCreation(beanName);
try {
return createBean(beanName, mbd, args);
}
finally {
afterPrototypeCreation(beanName);
}
});
bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName,
"Scope "" + scopeName + "" is not active for the current thread; consider " +
"defining a scoped proxy for this bean if you intend to refer to it from a singleton",
ex);
}
}
}
catch (BeansException ex) {
cleanupAfterBeanCreationFailure(beanName);
throw ex;
}
}
// 類型檢查，如果不能進(jìn)行類型轉(zhuǎn)換，則拋出異常
if (requiredType != null && !requiredType.isInstance(bean)) {
try {
T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
if (convertedBean == null) {
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
return convertedBean;
}
catch (TypeMismatchException ex) {
if (logger.isDebugEnabled()) {
logger.debug("Failed to convert bean "" + name + "" to required type "" +
ClassUtils.getQualifiedName(requiredType) + """, ex);
}
throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
}
}
return (T) bean;
}
}
整個(gè)代碼塊的內(nèi)容還是不少的，接下來我們一步一步的分析。
轉(zhuǎn)換 BeanNamefinal String beanName = transformedBeanName(name);
protected String transformedBeanName(String name) {
return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}
去除 FactoryBean 的修飾符，最終取指定 alias 所表示的 beanName。因?yàn)橛锌赡塬@取到以 & 開頭的 FactoryBean，所以要進(jìn)行轉(zhuǎn)化（關(guān)于 BeanFactory 和 FactoryBean 后面會進(jìn)行區(qū)分）
加載單例檢查緩存中是否存在 該 Bean 的單例（Bean默認(rèn)的Scope = singleton），如容器初始化的時(shí)候或者其他地方已經(jīng)調(diào)用過 getBean() 完成了初始化
Object sharedInstance = getSingleton(beanName);
緩存加載 Bean
默認(rèn)在裝載 Bean 的時(shí)候會先去檢查 singletonObjects 是否存在，如果存在直接提取緩存的。
public class DefaultSingletonBeanRegistry {
/** 保存 BeanName 和創(chuàng)建 bean 實(shí)例之間的關(guān)系 bean name --> bean instance */
private final Map singletonObjects = new ConcurrentHashMap<>(256);
/** 保存 BeanName 和創(chuàng)建 bean 實(shí)例的工廠之間的關(guān)系 bean name --> ObjectFactory */
private final Map> singletonFactories = new HashMap<>(16);
/** 保存 BeanName 和創(chuàng)建 bean 實(shí)例之間的關(guān)系 bean name --> bean instance */
/** 與 singletonObjects 不同的是當(dāng)一個(gè)單例 bean 被放到里面后，那么在 bean 在創(chuàng)建過程中，就可以通過 getBean 方法獲取到，可以用來檢測循環(huán)引用。 **/
private final Map earlySingletonObjects = new HashMap<>(16);
/** 保存當(dāng)前所有已注冊的 bean */
private final Set registeredSingletons = new LinkedHashSet<>(256);
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
// 嘗試從緩存獲取實(shí)例
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
synchronized (this.singletonObjects) {
// 若該 bean 正在加載則不處理
singletonObject = this.earlySingletonObjects.get(beanName);
if (singletonObject == null && allowEarlyReference) {
ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
if (singletonFactory != null) {
singletonObject = singletonFactory.getObject();
// 存入到緩存中
this.earlySingletonObjects.put(beanName, singletonObject);
this.singletonFactories.remove(beanName);
}
}
}
}
return singletonObject;
}
}
構(gòu)建實(shí)例（無緩存情況）
緩存中沒有，那就當(dāng)場構(gòu)建一個(gè) bean 出來，可以看到 getSingleton(String beanName, ObjectFactory singletonFactory) 有兩個(gè)參數(shù)，其中的 ObjectFactory 是怎么來的呢？ 接著往下看
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
// 記錄加載狀態(tài)，，以便對循環(huán)依賴進(jìn)行檢測
beforeSingletonCreation(beanName);
singletonObject = singletonFactory.getObject();
// 移除加載狀態(tài)
afterSingletonCreation(beanName);
addSingleton(beanName, singletonObject);
}
return (singletonObject != NULL_OBJECT ? singletonObject : null);
}
}
構(gòu)建 ObjectFactory
此處與其說是構(gòu)建 ObjectFactory ，不如說是在創(chuàng)建一個(gè)單例 Bean
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, () -> {
try {
// 對 JDK8 lambda 表達(dá)式熟悉的小伙伴就不會陌生了
return createBean(beanName, mbd, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
});
// 劃重點(diǎn)了
bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
創(chuàng)建 Bean
public class AbstractAutowireCapableBeanFactory {
@Override
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;
// 首先判斷需要?jiǎng)?chuàng)建的bean是否可以被實(shí)例化，這個(gè)類是否可以通過類裝載器來載入。
Class resolvedClass = resolveBeanClass(mbd, beanName);
if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
mbdToUse = new RootBeanDefinition(mbd);
mbdToUse.setBeanClass(resolvedClass);
}
// 準(zhǔn)備方法覆蓋
try {
mbdToUse.prepareMethodOverrides();
}
catch (BeanDefinitionValidationException ex) {
throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
beanName, "Validation of method overrides failed", ex);
}
try {
// 用 BeanPostProcessors 返回代理來替代真正的實(shí)例（如果 Bean 配置了 PostProcessor，那么這里返回的是一個(gè)代理）
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 {
// 重點(diǎn)來了
Object beanInstance = doCreateBean(beanName, mbdToUse, args);
if (logger.isDebugEnabled()) {
logger.debug("Finished creating instance of bean "" + beanName + """);
}
return beanInstance;
}
catch (BeanCreationException ex) {
// A previously detected exception with proper bean creation context already...
throw ex;
}
catch (ImplicitlyAppearedSingletonException ex) {
// An IllegalStateException to be communicated up to DefaultSingletonBeanRegistry...
throw ex;
}
catch (Throwable ex) {
throw new BeanCreationException(
mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
}
}
}
在創(chuàng)建 Bean 之前，Spring 還做了不少工作。
判斷創(chuàng)建的 bean 是否可以被實(shí)例化，這個(gè)類是否可以通過 ClassLoader 來載入，根據(jù)設(shè)置的 class 屬性或根據(jù) className 來解析 class。
對覆蓋進(jìn)行標(biāo)記并驗(yàn)證，在 Spring 配置中存在 lookup-mothod 和 replace-method 的，這兩個(gè)配置的加載時(shí)將配置統(tǒng)一存放在 BeanDefinition 中的 methodOverrides 屬性里，這個(gè)方法的操作也是針對于這兩個(gè)配置的；
應(yīng)用初始化前的后處理器，最后創(chuàng)建 bean。在 createBean() 方法里執(zhí)行完 resolveBeforeInstantiation 方法后，如果創(chuàng)建了代理且不為空的話就直接返回，否則需要進(jìn)行常規(guī) bean 的創(chuàng)建，這個(gè)創(chuàng)建過程是在 doCreateBean 中完成的
初始化 Bean上面 createBean 交給了 doCreateBean 來創(chuàng)建 bean （上面還有一個(gè)重要的方法getObjectForBeanInstance，在后面分析）
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
throws BeanCreationException {
// 實(shí)例化 Bean
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
// 根據(jù)指定 bean 使用相應(yīng)策略創(chuàng)建實(shí)例（正確情況會調(diào)用無參構(gòu)造函數(shù)）
instanceWrapper = createBeanInstance(beanName, mbd, args);
}
// 獲取實(shí)例化好的 Bean（Person person = new Person()），此處還未進(jìn)行賦值
final Object bean = instanceWrapper.getWrappedInstance();
// 獲得實(shí)例化好的 class
Class beanType = instanceWrapper.getWrappedClass();
if (beanType != NullBean.class) {
mbd.resolvedTargetType = beanType;
}
// 記錄創(chuàng)建 Bean 的 ObjectFactory，初始化前調(diào)用 post-processors，可以讓我們在 bean 實(shí)例化之前做一些定制操作
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;
}
}
// 檢測循環(huán)依賴，是否需要提早初始化（只能解決單例Bean）
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, () -> getEarlyBeanReference(beanName, mbd, bean));
}
// 初始化bean實(shí)例。
Object exposedObject = bean;
try {
// 在這個(gè)方法里面初始化對象，配置 xml 中的各種屬性
populateBean(beanName, mbd, instanceWrapper);
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 actualDependentBeans = new LinkedHashSet<>(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.");
}
}
}
}
// 用于銷毀方法
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
catch (BeanDefinitionValidationException ex) {
throw new BeanCreationException(
mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
}
return exposedObject;
}
上面源碼完成的操作可以概括為以下幾點(diǎn)
RootBeanDefinition 是不是單例，如果是單例先移除緩存
實(shí)例化 bean，將 RootBeanDefinition 轉(zhuǎn)換為 BeanWrapper
使用 MergedBeanDefinitionPostProcessor，Autowired注解 就是通過此方法實(shí)現(xiàn)類型的預(yù)解析；
解決循環(huán)依賴問題
在 populateBean() 中填充屬性，配置在 XML 中的各種屬性
注冊到 DisposableBean 中
完成創(chuàng)建并返回 Bean 的實(shí)例
接下來我們看下 Spring 是如何創(chuàng)建 bean 實(shí)例的。跟蹤 createBeanInstance() 方法
創(chuàng)建Bean實(shí)例
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
// 獲取 beanClass ， 要先確保 Bean 是正確的，已經(jīng)解析到當(dāng)前節(jié)點(diǎn)了
Class beanClass = resolveBeanClass(mbd, beanName);
if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
throw new BeanCreationException(mbd.getResourceDescription(), beanName,
"Bean class isn"t public, and non-public access not allowed: " + beanClass.getName());
}
Supplier instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
return obtainFromSupplier(instanceSupplier, beanName);
}
// 若工廠方法不為空則使用工廠方法初始化
if (mbd.getFactoryMethodName() != null) {
return instantiateUsingFactoryMethod(beanName, mbd, args);
}
// Shortcut when re-creating the same bean...
boolean resolved = false;
boolean autowireNecessary = false;
if (args == null) {
synchronized (mbd.constructorArgumentLock) {
if (mbd.resolvedConstructorOrFactoryMethod != null) {
resolved = true;
autowireNecessary = mbd.constructorArgumentsResolved;
}
}
}
// 如果已經(jīng)解析過則使用解析好的構(gòu)造方法不需要再次鎖定
if (resolved) {
if (autowireNecessary) {
// 構(gòu)造方法自動(dòng)注入
return autowireConstructor(beanName, mbd, null, null);
}
else {
// 使用默認(rèn)構(gòu)造方法
return instantiateBean(beanName, mbd);
}
}
// 根據(jù)參數(shù)解析構(gòu)造方法
Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
if (ctors != null ||
mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
return autowireConstructor(beanName, mbd, ctors, args);
}
// 沒有特殊處理的情況下，只需使用無參數(shù)的構(gòu)造函數(shù)。
return instantiateBean(beanName, mbd);
}
可以看出如果在 RootBeanDefinition 中存在 factoryMethodName屬性，或者說配置文件中配置了 factory-method，那么 Spring 會嘗試使用 instantiateUsingFactoryMethod(beanName, mbd, args) 方法根據(jù) RootBeanDefinition 中的配置生成bean實(shí)例。然后再解析構(gòu)造方法并進(jìn)行實(shí)例化，Spring 會根據(jù)參數(shù)及類型判斷使用哪個(gè)構(gòu)造方法進(jìn)行實(shí)例化。判斷調(diào)用哪個(gè)構(gòu)造方法的過程會采用緩存機(jī)制，如果已經(jīng)解析過則不需要重復(fù)解析而是從 RootBeanDefinition 中的屬性 resolvedConstructorOrFactoryMethod 緩存的值去取，否則需再次解析。
populateBean 屬性注入
這塊代碼比較多，有興趣請自行跟進(jìn)，就不貼出來了
在 populateBean 方法的中的主要處理流程：
InstantiationAwareBeanPostProcessor 處理器的 postProcessAfterInstantiation 方法控制程序是否繼續(xù)填充屬性；
根據(jù)注入類型提取依賴的 bean，并存入 PropertyValues 中；
InstantiationAwareBeanPostProcessor 處理器的 postProcessPropertyValues 方法對屬性在填充前再次處理（主要還是驗(yàn)證屬性）；
將所有 PropertyValues 中的屬性填充到 BeanWrapper 中；
initializeBean 初始化Bean
學(xué)過 Spring 的都知道 bean 配置時(shí)有一個(gè) init-method 屬性，這個(gè)屬性的作用是在 bean 實(shí)例化前調(diào)用 init-method 指定的方法進(jìn)行需要的操作，現(xiàn)在就進(jìn)入這個(gè)方法了；Spring 執(zhí)行過 bean 的實(shí)例化，并且進(jìn)行屬性填充后，就會調(diào)用用戶設(shè)定的初始化方法。
protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged((PrivilegedAction
最后加載完 Bean 并執(zhí)行完初始化操作后，一個(gè) bean 的加載基本就結(jié)束了。
增強(qiáng)的 Bean通過上面的描述，我們已經(jīng)知道了一個(gè)的 Bean 是如何初始化的，已經(jīng)具備普通 Bean 的功能。但是 Spring 還提供了一種增強(qiáng)的 Bean(FactoryBean)，具備 factory 能力的 Bean，這個(gè)能力主要在 getObjectForBeanInstance 得到。
public class AbstractBeanFactory {
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
// 如果想要獲取 FactoryBean 本身,那么 beanInstance 必須是 FactoryBean 的實(shí)例
if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
}
// 如果 instance 不是 FactoryBean 實(shí)例,或者想要獲取的就是 FactoryBean 實(shí)例，那么直接返回就好
if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
return beanInstance;
}
Object object = null;
if (mbd == null) {
// 獲取緩存的實(shí)例
object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
// 緩存中沒有對象,那么從頭準(zhǔn)備 bean defition 實(shí)例化一個(gè)
FactoryBean factory = (FactoryBean) beanInstance;
// Caches object obtained from FactoryBean if it is a singleton.
if (mbd == null && containsBeanDefinition(beanName)) {
mbd = getMergedLocalBeanDefinition(beanName);
}
boolean synthetic = (mbd != null && mbd.isSynthetic());
// 在這里面獲得最終的FactoryBean
object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}
return object;
}
}
關(guān)于 BeanFactory 和 FactoryBean 的區(qū)別：
BeanFactory： 容器的基本接口，是一個(gè)工廠，用來生產(chǎn) Bean
FactoryBean： 是一個(gè)特殊的 Bean，可以當(dāng)作工廠使用的 Bean
循環(huán)依賴上面有簡單提到過 循環(huán)依賴（只有在單例情況下才會嘗試解決循環(huán)依賴）。 無法解決就只能拋出 BeanCurrentlyInCreationException 異常
構(gòu)造器循環(huán)依賴
無法解決，只能拋出 BeanCurrentlyInCreationException 異常
setter 循環(huán)依賴
Spring 容器提前暴露了剛好完成的構(gòu)造器注入，但未完成其他步驟 (如 setter 注入 的 bean)。只能解決單例作用域的 bean 循環(huán)依賴。
addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
prototype 范圍的依賴處理
Spring 容器無法完成依賴注入，因?yàn)?Spring 容器不會緩存 prototype 作用域的 bean，因此無法提前暴露一個(gè)創(chuàng)建中的 bean。
總結(jié)
熬過幾個(gè)無人知曉的秋冬春夏，撐過去一切都會順著你想要的方向走...
說點(diǎn)什么全文代碼：https://gitee.com/battcn/battcn-spring-source/tree/master/Chapter4
個(gè)人QQ：1837307557
battcn開源群（適合新手）：391619659
微信公眾號：battcn（歡迎調(diào)戲）
文章版權(quán)歸作者所有，未經(jīng)允許請勿轉(zhuǎn)載,若此文章存在違規(guī)行為，您可以聯(lián)系管理員刪除。
轉(zhuǎn)載請注明本文地址：http://specialneedsforspecialkids.com/yun/71168.html
摘要：解密是注冊及加載的默認(rèn)實(shí)現(xiàn)，整個(gè)模板中它可以稱得上始祖。中是這樣介紹的自動(dòng)裝配時(shí)忽略給定的依賴接口，比如通過其他方式解析上下文注冊依賴，類似于通過進(jìn)行的注入或者通過進(jìn)行的注入。解析是資源文件讀取解析注冊的實(shí)現(xiàn)，要重點(diǎn)關(guān)注該類。 Spring是一個(gè)開源的設(shè)計(jì)層面框架，解決了業(yè)務(wù)邏輯層和其他各層的松耦合問題，將面向接口的編程思想貫穿整個(gè)系統(tǒng)應(yīng)用，同時(shí)它也是Java工作中必備技能之一......
摘要：它們的優(yōu)先級低于或以及作為創(chuàng)建應(yīng)用程序過程的正常部分添加到子級的任何其他屬性源。為引導(dǎo)配置類使用單獨(dú)的包名稱，并確保或注解的配置類尚未涵蓋該名稱。在這種情況下，它會在刷新時(shí)重建，并重新注入其依賴項(xiàng)，此時(shí)，它們將從刷新的重新初始化。 Spring Cloud Context：應(yīng)用程序上下文服務(wù) Spring Boot有一個(gè)關(guān)于如何使用Spring構(gòu)建應(yīng)用程序的主見，例如，它具有通用配置文...
Spring是一個(gè)開源的設(shè)計(jì)層面框架，解決了業(yè)務(wù)邏輯層和其他各層的松耦合問題，將面向接口的編程思想貫穿整個(gè)系統(tǒng)應(yīng)用，同時(shí)它也是Java工作中必備技能之一... 前言 緊跟上篇 Spring解密 - XML解析 與 Bean注冊 ，我們接著往下分析源碼 解密 在 Spring 的 XML 配置里面有兩大類聲明，一個(gè)是默認(rèn)的如 ，另一類就是自定義的如，兩種標(biāo)簽的解析方式差異是非常大的。parseBe...
摘要：自定義標(biāo)簽在講解自定義標(biāo)簽解析之前，先看下如何自定義標(biāo)簽定義文件定義一個(gè)文件描述組件內(nèi)容聲明命名空間值得注意的是與可以是不存在，只要映射到指定就行了。 Spring是一個(gè)開源的設(shè)計(jì)層面框架，解決了業(yè)務(wù)邏輯層和其他各層的松耦合問題，將面向接口的編程思想貫穿整個(gè)系統(tǒng)應(yīng)用，同時(shí)它也是Java工作中必備技能之一... 前言 在 上一節(jié) Spring解密 - 默認(rèn)標(biāo)簽的解析 中，重點(diǎn)分析了...
摘要：小程序官方流程圖如下，官方地址如果此圖理解不清楚的地方也可參看我的博客本文是對接微信小程序自定義登錄的一個(gè)完整例子實(shí)現(xiàn)，技術(shù)棧為。調(diào)用微信接口獲取和根據(jù)和自定義登陸態(tài)返回自定義登陸態(tài)給小程序端。 小程序官方流程圖如下，官方地址 : https://developers.weixin.qq.com/miniprogram/dev/framework/open-ability/login....
閱讀 2331·2021-11-24 10:27
閱讀 3576·2019-08-30 15:55
閱讀 3341·2019-08-30 15:53
閱讀 2342·2019-08-29 17:27
閱讀 1428·2019-08-26 13:47
閱讀 3547·2019-08-26 10:28
閱讀 913·2019-08-23 15:59
閱讀 2850·2019-08-23 15:19
