Spring core 源码分析 ---- IoC容器(二) getBean
博客专区 > AlexT 的博客 > 博客详情
Spring core 源码分析 ---- IoC容器(二) getBean
AlexT 发表于11个月前
Spring core 源码分析 ---- IoC容器(二) getBean
  • 发表于 11个月前
  • 阅读 38
  • 收藏 0
  • 点赞 0
  • 评论 0

新睿云服务器60天免费使用,快来体验!>>>   

    上节提到了在AbstractApplicationContext 调用refresh方法里,初始化所有BeanDefinitions后,遍历所有BeanDefinitionNames后,循环调用BeanFactory的getBean(name)方法,实例化所有容器 Bean对象(非lasy-init)。

GetBean做了什么?循环引用如何处理的?

    既然是BeanFactory的getBean方法,详细看下BeanFactory相关的类图:

  • DefaultListableBeanFactory: ListableBeanFactory和BeanDefinitionRegistry接口的默认实现,也是一个功能完善的BeanFactory,可以作为一个独立的BeanFactory使用,也可作为自定义BeanFactory的父类。
  • ConfigurableListableBeanFactory接口:提供分析和修改BeanDefinition,以及预初始化singletons接口。
  • ListableBeanFactory接口: BeanFactory接口的扩展接口,定义了各种Map<String,Object> getbeans* 的接口。
  • BeanFactory接口:BeanFactory作为最原始同时也最重要的Ioc容器,它主要的功能是为依赖注入 (DI) 提供支持,也是访问bean容器的客户端视角。BeanFactory包含了一系列bean definitions,每一个Bean definitions都有一个字符串的唯一标识。BeanFactory通过Bean definition 返回singleton的(独立的-prototype,request,session)等不同scope的bean实例。
  • AutowireCapableBeanFactory接口:定义了BeanFactory能够使用Autowiring的相关接口。
  • ConfigurableBeanFactory接口:提供配置BeanFactory的相关接口。
  • HierachicalBeanFactory接口:接口被bean factoris 实现,实现分层级的bean Factory。
  • SingletonBeanRegistry 接口: 为所有的singleton的bean提供统一的管理机制。
  • AbstractAutowireCapableBeanFactory : 实现了通过RootBeanDefinition创建bean的默认实现,提供bean创建,property populatin,autowring,handles runtime bean references,resolves managed collections,调用初始化方法等实现。
  • AbstractBeanFactory:BeanFactory接口的基础实现抽象类。
  • FactoryBeanRegistrySupport:  FactoryBean实例的管理,以及DefaultSingletonBeanRegistry的管理。
  • DefaultSingletonBeanRegistry: 实现SingletonBeanRegistry接口。
  • SimpleAliasRegistry : 实现 AliasRegistry接口。
  • AliasRegistry接口:别名相关的所有功能。

调用GetBean时,调用时序图如下:

    我们先从AbstractBeanFactory的 doGetBean(final String name,final Class<T> requiredType,final Object[] args,boolean typeCheckOnly) 开始,

参数意义如下:

  • name:需要得到bean的名称
  • requireType:需要得到bean的类型
  • args:创建bean实例时用的更为详细的参数(只在创建bean 实例时起作用)
  • typeCheckOnly:表明这个instance只是为了类型的检查,而不是真正创建一个bean

调用流程如下:

getBean主流程图

