Spring5 IOC源码解读系列3—prepareBeanFactory方法

一 概述

prepareBeanFactory方法的主要作用是配置工厂的标准上下文特征，如上下文的类加载器和后处理器。

二 源码

2.1 prepareBeanFactory

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
		// Tell the internal bean factory to use the context's class loader etc.
        //设置类加载器
		beanFactory.setBeanClassLoader(getClassLoader());
        //设置解析策略
		beanFactory.setBeanExpressionResolver(new StandardBeanExpressionResolver(beanFactory.getBeanClassLoader()));
        //添加属性注册解析器，包括systemEnvironment（操作系统相关）和systemProperties（JVM相关）属性值
		beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this, getEnvironment()));

		// Configure the bean factory with context callbacks.  
        //添加BeanPostProcessor处理器
       // 抽象类ApplicationContextAwareProcessor实现了BeanPostProcessor实现类，重写了postProcessBeforeInitialization方法,在bean的初始化前完成特定类型的bean的手动初始化
       //这些特定类型的bean是不在用户配置文件中声明的  
		beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));       

      //在ApplicationContextAwareProcessor中已经完成了下面六个属性的手动注入，因此直接忽略掉
		beanFactory.ignoreDependencyInterface(EnvironmentAware.class);
beanFactory.ignoreDependencyInterface(EmbeddedValueResolverAware.class);
		beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
		beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
		beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

		// BeanFactory interface not registered as resolvable type in a plain factory.
		// MessageSource registered (and found for autowiring) as a bean.

        //设置属性自动注入
		beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory)；
		beanFactory.registerResolvableDependency(ResourceLoader.class, this);
		beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
		beanFactory.registerResolvableDependency(ApplicationContext.class, this);

          //添加BeanPostProcessor处理器
          //ApplicationListenerDetector主要重新了Bean初始化后和Bean销毁前两个回调的方法。1）Bean初始化前：如果Bean是ApplicationListener类的实例,，而且满足单例。加入到applicationListeners中。2）Bean销毁前： 如果Bean是ApplicationListener的实例，则从事件广播器ApplicationEventMulticaster中删除该Bean。

		beanFactory.addBeanPostProcessor(new ApplicationListenerDetector(this));

		// Detect a LoadTimeWeaver and prepare for weaving, if found.
		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()));
		}

		// Register default environment beans.
        //从织入切面的方式上来看，存在三种织入方式
        //编译期织入：将AspectJ语言编写的切面类织入到Java类中，可以通过一个Ant或Maven任务来完成这个操作；
        //类加载期织入:简称为LTW（loadTimeWeaver）,实现方法1）通过JVM的-javaagent参数设置织入器类包，以代理JVM默认的类加载器；2）在aop.xml文件中指定切面类和需要进行切面织入的目标类。
        //运行期织入:JDK动态代理或者CGLib工具
        
        //判断是否含有类加载器织入
		if (!beanFactory.containsLocalBean(ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
		}
        
        //判断beanFactory是否含有environment，systemProperties和systemEnvironment这三个Bean
        //若无，则添加到一级缓存中
		if (!beanFactory.containsLocalBean(SYSTEM_PROPERTIES_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_PROPERTIES_BEAN_NAME, getEnvironment().getSystemProperties());
		}
		if (!beanFactory.containsLocalBean(SYSTEM_ENVIRONMENT_BEAN_NAME)) {
			beanFactory.registerSingleton(SYSTEM_ENVIRONMENT_BEAN_NAME, getEnvironment().getSystemEnvironment());
		}
	}

2.2 ApplicationContextAwareProcessor类

