Spring源代码分析之依赖注入

梦里梦外; 2022-08-27 14:40 172阅读 0赞

//获取IoC容器中指定名称的Bean
 public Object getBean(String name) throws BeansException {
 		//doGetBean才是真正向IoC容器获取被管理Bean的过程
 		return doGetBean(name, null, null, false);
 	}
 	//获取IoC容器中指定名称和类型的Bean
 	public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
 		//doGetBean才是真正向IoC容器获取被管理Bean的过程
 		return doGetBean(name, requiredType, null, false);
 	}
 //获取IoC容器中指定名称和参数的Bean
 	public Object getBean(String name, Object... args) throws BeansException {
 		//doGetBean才是真正向IoC容器获取被管理Bean的过程
 		return doGetBean(name, null, args, false);
 	}
 //获取IoC容器中指定名称、类型和参数的Bean
 	public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
 //doGetBean才是真正向IoC容器获取被管理Bean的过程
 		return doGetBean(name, requiredType, args, false);
 	}
 //真正实现向IoC容器获取Bean的功能，也是触发依赖注入功能的地方
 	@SuppressWarnings("unchecked")
 	protected <T> T doGetBean(
 			final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
 			throws BeansException {
 		//根据指定的名称获取被管理Bean的名称，剥离指定名称中对容器的相关依赖
 		//如果指定的是别名，将别名转换为规范的Bean名称
 		final String beanName = transformedBeanName(name);
 		Object bean;
 		//先从缓存中取是否已经有被创建过的单态类型的Bean，对于单态模式的Bean整
 //个IoC容器中只创建一次，不需要重复创建
 		Object sharedInstance = getSingleton(beanName);
 		//IoC容器创建单态模式Bean实例对象
 		if (sharedInstance != null && args == null) {
 			if (logger.isDebugEnabled()) {
 				//如果指定名称的Bean在容器中已有单态模式的Bean被创建，直接返回
 //已经创建的Bean
 				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 + "'");
 				}
 			}
 			//获取给定Bean的实例对象，主要是完成FactoryBean的相关处理
 			//注意：BeanFactory是管理容器中Bean的工厂，而FactoryBean是
 			//创建创建对象的工厂Bean，两者之间有区别
 			bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
 		}
 		else {//缓存没有正在创建的单态模式Bean
 			//缓存中已经有已经创建的原型模式Bean，但是由于循环引用的问题导致实
 //例化对象失败
 			if (isPrototypeCurrentlyInCreation(beanName)) {
 				throw new BeanCurrentlyInCreationException(beanName);
 			}
 			//对IoC容器中是否存在指定名称的BeanDefinition进行检查，首先检查是否
 			//能在当前的BeanFactory中获取的所需要的Bean，如果不能则委托当前容器
 			//的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找
 			BeanFactory parentBeanFactory = getParentBeanFactory();
 			//当前容器的父级容器存在，且当前容器中不存在指定名称的Bean
 			if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
 				//解析指定Bean名称的原始名称
 				String nameToLookup = originalBeanName(name);
 				if (args != null) {
 					//委派父级容器根据指定名称和显式的参数查找
 					return (T) parentBeanFactory.getBean(nameToLookup, args);
 				}
 				else {
 					//委派父级容器根据指定名称和类型查找
 					return parentBeanFactory.getBean(nameToLookup, requiredType);
 				}
 			}
 			//创建的Bean是否需要进行类型验证，一般不需要
 			if (!typeCheckOnly) {
 				//向容器标记指定的Bean已经被创建
 				markBeanAsCreated(beanName);
 			}
 		//根据指定Bean名称获取其父级的Bean定义，主要解决Bean继承时子类
 //合并父类公共属性问题
 			final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
 			checkMergedBeanDefinition(mbd, beanName, args);
 			//获取当前Bean所有依赖Bean的名称
 			String[] dependsOn = mbd.getDependsOn();
 			//如果当前Bean有依赖Bean
 			if (dependsOn != null) {
 				for (String dependsOnBean : dependsOn) {
 					//递归调用getBean方法，获取当前Bean的依赖Bean
 					getBean(dependsOnBean);
 					//把被依赖Bean注册给当前依赖的Bean
 					registerDependentBean(dependsOnBean, beanName);
 				}
 			}
 			//创建单态模式Bean的实例对象
 			if (mbd.isSingleton()) {
 			//这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象
 				sharedInstance = getSingleton(beanName, new ObjectFactory() {
 					public Object getObject() throws BeansException {
 						try {
 //创建一个指定Bean实例对象，如果有父级继承，则合并子//类和父类的定义
 							return createBean(beanName, mbd, args);
 						}
 						catch (BeansException ex) {
 							//显式地从容器单态模式Bean缓存中清除实例对象
 							destroySingleton(beanName);
 							throw ex;
 						}
 					}
 				});
 				//获取给定Bean的实例对象
 				bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
 			}
 			//IoC容器创建原型模式Bean实例对象
 			else if (mbd.isPrototype()) {
 				//原型模式(Prototype)是每次都会创建一个新的对象
 				Object prototypeInstance = null;
 				try {
 //回调beforePrototypeCreation方法，默认的功能是注册当前创//建的原型对象
 					beforePrototypeCreation(beanName);
 					//创建指定Bean对象实例
 					prototypeInstance = createBean(beanName, mbd, args);
 				}
 				finally {
 //回调afterPrototypeCreation方法，默认的功能告诉IoC容器指//定Bean的原型对象不再创建了
 					afterPrototypeCreation(beanName);
 				}
 				//获取给定Bean的实例对象
 				bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
 			}
 			//要创建的Bean既不是单态模式，也不是原型模式，则根据Bean定义资源中
 //配置的生命周期范围，选择实例化Bean的合适方法，这种在Web应用程序中
 //比较常用，如：request、session、application等生命周期
 			else {
 				String scopeName = mbd.getScope();
 				final Scope scope = this.scopes.get(scopeName);
 				//Bean定义资源中没有配置生命周期范围，则Bean定义不合法
 				if (scope == null) {
 					throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
 				}
 				try {
 					//这里又使用了一个匿名内部类，获取一个指定生命周期范围的实例
 					Object scopedInstance = scope.get(beanName, new ObjectFactory() {
 						public Object getObject() throws BeansException {
 							beforePrototypeCreation(beanName);
 							try {
 								return createBean(beanName, mbd, args);
 							}
 							finally {
 								afterPrototypeCreation(beanName);
 							}
 						}
 					});
 					//获取给定Bean的实例对象
 					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);
 				}
 			}
 		}
 		//对创建的Bean实例对象进行类型检查
 		if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
 			throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
 		}
 		return (T) bean;
 	}

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)
    			throws BeanCreationException {
    
    		if (logger.isDebugEnabled()) {
    			logger.debug("Creating instance of bean '" + beanName + "'");
    		}
    		// Make sure bean class is actually resolved at this point.
    		resolveBeanClass(mbd, beanName);
    
    		// Prepare method overrides.
    		try {
    			mbd.prepareMethodOverrides();
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanDefinitionStoreException(mbd.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, mbd);
    			if (bean != null) {
    				return bean;
    			}
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"BeanPostProcessor before instantiation of bean failed", ex);
    		}
    
    		Object beanInstance = doCreateBean(beanName, mbd, args);
    		if (logger.isDebugEnabled()) {
    			logger.debug("Finished creating instance of bean '" + beanName + "'");
    		}
    		return beanInstance;
    	}

