Spring源码：Supplier、工厂方法实例化Bean-createBeanInstance

水深无声 2024-03-24 06:31 9阅读 0赞

## 前言 ##

程序执行了 `resolveBeforeInstantiation` 函数之后，如果返回的结果为 null，就需要执行 `doCreateBean` 函数进行创建 Bean。本篇就来分析 `doCreateBean` 的代码逻辑

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    	throws BeanCreationException {
    
    // Instantiate the bean.
    // BeanWrapper是对Bean的包装
    BeanWrapper instanceWrapper = null;
    //1、如果是单例，移除缓存
    if (mbd.isSingleton()) {
    	// factoryBeanObjectCache：存的是beanName对应的FactoryBean.getObject()所返回的对象
    	// factoryBeanInstanceCache：存的是beanName对应的FactoryBean实例对象
    	instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    
    // 2、实例化
    if (instanceWrapper == null) {
    	// 创建bean实例 1、工厂方法 2、构造函数自动注入 3、简单初始化
    	instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    
    // 包装的实例对象，也就是原始对象
    final Object bean = instanceWrapper.getWrappedInstance();
    // 包装的实例对象的类型
    Class<?> beanType = instanceWrapper.getWrappedClass();
    // 如果不是NullBean，则将resolvedTargetType 属性设置为当前的WrappedClass
    if (beanType != NullBean.class) {
    	mbd.resolvedTargetType = beanType;
    }
    
    //3、寻找注入点
    synchronized (mbd.postProcessingLock) {
    	if (!mbd.postProcessed) {
    		try {
    			// 这里会查找@Autowired、@Value、Resource的注入点(InjectedElement)，
    			// 并把这些注入点添加到mbd的属性externallyManagedConfigMembers中
    			applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
    		}
    		catch (Throwable ex) {
    			throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    					"Post-processing of merged bean definition failed", ex);
    		}
    		mbd.postProcessed = true;
    	}
    }
    //4、
    //如果当前bean是单例并且支持循环依赖，且当前bean正在创建，
    //就通过往singletonFactories(三级缓存)添加一个objectFactory，
    //这样后期如果有其他bean依赖该bean 可以从singletonFactories获取到bean， 解决循环依赖
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
    		isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
    	if (logger.isTraceEnabled()) {
    		logger.trace("Eagerly caching bean '" + beanName +
    				"' to allow for resolving potential circular references");
    	}
    	// 构造一个 ObjectFactory 添加到singletonFactories中
            // getEarlyBeanReference()可以对 返回的bean进行修改，目前除了可能会返回动态代理对象（aop） 其他的都是直接返回bean
    	addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    
    Object exposedObject = bean;
    try {
    	// 5、填充属性，对 bean 进行填充 将各个属性注入
    	populateBean(beanName, mbd, instanceWrapper);
    
    	// 6、执行初始化方法
    	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);
    	}
    }
    // 7、检测循环依赖
    if (earlySingletonExposure) {
    	// earlySingletonReference 只有在检测到有循环依赖的情况下才会不为空
    	Object earlySingletonReference = getSingleton(beanName, false);
    	if (earlySingletonReference != null) {
    		// 如果提前暴露的对象(bean)和经过了完整的生命周期后的对象相等(exposedObject)
    		// 则把缓存中的earlySingletonReference赋值给exposedObject
    		// 最终会添加到singletonObjects中去
    		// (初始化之后的bean等于原始的bean，说明不是proxy），
    		//
    		if (exposedObject == bean) {
    			exposedObject = earlySingletonReference;
    	}
    		//检测该bean的dependon的bean是否都已经初始化好了
    		else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
    			String[] dependentBeans = getDependentBeans(beanName);
    			Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
    			for (String dependentBean : dependentBeans) {
    				if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
    					actualDependentBeans.add(dependentBean);
    				}
    			}
    			/*
    			* 因为 bean 创建后；其所依赖的 bean 一定是创建了的。
    			* actualDependentBeans 不为空表示当 bean 创建后依赖的 bean 没有
    			* 全部创建完，也就是说存在循环依赖
    			*/
    			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 {
                // 8、注册DisposableBean
                registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
                throw new BeanCreationException(
                                mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }
    
        return exposedObject;
        }
    }
    复制代码

上述代码分支挺多的，总结一下关键点：

1、如果是单例则需要首先清除缓存

2、实例化 `Bean`，有四种方式：工厂方法，`Supplier` 回调、有参构造函数自动注入、默认构造函数注入

3、`MergedBeanDefinitionPostProcessor` 的使用

4、单例模式下的依赖处理

5、属性填充，将所有属性填充至 bean 的实例中

6、执行初始化方法

7、循环依赖检查，存在循环依赖则抛出异常

8、注册 `DisposableBean`

第一点就不再分析了。我们来看第二点实例化Bean `createBeanInstance`方法。本文就分析其中两种实例化Bean 的方式。分别是：工厂方法，Supplier 回调。其余两种放到下一篇。

## createBeanInstance ##

进入到`createBeanInstance`方法， 该方法位于 `AbstractAutowireCapableBeanFactory` 类中

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    
        // 得到bean的class  使用类加载器根据设置的 class 属性或者根据 className 来解析 Class
        Class<?> beanClass = resolveBeanClass(mbd, beanName);
        // 如果beanclass不是public 且不允许访问非public方法和属性则抛出异常
        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());
        }
    
        // 这是Spring提供给开发者的扩展点
        // 当一个BeanDefinition中存在一个Supplier类的时候, Spring就利用这个类的get方法来获取实例,
        Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
                return obtainFromSupplier(instanceSupplier, beanName);
        }
    
        // 通过factoryMethod实例化这个bean
        // factorMethod这个名称在xml中还是比较常见的, 即通过工厂方法来创建bean对象
        // 如果一个bean对象是由@Bean注解创建的, 也会走instantiateUsingFactoryMethod方法来创建
        if (mbd.getFactoryMethodName() != null) {
                return instantiateUsingFactoryMethod(beanName, mbd, args);
        }
    
    
        // Shortcut when re-creating the same bean... 重新创建相同bean时的快捷方式
        boolean resolved = false;
        boolean autowireNecessary = false;
        // 当作用域为原型、多次调用getBean()时，不传入参数，从缓存中获取这段逻辑才会被执行
    // 如果是单例，第二次调用 getBean()，直接从单例池获取对象了，根本就不会走到这里
        if (args == null) {
                synchronized (mbd.constructorArgumentLock) {
                        // resolvedConstructorOrFactoryMethod 缓存了已解析的构造函数或工厂方法
                        if (mbd.resolvedConstructorOrFactoryMethod != null) {
            // resolved为true，表示当前bean的构造方法已经确定