Spring Bean实例化流程-优快云博客

本文链接：https://blog.youkuaiyun.com/qq_22866497/article/details/89296642

Bean实例化前奏

在从配置文件中载入Bean定义，并解析成相应的BeanDefinition，注册Bean的后置处理器并调用，初始化好国际资源，事件广播等组件，注册监听器后，接下来就要做非懒加载bean的实例化工作。这个是在refresh()方法中调用finishBeanFactoryInitialization(beanFactory)方法完成的。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
		// 我们在配置文件中有时会注册一些转换器(见下面的配置)，就是在这个地方初始化的
		if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
				beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
			beanFactory.setConversionService(
					beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
		}

		// 切面的织入时期有三个：编译期，类加载期，运行期，我们用的最多的是运行期切面织入
		// 这个是对类加载时期进行切面织入的初始化，不过需要使用Ajc编译器
		String[] weaverAwareNames = beanFactory.getBeanNamesForType(LoadTimeWeaverAware.class, false, false);
		for (String weaverAwareName : weaverAwareNames) {
			getBean(weaverAwareName);
		}

		// 回收用于判断类型匹配的类加载器
		beanFactory.setTempClassLoader(null);

		// 缓存所有的BeanDefinition元数据，不希望再改变
		beanFactory.freezeConfiguration();

		// 实例化所有的非懒加载单例类
		beanFactory.preInstantiateSingletons();
	}

<!-- 自定义转换器 -->
    <bean id="conversionService" class="org.springframework.context.support.ConversionServiceFactoryBean">
        <property name="converters">
            <set>
                <bean class="convertservice.StringToDateConverter">
                    <property name="datePattern" value="yyyy-MM-dd"/>
                </bean>
            </set>
        </property>
    </bean>

下面来看看preInstantiateSingletons()方法。在这个方法中我们会遇到一个Spring中容易混淆的概念FactoryBean和BeanFactory。众所周知，BeanFactroy是管理bean的容器，而FactroyBean是能够创建对象和修饰对象的工厂Bean，
通过getBean(&+factoryBeanName)能够从容器中获取到FactroyBean本身，通过getBean(factoryBeanName)则从容器中获取到的是FactroyBean的getObject()方法生成的对象。通过实现FactoryBean接口自定义FactoryBean。

public class SmartFactoryBeanTest implements SmartFactoryBean {

    public boolean isPrototype() {
        return false;
    }

    public boolean isEagerInit() {
        System.out.println("========================SmartFactoryBeanTest");
        return true;
    }

    public Object getObject() throws Exception {
        return new Parent();
    }

    public Class<?> getObjectType() {
        return null;
    }

    public boolean isSingleton() {
        return false;
    }
}

@Override
	public void preInstantiateSingletons() throws BeansException {
		if (this.logger.isDebugEnabled()) {
			this.logger.debug("Pre-instantiating singletons in " + this);
		}

		// 用副本进行遍历，防止遍历时集合改变
		List<String> beanNames = new ArrayList<String>(this.beanDefinitionNames);

		for (String beanName : beanNames) {
			// 有时为了配置文件(见下面的配置)中某些配置能够复用，我们会定义Bean之间的父子关系
			// 这里是将其父BeanDefinition和子BeanDefinition合并的地方
			RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
			// 如果这个BeanDefintion不是抽象的，并且是单例的，并且是懒加载的
			if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
				// 判断是不是FactoryBean
				if (isFactoryBean(beanName)) {
					final FactoryBean<?> factory = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName);
					boolean isEagerInit;
					if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
						isEagerInit = AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
							@Override
							public Boolean run() {
								return ((SmartFactoryBean<?>) factory).isEagerInit();
							}
						}, getAccessControlContext());
					}
					else {
						// 调用isEagerInit()方法
						isEagerInit = (factory instanceof SmartFactoryBean &&
								((SmartFactoryBean<?>) factory).isEagerInit());
					}
					if (isEagerInit) {
						// 触发实例化
						getBean(beanName);
					}
				}
				else {
					// 触发实例化
					getBean(beanName);
				}
			}
		}

		// Trigger post-initialization callback for all applicable beans...
		for (String beanName : beanNames) {
			Object singletonInstance = getSingleton(beanName);
			if (singletonInstance instanceof SmartInitializingSingleton) {
				final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
				if (System.getSecurityManager() != null) {
					AccessController.doPrivileged(new PrivilegedAction<Object>() {
						@Override
						public Object run() {
							smartSingleton.afterSingletonsInstantiated();
							return null;
						}
					}, getAccessControlContext());
				}
				else {
					smartSingleton.afterSingletonsInstantiated();
				}
			}
		}
	}

 <!-- 该bean不会被实例化,只用于提取公共配置,实现属性继承 -->
    <bean id="parent" class="parent.Parent" abstract="true" lazy-init="true">
        <property name="username" value="parent name"/>
    </bean>
    <bean id="son" class="parent.Son" parent="parent">
        <!--<property name="username" value="son name"/>-->
        <property name="age" value="18"/>
    </bean>