源码如下:

	/**
	 * Return an instance, which may be shared or independent, of the specified bean.
	 * @param name the name of the bean to retrieve
	 * @param requiredType the required type of the bean to retrieve
	 * @param args arguments to use when creating a bean instance using explicit arguments
	 * (only applied when creating a new instance as opposed to retrieving an existing one)
	 * @param typeCheckOnly whether the instance is obtained for a type check,
	 * not for actual use
	 * @return an instance of the bean
	 * @throws BeansException if the bean could not be created
	 */
	@SuppressWarnings("unchecked")
	protected <T> T doGetBean(
			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
			throws BeansException {
        //处理name,去除开头&,若是别名则转换成标准beanName
		final String beanName = transformedBeanName(name);
		Object bean;

		// Eagerly check singleton cache for manually registered singletons.
        // 取缓存的Bean,在此处解决了循环引用的问题
		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 + "'");
				}
			}
            // 完成FactoryBean的处理
			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
		}

		else {
			// Fail if we're already creating this bean instance:
			// We're assumably within a circular reference.
            // 如果我们已经正在创建这个bean实例,则因为循环引用的问题抛出异常
			if (isPrototypeCurrentlyInCreation(beanName)) {
				throw new BeanCurrentlyInCreationException(beanName);
			}

			// Check if bean definition exists in this factory.
            // 检查bean definition是否在当前beanFactory中,若不在,委派到父类 or 父类的父类 
			BeanFactory parentBeanFactory = getParentBeanFactory();
			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
				// Not found -> check parent.
				String nameToLookup = originalBeanName(name);
				if (args != null) {
					// Delegation to parent with explicit args.
					return (T) parentBeanFactory.getBean(nameToLookup, args);
				}
				else {
					// No args -> delegate to standard getBean method.
					return parentBeanFactory.getBean(nameToLookup, requiredType);
				}
			}

			if (!typeCheckOnly) {
                // 标记bean为已创建,放入alreadyCreated Set<String>
				markBeanAsCreated(beanName);
			}

			try {
                // 通过beanName得到BeanDefinition
				final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
				checkMergedBeanDefinition(mbd, beanName, args);

				// Guarantee initialization of beans that the current bean depends on.
                // 得到目标bean所有依赖的beanNames
				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 + "'");
						}
                        // 将依赖bean注册到目标bean上,保证在目标bean destroy前被destroy
						registerDependentBean(dep, beanName);
                        // 创建 dependent的bean实例
						getBean(dep);
					}
				}

				// Create bean instance.
                // 创建单例模式的bean
				if (mbd.isSingleton()) {
                    // 使用匿名的内部类,创建一个Bean实例 在 DefaultSingletonBeanRegisty.java中
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
                        // getSingleton中会调用getObject()
						@Override
						public Object getObject() throws BeansException {
							try {
								return createBean(beanName, mbd, args);
							}
							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);
				}
                // 创建prototype模式的bean
				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);
				}
                // 创建其他scope的bean 
				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, new ObjectFactory<Object>() {
							@Override
							public Object getObject() throws BeansException {
								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;
			}
		}

		// Check if required type matches the type of the actual bean instance.
		if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
			try {
				return getTypeConverter().convertIfNecessary(bean, requiredType);
			}
			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;
	}

 

由于大部分业务bean都是singleton的,所以doGetBean方法直接就去看beanFactory的 singletonObjects里有没有目标bean。我们可以详细看下<getBean主流程图> 里第一个子流程

sharedInstance = getSingleton(beanName) ---> 调用:

DefaultSingletonBeanRegistry.java 里的getSingleton(beanName,allowEarlyReference=true) 方法。

流程图:

 源码如下:

	/**
	 * Return the (raw) singleton object registered under the given name.
	 * <p>Checks already instantiated singletons and also allows for an early
	 * reference to a currently created singleton (resolving a circular reference).
	 * @param beanName the name of the bean to look for
	 * @param allowEarlyReference whether early references should be created or not
	 * @return the registered singleton object, or {@code null} if none found
	 */
	protected Object getSingleton(String beanName, boolean allowEarlyReference) {
		Object singletonObject = this.singletonObjects.get(beanName);
		if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
			synchronized (this.singletonObjects) {
				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 != NULL_OBJECT ? singletonObject : null);
	}

    若通过BeanName得到singletonObjects里的bean,判断是一个标准bean ,而不是FactoryBean,或者调用方就需要一个FactoryBean的引用,就直接返回。 

    若是取到的sharedInstance为空,那么后续会走双亲委派模型 去搜索父BeanFactory里是否有当前BeanName的BeanDefinition,若有,让父BeanFactory去初始化Bean。

    双亲委派模型,典型的使用就是JVM的类加载机制了,其优点主要是:

    (1) 保证全局一个Bean只被一个BeanFactory加载,避免了重复加载的问题。

    (2) 模型使得Bean随着BeanFactory具备了一种带优先级的层次关系,越基础的Bean,越会被上层的BeanFactory加载。

    确定了当前bean属于当前的BeanFactory后,加载此Bean的所有depends-on的beans。 当depends-on的beans全被加载完毕后,判断当前bean的scope是哪种?

    spring中的bean的scope有如下几种 singleton(ioc容器里唯一),prototype(每次创建新实例),request(一次http request唯一),session,globalSession,application,websocket 。

    代码中的处理逻辑,做了三个分支, isSingleton,isPrototype,以及其他。

    当bean的scope为Singleton时,会调用父类DefaultSingletonBeanRegistry里的

getSingleton(beanName,ObjectFactory<?>)方法,调用方式如下:

	            // Create bean instance.
				if (mbd.isSingleton()) {
					sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
						@Override
						public Object getObject() throws BeansException {
							try {
                                //createBean其他scope都会调用,而此处getSingleton保证了所有singleton的逻辑
								return createBean(beanName, mbd, args);
							}
							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);
				}