//判断当前的Bean是否可以被实例化，即是否可以被当前的类加载器所加载

resolveBeanClass(mbd, beanName);
    
    		// Prepare method overrides.

//准备校验和Bean中的方法覆盖

try {
    			mbd.prepareMethodOverrides();
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
    					beanName, "Validation of method overrides failed", ex);
    		}
    
    		try {
    			// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.

//如果Bean配置了初始化前和初始化后的处理器，则试图创建一个代理对象

Object bean = resolveBeforeInstantiation(beanName, mbd);
    			if (bean != null) {
    				return bean;
    			}
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"BeanPostProcessor before instantiation of bean failed", ex);
    		}
    
    		//创建Bean的入口

Object beanInstance = doCreateBean(beanName, mbd, args);
    		if (logger.isDebugEnabled()) {
    			logger.debug("Finished creating instance of bean '" + beanName + "'");
    		}
    		return beanInstance;
    	}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    		// 封装被创建的对象

BeanWrapper instanceWrapper = null;

//单例的Bean先从缓存中获取

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);
 
 		// Allow post-processors to modify the merged bean definition.

//调用PostProcessor的后置处理器

synchronized (mbd.postProcessingLock) {
 			if (!mbd.postProcessed) {
 				applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
 				mbd.postProcessed = true;
 			}
 		}
 
 		 //向容器中缓存单态模式的Bean对象，以防循环引用

// 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>() {
 				public Object getObject() throws BeansException {
 					return getEarlyBeanReference(beanName, mbd, bean);
 				}
 			});
 		}
 
 		// Bean对象的初始化，依赖注入从此开始

Object exposedObject = bean;
    		try {

//将Bean实例对象封装，并且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);
    			}
    		}
    
    		if (earlySingletonExposure) {

//获取指定名称的已注册的单态模式Bean对象

Object earlySingletonReference = getSingleton(beanName, false);
    			if (earlySingletonReference != null) {

//根据名称获取的以注册的Bean和正在实例化的Bean是同一个

if (exposedObject == bean) {

//当前实例化的Bean初始化完成

exposedObject = earlySingletonReference;
    				}

//当前Bean依赖其他Bean，并且当发生循环引用时不允许新创建实例对象

else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
 					String[] dependentBeans = getDependentBeans(beanName);
 					Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);

//获取当前Bean所依赖的其他Bean 
 					for (String dependentBean : dependentBeans) {

//对依赖Bean进行类型检查

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.

//注册完成依赖注入的Bean

try {
    			registerDisposableBeanIfNecessary(beanName, bean, mbd);
    		}
    		catch (BeanDefinitionValidationException ex) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    		}
    
    		return exposedObject;
    	}

1 createBeanInstance: 生成Bean所包含的Java对象的实例

2 populateBean: 对Bean的属性的依赖注入进行处理

在createBeanInstance方法中创建Bean的Java实例对象：

在createBeanInstance方法中，根据指定的初始化策略，使用静态工厂，工厂方法或者容器生成Java的实例对象

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    		// Make sure bean class is actually resolved at this point.

//确认创建的Bean的实例的类可以被实例化

Class<?> beanClass = resolveBeanClass(mbd, beanName);
 
 		//这里使用工厂方法对Bean进行实例化

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);
 	}