3.3-1、Spring源码学习：prepareBeanFactory(beanFactory);

蔚落 2023-06-05 05:46 1阅读 0赞

### 文章目录 ###

*   *   *  前言
         *  承上启下
         *  AbstractApplicationContext.prepareBeanFactory(ConfigurableListableBeanFactory beanFactory)
         *   *  beanFactory 添加单例 bean 的过程
             *   *  DefaultListableBeanFactory.registerSingleton(String beanName, Object singletonObject)
                 *  DefaultSingletonBeanRegistry.registerSingleton(String beanName, Object singletonObject)
                 *  DefaultSingletonBeanRegistry.addSingleton(String beanName, Object singletonObject)
                 *  判断是否开始创建bean:hasBeanCreationStarted()
                 *  清除缓存: clearByTypeCache()
         *  参考资料

### 前言 ###

> 世界观第一,体能第二,技术第三

### 承上启下 ###

> 本文就Spring 源码中 `refresh()`方法中的 `prepareBeanFactory(beanFactory);`进行学习和解读.  
> 相较而言，本方法内部的逻辑不算复杂。  
> 本方法用于设置 beanFactory 的类加器、SpEL解析器、bean的属性编辑器、特殊接口的免自动注入和特殊类型的指定注入.对环境相关的对象 environment、systemProperties、systemEnvironment 设置为 beanFactory 单例.

### AbstractApplicationContext.prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) ###

> org.springframework.context.support.AbstractApplicationContext.prepareBeanFactory(ConfigurableListableBeanFactory beanFactory)

> 本方法内部没有太多复杂的逻辑,主要做了一些准备工作,具体看注释吧

/** * Configure the factory's standard context characteristics, * such as the context's ClassLoader and post-processors. * @param beanFactory the BeanFactory to configure */
    	protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) { 
    		//为内部 bean factory 指定使用 上下文类加载器
    		// Tell the internal bean factory to use the context's class loader etc.
    		beanFactory.setBeanClassLoader(getClassLoader());
    		
    		//指定 bean 表达解析器为 StandardBeanExpressionResolver,用于解析 Spring EL 表达式,前缀为 "#{",后缀为"}"
    		// 用法,比如Java代码中 @Value("#{表达式}") 
    		// 用法,比如xml文档中 <property name="arg" value="#{表达式}">
    		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
    		
    		//设置 bean 属性编辑器,便于对bean的属性进行编辑
    		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));
    
    		// Configure the bean factory with context callbacks.
    		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
    		
    		//ignoreDependencyInterface 表示该接口不使用自动注入 
    		//ResourceLoaderAware、ApplicationEventPublisherAware、
    		//MessageSourceAware、ApplicationContextAware、EnvironmentAware
    		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
    		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
    		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
    		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);
    		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
    
    		// registerResolvableDependency 表示该类型使用指定的对象注入
    		// 比如 BeanFactory.class 就注入 beanFactory 对象
    		//ResourceLoader.class、ApplicationEventPublisher.class、ApplicationContext.class 就注入 this-调用类自身
    		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
    		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
    		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
    		beanFactory.registerResolvableDependency(ApplicationContext.class, this);
    
    		//默认不会进入内部逻辑
    		//增加了对AspectJ的支持
    		//spring的loadTimeWeaver主要是通过 instrumentation 的动态字节码增强在装载期注入依赖
    		if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME)) { 
    			beanFactory.addBeanPostProcessor(new LoadTimeWeaverAwareProcessor(beanFactory));
    			// Set a temporary ClassLoader for type matching.
    			beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
    		}
    
    		// 下面是三个为 beanFactory 添加单例的代码,后面会单独讲解.
    		// 注册默认的环境相关 beans.
    		// beanName 为 environment
    		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) { 
    			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
    		}
    		//beanName 为 systemProperties
    		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) { 
    			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
    		}
    		//beanName 为 systemEnvironment
    		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) { 
    			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
    		}
    	}

#### beanFactory 添加单例 bean 的过程 ####

> 上面代码片段中,有将三个和上下文环境相关的对象添加为 beanFactory 单例 bean的逻辑.  
> 以 `beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());`为例.

##### DefaultListableBeanFactory.registerSingleton(String beanName, Object singletonObject) #####

> org.springframework.beans.factory.support.DefaultListableBeanFactory.registerSingleton(String beanName, Object singletonObject)

@Override
    public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException { 
    	//关键的一行
    	super.registerSingleton(beanName, singletonObject);
    	
    	//如果尚未开始创建
    	if (hasBeanCreationStarted()) { 
    		// Cannot modify startup-time collection elements anymore (for stable iteration)
    		synchronized (this.beanDefinitionMap) { 
    			if (!this.beanDefinitionMap.containsKey(beanName)) { 
    				Set<String> updatedSingletons = new LinkedHashSet<String>(this.manualSingletonNames.size() + 1);
    				updatedSingletons.addAll(this.manualSingletonNames);
    				updatedSingletons.add(beanName);
    				this.manualSingletonNames = updatedSingletons;
    			}
    		}
    	}
    	else { 
    		// 依旧在启动阶段
    		//如果 beanDefinitionMap 不包含 beanName,则将该beanName添加到 manualSingletonNames(手动单例名字Set集合中)
    		if (!this.beanDefinitionMap.containsKey(beanName)) { 
    			this.manualSingletonNames.add(beanName);
    		}
    	}
    
    	clearByTypeCache();
    }

##### DefaultSingletonBeanRegistry.registerSingleton(String beanName, Object singletonObject) #####

> org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.registerSingleton(String beanName, Object singletonObject)

@Override
    public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException { 
    	Assert.notNull(beanName, "'beanName' must not be null");
    	synchronized (this.singletonObjects) { 
    		// 如果单例对象已经存在了,则抛出异常
    		Object oldObject = this.singletonObjects.get(beanName);
    		if (oldObject != null) { 
    			throw new IllegalStateException("Could not register object [" + singletonObject +
    					"] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
    		}
    		//这是关键一行
    		addSingleton(beanName, singletonObject);
    	}
    }

##### DefaultSingletonBeanRegistry.addSingleton(String beanName, Object singletonObject) #####

> org.springframework.beans.factory.support.DefaultSingletonBeanRegistry.addSingleton(String beanName, Object singletonObject)

protected void addSingleton(String beanName, Object singletonObject) { 
    	synchronized (this.singletonObjects) { 
    		//下面几个都是 Map 对象
    		//单例对象
    		this.singletonObjects.put(beanName, (singletonObject != null ? singletonObject : NULL_OBJECT));
    		//单例工厂
    		this.singletonFactories.remove(beanName);
    		//早期的单例对象
    		this.earlySingletonObjects.remove(beanName);
    		//已被注册的单例
    		this.registeredSingletons.add(beanName);
    	}
    }

##### 判断是否开始创建bean:hasBeanCreationStarted() #####

protected boolean hasBeanCreationStarted() { 
    //如果非空,表示已经开始创建,否则表示尚未开始创建
    		return !this.alreadyCreated.isEmpty();
    	}

##### 清除缓存: clearByTypeCache() #####

> 清除缓存,防止之前到调用到影响

private void clearByTypeCache() { 
    		this.allBeanNamesByType.clear();
    		this.singletonBeanNamesByType.clear();
    	}

### 参考资料 ###

> \[1\]、https://yq.aliyun.com/articles/666890  
> \[2\]、https://blog.csdn.net/cuichunchi/article/details/90407632