下面来看看是如何完成父BeanDefinition和子BeanDefinition的合并的。开始先看一下RootBeanDefiniton的构造函数。

	RootBeanDefinition(BeanDefinition original) {
		// 调用父容器AbstractBeanDefiniton的构造函数
		super(original);
	}
	
	protected AbstractBeanDefinition(BeanDefinition original) {
		// 设置父BeanDefintion名字
		setParentName(original.getParentName());
		setBeanClassName(original.getBeanClassName());
		setFactoryBeanName(original.getFactoryBeanName());
		setFactoryMethodName(original.getFactoryMethodName());
		setScope(original.getScope());
		setAbstract(original.isAbstract());
		setLazyInit(original.isLazyInit());
		setRole(original.getRole());
		setConstructorArgumentValues(new ConstructorArgumentValues(original.getConstructorArgumentValues()));
		setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));
		setSource(original.getSource());
		copyAttributesFrom(original);

		if (original instanceof AbstractBeanDefinition) {
			AbstractBeanDefinition originalAbd = (AbstractBeanDefinition) original;
			if (originalAbd.hasBeanClass()) {
				setBeanClass(originalAbd.getBeanClass());
			}
			setAutowireMode(originalAbd.getAutowireMode());
			setDependencyCheck(originalAbd.getDependencyCheck());
			setDependsOn(originalAbd.getDependsOn());
			setAutowireCandidate(originalAbd.isAutowireCandidate());
			copyQualifiersFrom(originalAbd);
			setPrimary(originalAbd.isPrimary());
			setNonPublicAccessAllowed(originalAbd.isNonPublicAccessAllowed());
			setLenientConstructorResolution(originalAbd.isLenientConstructorResolution());
			setInitMethodName(originalAbd.getInitMethodName());
			setEnforceInitMethod(originalAbd.isEnforceInitMethod());
			setDestroyMethodName(originalAbd.getDestroyMethodName());
			setEnforceDestroyMethod(originalAbd.isEnforceDestroyMethod());
			setMethodOverrides(new MethodOverrides(originalAbd.getMethodOverrides()));
			setSynthetic(originalAbd.isSynthetic());
			setResource(originalAbd.getResource());
		}
		else {
			setResourceDescription(original.getResourceDescription());
		}
	}

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
		// 首先从缓存中找
		RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
		if (mbd != null) {
			return mbd;
		}
		return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
	}

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd)
			throws BeanDefinitionStoreException {

		return getMergedBeanDefinition(beanName, bd, null);
	}

protected RootBeanDefinition getMergedBeanDefinition(
			String beanName, BeanDefinition bd, BeanDefinition containingBd)
			throws BeanDefinitionStoreException {

		synchronized (this.mergedBeanDefinitions) {
			RootBeanDefinition mbd = null;

			// 首先尝试从缓存中获取合并后的beanDefinition
			if (containingBd == null) {
				mbd = this.mergedBeanDefinitions.get(beanName);
			}

			if (mbd == null) {
				// 如果bean标签的parent属性为null，表明不需要合并
				if (bd.getParentName() == null) {
					// 如果此BeanDefinition是RootBeanDefinition类型的
					if (bd instanceof RootBeanDefinition) {
						// 就以此BeanDefinition为父BeanDefinition进行深拷贝一份
						mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
					}
					else {
						// 否则new一个
						mbd = new RootBeanDefinition(bd);
					}
				}
				else {
					BeanDefinition pbd;
					try {
						// 标准化bean名字
						String parentBeanName = transformedBeanName(bd.getParentName());
						// 如果bean的名称和父bean名称不一样
						if (!beanName.equals(parentBeanName)) {
							pbd = getMergedBeanDefinition(parentBeanName);
						}
						else {
							// 否则去父容器中合并
							if (getParentBeanFactory() instanceof ConfigurableBeanFactory) {
								pbd = ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(parentBeanName);
							}
							else {
								throw new NoSuchBeanDefinitionException(bd.getParentName(),
										"Parent name '" + bd.getParentName() + "' is equal to bean name '" + beanName +
										"': cannot be resolved without an AbstractBeanFactory parent");
							}
						}
					}
					catch (NoSuchBeanDefinitionException ex) {
						throw new BeanDefinitionStoreException(bd.getResourceDescription(), beanName,
								"Could not resolve parent bean definition '" + bd.getParentName() + "'", ex);
					}
					// 深拷贝父BeanDefinition
					mbd = new RootBeanDefinition(pbd);
					// 用子BeanDefinition覆盖父BeanDefinition中的配置
					mbd.overrideFrom(bd);
				}

				// 如果没有设置scope，默认为单例
				if (!StringUtils.hasLength(mbd.getScope())) {
					mbd.setScope(RootBeanDefinition.SCOPE_SINGLETON);
				}

				// 包含在非单例bean中bean不能自己为单例，需要设置为包含的bean的sceope属性
				if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
					mbd.setScope(containingBd.getScope());
				}

				// 缓存合并后的BeanDefinition
				if (containingBd == null && isCacheBeanMetadata()) {
					this.mergedBeanDefinitions.put(beanName, mbd);
				}
			}

			return mbd;
		}
	}

@Override
	public BeanDefinition getMergedBeanDefinition(String name) throws BeansException {
		String beanName = transformedBeanName(name);

		// 子容器中没有就去父容器合并
		if (!containsBeanDefinition(beanName) && getParentBeanFactory() instanceof ConfigurableBeanFactory) {
			return ((ConfigurableBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName);
		}
		// 本地合并，递归直到没有父BeanDefinition
		return getMergedLocalBeanDefinition(beanName);
	}