@Override
	@Nullable
	public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
     //如果bean的类型不属于以下几种，终止方法，直接return
		if (!(bean instanceof EnvironmentAware || bean instanceof EmbeddedValueResolverAware ||
				bean instanceof ResourceLoaderAware || bean instanceof ApplicationEventPublisherAware ||
				bean instanceof MessageSourceAware || bean instanceof ApplicationContextAware)){
			return bean;
		}

		...
        //满足类型的bean，调用invokeAwareInterfaces方法
			invokeAwareInterfaces(bean);
       ...
		return bean;
	}

 
     //对指定类型的bean实现手动注入
	private void invokeAwareInterfaces(Object bean) {
		if (bean instanceof EnvironmentAware) {
			((EnvironmentAware) bean).setEnvironment(this.applicationContext.getEnvironment());
		}
		if (bean instanceof EmbeddedValueResolverAware) {
			((EmbeddedValueResolverAware) bean).setEmbeddedValueResolver(this.embeddedValueResolver);
		}
		if (bean instanceof ResourceLoaderAware) {
			((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
		}
		if (bean instanceof ApplicationEventPublisherAware) {
			((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
		}
		if (bean instanceof MessageSourceAware) {
			((MessageSourceAware) bean).setMessageSource(this.applicationContext);
		}
		if (bean instanceof ApplicationContextAware) {
			((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
		}
	}

2.3 ApplicationListenerDetector类

class ApplicationListenerDetector implements DestructionAwareBeanPostProcessor, MergedBeanDefinitionPostProcessor {

	private final transient AbstractApplicationContext applicationContext;

	private final transient Map<String, Boolean> singletonNames = new ConcurrentHashMap<>(256);


	@Override
	public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {    
       //A.class.isAssignableFrom(B.class)判断 B是否A的父接口或者父类
		if (ApplicationListener.class.isAssignableFrom(beanType)) {
			this.singletonNames.put(beanName, beanDefinition.isSingleton());
		}
	}


	@Override
    //Bean的初始化前调用的方法
	public Object postProcessAfterInitialization(Object bean, String beanName) {
          //Bean是否为ApplicationListener类的实例
		if (bean instanceof ApplicationListener) {
			// potentially not detected as a listener by getBeanNamesForType retrieval
			Boolean flag = this.singletonNames.get(beanName);
            //判断Bean是否为单例
			if (Boolean.TRUE.equals(flag)) {
				// singleton bean (top-level or inner): register on the fly
				//添加到applicationListeners中                this.applicationContext.addApplicationListener((ApplicationListener<?>) bean);
			}
			else if (Boolean.FALSE.equals(flag)) { //不是单例
            //从singletonNames中删除
				this.singletonNames.remove(beanName);
			}
		}
		return bean;
	}

	@Override
	public void postProcessBeforeDestruction(Object bean, String beanName) {
      //Bean是否为ApplicationListener类的实例
		if (bean instanceof ApplicationListener) {
			try {
             //获取事件广播器
				ApplicationEventMulticaster multicaster = this.applicationContext.getApplicationEventMulticaster();
                //删除该Bean
				multicaster.removeApplicationListener((ApplicationListener<?>) bean);
				multicaster.removeApplicationListenerBean(beanName);
			}
			catch (IllegalStateException ex) {
				// ApplicationEventMulticaster not initialized yet - no need to remove a listener
			}
		}
	}

...

}

2.4 addBeanPostProcessor方法

	public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor) {
		Assert.notNull(beanPostProcessor, "BeanPostProcessor must not be null");
		// Remove from old position, if any
        //删除旧的后置处理器
		this.beanPostProcessors.remove(beanPostProcessor);
		// Track whether it is instantiation/destruction aware
        
        
      //判断当前对象是否为InstantiationAwareBeanPostProcessor的实例
		if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) {
            // InstantiationAwareBeanPostProcessor是BeanPostProcessor的子接口，它添加了一个实例化之前的回调，以及一个实例化之后但在显式属性设置或自动装配发生之前的回调。
  //该接口主要面向框架开发，应用层开发的用户建议使用BeanPostProcessor}接口或者抽象类InstantiationAwareBeanPostProcessorAdapter。
			this.hasInstantiationAwareBeanPostProcessors = true;
		}
   
          //判断当前对象是否为DestructionAwareBeanPostProcessor的实例
		if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) {
             // DestructionAwareBeanPostProcessor 是BeanPostProcessor的子接口，用于bean销毁前进行回调。
			this.hasDestructionAwareBeanPostProcessors = true;
		}
		// Add to end of list
        //添加到列表中，用于创建bean
		this.beanPostProcessors.add(beanPostProcessor);
	}

2.5 registerSingleton

public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
		Assert.notNull(beanName, "Bean name must not be null");
		Assert.notNull(singletonObject, "Singleton object must not be null");
        //加对象锁
		synchronized (this.singletonObjects) {
        //singletonObjects是一级缓存，数据结构为ConcurrentHashMap，key为BaenName，value是bean对象实例
       
       //判断是否存在一级缓存
			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);
		}
	}
    
    
    

2.6 addSingleton

protected void addSingleton(String beanName, Object singletonObject) {
		synchronized (this.singletonObjects) {
          //添加到一级缓存
			this.singletonObjects.put(beanName, singletonObject);
            //删除三级缓存
			this.singletonFactories.remove(beanName);
             //删除三级缓存
			this.earlySingletonObjects.remove(beanName);
            //将初始化完的Bean对象的BeanName注册到registeredSingletons中
            //registeredSingletons的数据结构是LinkedHashSet，按顺序维护注册的单例Bean的BeanName
			this.registeredSingletons.add(beanName);
		}
	}

三 参考文献

1）JDK7在线文档
https://tool.oschina.net/apidocs/apidoc?api=jdk_7u4
2) JDK8在线文档
https://docs.oracle.com/javase/8/docs/api/
3) Bruce Eckel. Java编程思想，第4版，2007，机械工业出版社
4）方腾飞，魏鹏，程晓明. Java并发编程的艺术，第1版，2015年，机械工业出版社
5）克雷格.沃斯. Spring实战，第5版，2020年，人民邮电出版社