DefaultSingletonBeanRegistry.java -----getSingleton(beanName,ObjectFactory<?>) 

流程图如下:

源码如下:

/**
	 * Return the (raw) singleton object registered under the given name,
	 * creating and registering a new one if none registered yet.
	 * @param beanName the name of the bean
	 * @param singletonFactory the ObjectFactory to lazily create the singleton
	 * with, if necessary
	 * @return the registered singleton object
	 */
	public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
		Assert.notNull(beanName, "'beanName' must not be null");
		synchronized (this.singletonObjects) {
			Object singletonObject = this.singletonObjects.get(beanName);
			// 若singletonObjects(Cache of singleton objects)没有beanName,bean没被创建过
            if (singletonObject == null) {
                // 标识是否正在 destroy singletons
				if (this.singletonsCurrentlyInDestruction) {
					throw new BeanCreationNotAllowedException(beanName,
							"Singleton bean creation not allowed while singletons of this factory are in destruction " +
							"(Do not request a bean from a BeanFactory in a destroy method implementation!)");
				}
				if (logger.isDebugEnabled()) {
					logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
				}
                // 判断是否正在创建,若正在(singletonsCurrentlyInCreation.contains),抛出异常,若不在加入 singletonsCurrentlyInCreation Set<String> 里
				beforeSingletonCreation(beanName);
				boolean newSingleton = false;
				boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
				if (recordSuppressedExceptions) {
					this.suppressedExceptions = new LinkedHashSet<Exception>();
				}
				try {
                    // 在此调用上层方法,createBean() 也是创建对象的方法
					singletonObject = singletonFactory.getObject();
					newSingleton = true;
				}
				catch (IllegalStateException ex) {
					// Has the singleton object implicitly appeared in the meantime ->
					// if yes, proceed with it since the exception indicates that state.
					singletonObject = this.singletonObjects.get(beanName);
					if (singletonObject == null) {
						throw ex;
					}
				}
				catch (BeanCreationException ex) {
					if (recordSuppressedExceptions) {
						for (Exception suppressedException : this.suppressedExceptions) {
							ex.addRelatedCause(suppressedException);
						}
					}
					throw ex;
				}
				finally {
					if (recordSuppressedExceptions) {
						this.suppressedExceptions = null;
					}
                    // 创建结束,移除singletonsCurrentlyInCreation里的beanName
					afterSingletonCreation(beanName);
				}
                // 创建成功
				if (newSingleton) {
					// 将bean放入singletonObjects里,从singletonFactories里移除beanName,
                    // 从earlySingletonObjects(解决循环依赖,提前引用)中移除,
                    // 添加beanName 到registerdSingletons里
                    addSingleton(beanName, singletonObject);
				}
			}
			return (singletonObject != NULL_OBJECT ? singletonObject : null);
		}
	}

调用singletonFactory.getObject() ,即是调用AbstractAutowireCapableBeanFactory的createBean方法。

AbstractAutowireCapableBeanFactory.java---------createBean()

流程图如下:

源码如下:

	/**
	 * Central method of this class: creates a bean instance,
	 * populates the bean instance, applies post-processors, etc.
	 * @see #doCreateBean
	 */
	@Override
	protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
		if (logger.isDebugEnabled()) {
			logger.debug("Creating instance of bean '" + beanName + "'");
		}
		RootBeanDefinition mbdToUse = mbd;

		// Make sure bean class is actually resolved at this point, and
		// clone the bean definition in case of a dynamically resolved Class
		// which cannot be stored in the shared merged bean definition.
        // 确保目标bean的class已经被解析并set到beanDefinition里,返回class
		Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            // dynamically resolved Class 不能存储到shared mergedBeanDefinitions 里,所以deep copy
			mbdToUse = new RootBeanDefinition(mbd);
			mbdToUse.setBeanClass(resolvedClass);
		}

		// Prepare method overrides.
		try {
			mbdToUse.prepareMethodOverrides();
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
					beanName, "Validation of method overrides failed", ex);
		}

		try {
			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
			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);
		}
        // 核心创建bean 方法
		Object beanInstance = doCreateBean(beanName, mbdToUse, args);
		if (logger.isDebugEnabled()) {
			logger.debug("Finished creating instance of bean '" + beanName + "'");
		}
		return beanInstance;
	}

 上述代码调用了 AbstractAutowireCapableBeanFactory的doCreateBean方法:

流程图如下:

源码如下:

	/**
	 * Actually create the specified bean. Pre-creation processing has already happened
	 * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
	 * <p>Differentiates between default bean instantiation, use of a
	 * factory method, and autowiring a constructor.
	 * @param beanName the name of the bean
	 * @param mbd the merged bean definition for the bean
	 * @param args explicit arguments to use for constructor or factory method invocation
	 * @return a new instance of the bean
	 * @throws BeanCreationException if the bean could not be created
	 * @see #instantiateBean
	 * @see #instantiateUsingFactoryMethod
	 * @see #autowireConstructor
	 */
	protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
			throws BeanCreationException {

		// Instantiate the bean.
        // beanWrapper 是 low-level 的javaBeans 的结构,可以操作一些bean的属性
		BeanWrapper instanceWrapper = null;
		if (mbd.isSingleton()) {
			instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
		}
		if (instanceWrapper == null) {
            // 创建制定bean新的实例,选用合适的构造方法调用
			instanceWrapper = createBeanInstance(beanName, mbd, args);
		}
		final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
		Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
		mbd.resolvedTargetType = beanType;

		// Allow post-processors to modify the merged bean definition.
		synchronized (mbd.postProcessingLock) {
			if (!mbd.postProcessed) {
				try {
					applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
				}
				catch (Throwable ex) {
					throw new BeanCreationException(mbd.getResourceDescription(), beanName,
							"Post-processing of merged bean definition failed", ex);
				}
				mbd.postProcessed = true;
			}
		}

		// Eagerly cache singletons to be able to resolve circular references
		// even when triggered by lifecycle interfaces like BeanFactoryAware.
        // 尽早拿到引用,防止循环引用
		boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
				isSingletonCurrentlyInCreation(beanName));
		if (earlySingletonExposure) {
			if (logger.isDebugEnabled()) {
				logger.debug("Eagerly caching bean '" + beanName +
						"' to allow for resolving potential circular references");
			}
			addSingletonFactory(beanName, new ObjectFactory<Object>() {
				@Override
				public Object getObject() throws BeansException {
					return getEarlyBeanReference(beanName, mbd, bean);
				}
			});
		}

		// Initialize the bean instance.
		Object exposedObject = bean;
		try {
            // 给Bean的属性赋值,属性的依赖在此注入
			populateBean(beanName, mbd, instanceWrapper);
			if (exposedObject != null) {
                // 初始化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);
			}
		}
        // 若bean是singleton 并且正在创建
		if (earlySingletonExposure) {
			Object earlySingletonReference = getSingleton(beanName, false);
			if (earlySingletonReference != null) {
                // 正在实例化的bean 和目标bean是一个
				if (exposedObject == bean) {
					exposedObject = earlySingletonReference;
				}
				else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
					String[] dependentBeans = getDependentBeans(beanName);
					Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
					for (String dependentBean : dependentBeans) {
						if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
							actualDependentBeans.add(dependentBean);
						}
					}
					if (!actualDependentBeans.isEmpty()) {
						throw new BeanCurrentlyInCreationException(beanName,
								"Bean with name '" + beanName + "' has been injected into other beans [" +
								StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
								"] in its raw version as part of a circular reference, but has eventually been " +
								"wrapped. This means that said other beans do not use the final version of the " +
								"bean. This is often the result of over-eager type matching - consider using " +
								"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
					}
				}
			}
		}

		// Register bean as disposable.
		try {
			registerDisposableBeanIfNecessary(beanName, bean, mbd);
		}
		catch (BeanDefinitionValidationException ex) {
			throw new BeanCreationException(
					mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
		}

		return exposedObject;
	}

BeanWrapper接口提供一系列对Bean中属性 set get 以及 converter等功能。

可以看到instanceWrapper是由AbstractAutowiredCapableBeanFactory 的createBeanInstance方法创建,

流程图如下:

/**
	 * Create a new instance for the specified bean, using an appropriate instantiation strategy:
	 * factory method, constructor autowiring, or simple instantiation.
	 * @param beanName the name of the bean
	 * @param mbd the bean definition for the bean
	 * @param args explicit arguments to use for constructor or factory method invocation
	 * @return BeanWrapper for the new instance
	 * @see #instantiateUsingFactoryMethod
	 * @see #autowireConstructor
	 * @see #instantiateBean
	 */
	protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
		// Make sure bean class is actually resolved at this point.
		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());
		}

		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;
				}
			}
		}
		if (resolved) {
			if (autowireNecessary) {
				return autowireConstructor(beanName, mbd, null, null);
			}
			else {
				return instantiateBean(beanName, mbd);
			}
		}

		// Need to determine the constructor...
		Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
		if (ctors != null ||
				mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
				mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
			return autowireConstructor(beanName, mbd, ctors, args);
		}

		// No special handling: simply use no-arg constructor.
		return instantiateBean(beanName, mbd);
	}

    从上述代码中,可以看到有三种初始化BeanWrapper的方式,

    (1) instantiateUsingFactoryMethod ---- 当BeanDefinition有工厂方法时

    (2) autowireConstructor ------ 当BeanDefinition有构造函数 或者 args 不为空 等

    (3) instantiateBean ------ 无参时默认构造函数

    三者都调用了 beanFactory.getInstantiationStrategy.instantiate()

    

    默认实现使用了Cglib :

	/**
		 * Create a new instance of a dynamically generated subclass implementing the
		 * required lookups.
		 * @param ctor constructor to use. If this is {@code null}, use the
		 * no-arg constructor (no parameterization, or Setter Injection)
		 * @param args arguments to use for the constructor.
		 * Ignored if the {@code ctor} parameter is {@code null}.
		 * @return new instance of the dynamically generated subclass
		 */
		public Object instantiate(Constructor<?> ctor, Object... args) {
			Class<?> subclass = createEnhancedSubclass(this.beanDefinition);
			Object instance;
			if (ctor == null) {
				instance = BeanUtils.instantiateClass(subclass);
			}
			else {
				try {
					Constructor<?> enhancedSubclassConstructor = subclass.getConstructor(ctor.getParameterTypes());
					instance = enhancedSubclassConstructor.newInstance(args);
				}
				catch (Exception ex) {
					throw new BeanInstantiationException(this.beanDefinition.getBeanClass(),
							"Failed to invoke constructor for CGLIB enhanced subclass [" + subclass.getName() + "]", ex);
				}
			}
			// SPR-10785: set callbacks directly on the instance instead of in the
			// enhanced class (via the Enhancer) in order to avoid memory leaks.
			Factory factory = (Factory) instance;
			factory.setCallbacks(new Callback[] {NoOp.INSTANCE,
					new LookupOverrideMethodInterceptor(this.beanDefinition, this.owner),
					new ReplaceOverrideMethodInterceptor(this.beanDefinition, this.owner)});
			return instance;
		}

至此,getBean()的所有过程已详尽描述。

 

getBean的创建流程,可以从整个调用过程中里的一些关键变量的角度来看这个问题:

AbstractBeanFactory----此层面定义的变量用来控制整个BeanFactory:

List<BeanPostProcessor> beanPostProcessors:createBean时作用的BeanPostProcessors

Map<String,RootBeanDefinition> mergedBeanDefinitions: bean名称与RBD对应的map

Set<String> alreadyCreated :已经至少创建一次的BeanName

ThreadLocal<Object> prototypesCurrentlyInCreation: 正在创建的bean的名称

 

DefaultSingletonBeanRegistry:

Map<String,Object> singletonObjects:ConcurrentHashMap,所有singleton对象,beanName->bean instance

Map<String,ObjectFactory<?>> singletonFactories:singleton工厂对象,beanName->ObjectFactory

Map<String,Object> earlySingletonObjects : 早期的singleton对象。

Set<String> registeredSingletons : 注册的singletons的集合,包含正在注册序列的bean names

Set<String> singletonCurrentlyInCreation : 当前正在创建的bean的names

Set<String> inCreationCheckExclusions : 创建检查之外的Bean的names

Map<String,Object> disposableBeans : beanName -> disposable bean 实例 

Map<String,Set<String>> containedBeanMap: bean包含的bean names的map

Map<String,Set<String>> dependentBeanMap: bean 和 依赖的bean names的map

Map<String,Set<String>> dependeciesForBeanMap : bean 和 引用它的bean names 的map

1.在AbstractBeanFactory---doGetBean里 getSingleton(beanName)里会先看singletonObjects是否有这个Bean,若没有,再看singletonsCurrentlyInCreation里有没有这个Bean。若有,再看earlySingletonObjects里是否有这个Bean,若有直接返回,若没有,再看singletonFactories是否有这个BeanName,若有则创建这个bean,并将其放入 earlySingletonObjects里。

从此过程可以看出 一个Bean 从 ObjectFactory ---> earlySingletonObject -> 完整的Bean的。

 

下一遍会详细说明Spring 中的循环引用是如何处理的?

 

 

  • 打赏
  • 点赞
  • 收藏
  • 分享
共有 人打赏支持
粉丝 1
博文 13
码字总数 28763
×
AlexT
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: