【框架专题】——管理型容器——SpringIOC源码——容器整体层——beanFactory/ApplicationContext

本文原文章：https://blog.csdn.net/qq_41907991/article/details/105197581，我对此做出了全新的整理

beanFactory——接口概述

beanFactory

public interface BeanFactory {

    /*
       @利用工厂——————获取Bean的接口
     */
	Object getBean(String name) throws BeansException;// 都是用于获取指定的Bean，根据名称获取指定类型获取
	<T> T getBean(String name, Class<T> requiredType) throws BeansException;
	Object getBean(String name, Object... args) throws BeansException;
	<T> T getBean(Class<T> requiredType) throws BeansException;
	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;


    /*
       @利用工厂——————获取指定的Bean的ObjectProvider，后续讲讲什么叫ObjectProvider
     */
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
	<T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
	
    /*
      @利用工厂——————对bean的一些判断
     */
	boolean containsBean(String name);// 检查容器中是否含有这个名称的Bean
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException; // 判断指定的Bean是否为单例
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;// 判断指定的Bean是否为原型
	
    // 判断指定的Bean类型是否匹配，关于ResolvableType我已经专门写文章介绍过了，请参考我《Spring杂谈》相关文章
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
	boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
	
     /*
      @利用工厂——————对bean的额外信息的获取
     */
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;// 返回指定Bean的类型
	String[] getAliases(String name);// 返回指定Bean的别名



    /*
       FactroyBean的前缀，如果getBean的时候BeanName有这个前缀，会去获取对应的FactroyBean
       而不是获取FactroyBean的getObject返回的Bean
     */
	String FACTORY_BEAN_PREFIX = "&";

}

HierarchicalBeanFactory

HierarchicalBeanFactory对顶层的BeanFactory做了扩展，让其具有了父子层级关系，仅此而已

public interface HierarchicalBeanFactory extends BeanFactory {
    @Nullable
	BeanFactory getParentBeanFactory();// 获取父容器
	boolean containsLocalBean(String name);// 获取父系容器，只在当前容器中判断是否包含这个名称的Bean
}

ListableBeanFactory——批量获取

public interface ListableBeanFactory extends BeanFactory {

   /*
       （A）获取类
    */

    /* 
      利用工厂————获取（指定name）的bean元信息（忽略父子容器）
     */
	boolean containsBeanDefinition(String beanName);

  /* 
      利用工厂————获取（所有）bean元信息的个数（忽略父子容器）
     */
	int getBeanDefinitionCount();

      /* 
      利用工厂————获取（所有）bean元信息的name名（忽略父子容器）
     */
	String[] getBeanDefinitionNames();

    /* 
      利用工厂————获取（指定类型）所有bean的name名（忽略父子容器）
      既会通过BeanDefinition做判断，也会通过FactoryBean的getObjectType方法判断
      
      includeNonSingletons：是否能包含非单例的Bean
      allowEagerInit：是否允许对”懒加载"的Bean进行实例化,这里主要针对FactoryBean，因为FactoryBean
     */
	String[] getBeanNamesForType(ResolvableType type);
	String[] getBeanNamesForType(@Nullable Class<?> type);
	String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

     
     /*
       利用工厂————获取（指定类型的）map这种结构
       includeNonSingletons：是否能包含非单例的Bean
       allowEagerInit：是否允许对”懒加载"的Bean进行实例化,这里主要针对FactoryBean，因为FactoryBean
      */

	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
			throws BeansException;

   
     /*
       利用工厂————获取（指定注解的）所有bean的name名
    */
	String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

	/*
       利用工厂————获取（指定注解的）所有map这种结构
    */
	Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;
       
    /*
       利用工厂————获取（指定注解的以及bean名字）的注解对象，以便于获取注解值
       ，如果没有这个Bean会抛出NoSuchBeanDefinitionException
        如果指定Bean上不存在这个注解，会从其父类上查找
    */
	@Nullable
	<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
			throws NoSuchBeanDefinitionException;

}

AutowireCapableBeanFactory———为bean创建提供核心方法

public interface AutowireCapableBeanFactory extends BeanFactory {
	
    // 自动注入下的四种模型，如果有疑问请参考之前的文章《自动注入与精确注入》
	int AUTOWIRE_NO = 0;
	int AUTOWIRE_BY_NAME = 1;
	int AUTOWIRE_BY_TYPE = 2;
	int AUTOWIRE_CONSTRUCTOR = 3;
    /*
      （标记符号）
      该属性是一种约定俗成的用法：以类全限定名+.ORIGINAL 作为Bean Name，用于告诉Spring，在初始化的时候，需要返回原始给定实例，而别返回代理对象
     */
	String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";

    
    //-------------------------------------------------------------------------
	// 【1】容器外的bean基本方法
	//-------------------------------------------------------------------------
   /*
      下面这三个方法通常用于创建跟填充Bean(对Bean进行属性注入)，但是请注意，直接采用下面这些方法创建或者装配的Bean
       不被Spring容器所管理
    */
	
	<T> T createBean(Class<T> beanClass) throws BeansException;
    /*
      为一个外部的obejct完成属性注入，解析他里面然后注入一切需要
    */
	void autowireBean(Object existingBean) throws BeansException;
	 /*
      为一个外部的obejct完成属性注入，并指定这个bean名称加入容器
    */
	Object configureBean(Object existingBean, String beanName) throws BeansException;

  


	//-------------------------------------------------------------------------
	// 【2】容器内的bean基本方法
	//-------------------------------------------------------------------------
    // autowireMode依赖检查的级别如下：
    // 1.DEPENDENCY_CHECK_NONE = 0，代表不进行依赖检查
	// 2.DEPENDENCY_CHECK_SIMPLE = 2，代表对基本数据类的字段做检查。如果一个int类型的字段没有被赋值，那么会抛出异常
	// 3.DEPENDENCY_CHECK_ALL = 3，对引用类型的字段做检查。如果一个Object类型的字段没有被赋值，那么会抛出异常
	/*
        基本方法
    */
   Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
	Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;
	void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
			throws BeansException;
   /*
        生命周期相关方法
    */
	void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;
	Object initializeBean(Object existingBean, String beanName) throws BeansException;
	Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException;
	Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException;
	void destroyBean(Object existingBean);

     
	//-------------------------------------------------------------------------
	// 【3】依赖注入相关方法
	  // 这些方法有点难，以后详细分析
	//-------------------------------------------------------------------------
	/* 
	  返回某个类型的bean实例，返回实例的名字+实例本身
	  依赖描述(field/method/constructor)
	 */
	<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;
    /* 
	   看看依赖描述中是否在容器中存在指定name的bean
	 */
	Object resolveBeanByName(String name, DependencyDescriptor descriptor) throws BeansException;
	


    /*
      @利用工厂————解析依赖（根据依赖描述）
      
       requestingBeanName 委托bean自己的名称
     */
	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;
    /*  
        @利用工厂————解析依赖（最详细）
        autowiredBeanNames 委托bean所需要的所有Bean名称
        typeConverter 用以转换数组和连表的转换器
     */	
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;

}

ConfigurableBeanFactory———为bean创建提供辅助支持

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {
	// 单例及原型的常量
	String SCOPE_SINGLETON = "singleton";
	String SCOPE_PROTOTYPE = "prototype";
	/*
	 【1】 缓存管理
	 */
    // 是否缓存Bean的元数据，默认是开启的
	void setCacheBeanMetadata(boolean cacheBeanMetadata);
	boolean isCacheBeanMetadata();
	/*
	 【2】SPEL表达式解析器管理
	*/
	void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);
	BeanExpressionResolver getBeanExpressionResolver();
	AccessControlContext getAccessControlContext();//访问接口
    /*
      【3】工厂整体
     */  
	void copyConfigurationFrom(ConfigurableBeanFactory otherFactory); // 从另外一个容器中拷贝配置，不包含具体的bean的定义
	/*
     【4】属性编辑与类型转化相关支持
    */
	void setConversionService(@Nullable ConversionService conversionService);
	@Nullable
	ConversionService getConversionService();
	void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);
	void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);
	void copyRegisteredEditorsTo(PropertyEditorRegistry registry);
	void setTypeConverter(TypeConverter typeConverter);
	TypeConverter getTypeConverter();
	void addEmbeddedValueResolver(StringValueResolver valueResolver);// 值解析器，例如可以使用它来处理占位符
	boolean hasEmbeddedValueResolver();
	@Nullable
	String resolveEmbeddedValue(String value);
   /*
    【5】 类加载器管理
    */
	void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;
	void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);// 为Bean设置指定的类加载器
	ClassLoader getBeanClassLoader();// 获取类型加载器，可能返回null,代表系统类加载器不可访问
	void setTempClassLoader(@Nullable ClassLoader tempClassLoader);// 设置临时的类加载器，在进行类加载时期织入时会用到（loadTimeWeaver）
	ClassLoader getTempClassLoader();
  /*
      【6】后置处理器crud
     */
	void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);
	int getBeanPostProcessorCount();

    /*
      【7】作用域crud
     */
	void registerScope(String scopeName, Scope scope); // 注册指定名称的Scope
	String[] getRegisteredScopeNames();// 返回所有的注册的scope的名称
	Scope getRegisteredScope(String scopeName);// 返回指定名称的已注册的scope


   /*
      【8】bean相关的crud
    */
    /*
      元数据管理
     */
	BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;// 获取bean的最新元数据
    /*
      状态管理
     */
	void setCurrentlyInCreation(String beanName, boolean inCreation);// 循环依赖相关，标志一个Bean是否在创建中
	boolean isCurrentlyInCreation(String beanName);
	boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;// 是否是一个FactoryBean
    /*
       别名管理
      */
    void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;// 为Bean注册别名
	void resolveAliases(StringValueResolver valueResolver);// 解析别名

	/*
	  处理bean依赖问题
	  */
	void registerDependentBean(String beanName, String dependentBeanName);//注册一个依赖于指定bean的Bean
	String[] getDependentBeans(String beanName); // 返回所有指定的Bean从属于哪些Bean
	String[] getDependenciesForBean(String beanName);// 返回指定名称的bean的所有依赖
	 /*
       销毁管理
     */
	void destroyBean(String beanName, Object beanInstance);// 销毁Bean
	void destroyScopedBean(String beanName);// 先从域中移除，然后再销毁
	void destroySingletons(); // 销毁所有单例

}

ConfigurableListableBeanFactory————汇总接口

public interface ConfigurableListableBeanFactory
		extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {
	
	void ignoreDependencyType(Class<?> type);// 自动装配的模式下，忽略这个【类型的依赖】
	void ignoreDependencyInterface(Class<?> ifc); //自动装配的模式下，忽略这个【接口类型的依赖】
    /*
     注入容器外的依赖
     这个方法设计的目的主要是为了让容器中的Bean能依赖一个不被容器管理的Bean
     */
	void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);
	/*
	 根据另外一个bean的依赖描述，看看自己是否需要注入到这个依赖中
	 */
	boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
			throws NoSuchBeanDefinitionException;
    // 
    /*
      获取指定的BeanDefinition
     */
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
	Iterator<String> getBeanNamesIterator();    // 获取包含了所有的Bean的名称的迭代器

	/*
	  流程性操作
	 */
	void clearMetadataCache();// 清理元数据的缓存
	void freezeConfiguration();// 冻结所有的Bean配置
	boolean isConfigurationFrozen();// 是否冻结
	void preInstantiateSingletons() throws BeansException;// 实例化当前所有的剩下的单实例
}

ApplicationContext——非web接口概述

ApplicationContext是作为整个SpirngIoc的全局上下文，beanFactory相当于是处理bean的核心，而ApplicationContext则可能蕴含一些其他数据或者组件，比如说环境对象，国际化配置以及解析注解和XML的一些组件，那么这一系列最终交给beanFactory的时候也需要流程，这些流程也在ApplicationContext去定义
ApplicationContext整体可以分为两个体系，一个就是web体系，另外一个就是非web体系

ApplicationContext接口的方法都是只读的，不能对当前的容器做任何改变。
而ConfigurableApplicationContext接口在ApplicationContext的基础上增加了很多进行配置的方法，比如添加事件监听器，添加后置处理器等等。

ConfigurableApplicationContext

public interface ConfigurableApplicationContext extends ApplicationContext, Lifecycle, Closeable {
	// 配置路径的分隔符
	String CONFIG_LOCATION_DELIMITERS = ",; \t\n";
	String CONVERSION_SERVICE_BEAN_NAME = "conversionService";
	String LOAD_TIME_WEAVER_BEAN_NAME = "loadTimeWeaver";
	String ENVIRONMENT_BEAN_NAME = "environment";
	String SYSTEM_PROPERTIES_BEAN_NAME = "systemProperties";
	String SYSTEM_ENVIRONMENT_BEAN_NAME = "systemEnvironment";

	/*
	  环境操作
	 */
	void setId(String id);//设置此应用程序上下文的唯一ID。
	void setParent(@Nullable ApplicationContext parent); //设置父容器，设置后不能再改了
// 返回此上下文内部的Bean工厂，可以用来访问底层工厂的特定功能。通过此工厂可以设置和验证所需的属性、自定义转换服务
	// 备注：父类方法为获得AutowireCapableBeanFactory接口，而此处的ConfigurableListableBeanFactory可配置、可列出Bean的工厂是它的子类
	ConfigurableListableBeanFactory getBeanFactory() throws IllegalStateException;
  
 /*
   组件操作
  */
  	void setEnvironment(ConfigurableEnvironment environment);//设置environment  此处为ConfigurableEnvironment 也是可以配置的应用上下文
  	ConfigurableEnvironment getEnvironment();// 此处修改父类返回值为ConfigurableEnvironment
	void addBeanFactoryPostProcessor(BeanFactoryPostProcessor postProcessor);//添加一个新的BeanFactoryPostProcessor（refresh()的时候会调用的）
	void addApplicationListener(ApplicationListener<?> listener); // 添加一个事件监听器
	void addProtocolResolver(ProtocolResolver resolver);// 注册协议处理器  允许处理额外的资源协议
   /*
   流程操作
  */
	
	//加载或刷新配置的持久表示  最最最重要的一个方法
	//表示可以是xml、可以是注解、可以是外部资源文件等等。。。。
	// 这个方法执行完成后，所有的单例Bean都已经被实例化，Bean工厂肯定也就被创建好了
	void refresh() throws BeansException, IllegalStateException;
	void registerShutdownHook();//JVM运行时注册一个关闭挂钩，在关闭JVM时关闭此上下文，除非此时已经关闭
	void close();//关闭此应用程序上下文，释放实现可能持有的所有资源和锁  包括一些销毁、释放资源操作
	
    //标识上下文是否激活 refresh()后就会激活
	boolean isActive();
 

AbstractRefreshableApplicationContext

public abstract class AbstractRefreshableApplicationContext extends AbstractApplicationContext {
	
	private Boolean allowBeanDefinitionOverriding;// 碰到重复的Bean时，是否允许覆盖原先的BeanDefinition
	private Boolean allowCircularReferences;// 是否允许循环引用
	private DefaultListableBeanFactory beanFactory;// 默认持有一个DefaultListableBeanFactory

	/*
	  非重点
	 */
	private final Object beanFactoryMonitor = new Object();// 对内部工厂进行操作时所采用的锁
	public AbstractRefreshableApplicationContext() {
	}

	public AbstractRefreshableApplicationContext(@Nullable ApplicationContext parent) {
		super(parent);
	}

	public void setAllowBeanDefinitionOverriding(boolean allowBeanDefinitionOverriding) {
		this.allowBeanDefinitionOverriding = allowBeanDefinitionOverriding;
	}

	public void setAllowCircularReferences(boolean allowCircularReferences) {
		this.allowCircularReferences = allowCircularReferences;
	}
	
    // 
    // 
   /*
	 核心：创建了工厂以及，定义了加载bean的流程
	 刷新Bean工厂，如果当前上下文中已经存在一个容器的话，会先销毁容器中的所有Bean，然后关闭Bean工厂
	 之后在重新创建一个DefaultListableBeanFactory
	 */
	@Override
	protected final void refreshBeanFactory() throws BeansException {
		if (hasBeanFactory()) {
			destroyBeans();
			closeBeanFactory();
		}
		try {
			DefaultListableBeanFactory beanFactory = createBeanFactory();
			beanFactory.setSerializationId(getId());
			customizeBeanFactory(beanFactory);
			loadBeanDefinitions(beanFactory);
			synchronized (this.beanFactoryMonitor) {
				this.beanFactory = beanFactory;
			}
		}
		catch (IOException ex) {
			throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);
		}
	}
	/*
	  一些工厂本身或者状态的CRUD
	 */
	protected void cancelRefresh(BeansException ex) {
		synchronized (this.beanFactoryMonitor) {
			if (this.beanFactory != null) {
				this.beanFactory.setSerializationId(null);
			}
		}
		super.cancelRefresh(ex);
	}
	protected final void closeBeanFactory() {
		synchronized (this.beanFactoryMonitor) {
			if (this.beanFactory != null) {
				this.beanFactory.setSerializationId(null);
				this.beanFactory = null;
			}
		}
	}
	protected final boolean hasBeanFactory() {
		synchronized (this.beanFactoryMonitor) {
			return (this.beanFactory != null);
		}
	}
	public final ConfigurableListableBeanFactory getBeanFactory() {
		synchronized (this.beanFactoryMonitor) {
			if (this.beanFactory == null) {
				throw new IllegalStateException("BeanFactory not initialized or already closed - " +
						"call 'refresh' before accessing beans via the ApplicationContext");
			}
			return this.beanFactory;
		}
	}

	protected DefaultListableBeanFactory createBeanFactory() {
		return new DefaultListableBeanFactory(getInternalParentBeanFactory());
	}

	.......
	/*
	  加载BeanDefinition的方法，可能XML也可能是注解，还有配置文件也不一样
	 */
	protected abstract void loadBeanDefinitions(DefaultListableBeanFactory beanFactory)
			throws BeansException, IOException;

}

WebApplicationContext

public interface WebApplicationContext extends ApplicationContext {
	String ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE = WebApplicationContext.class.getName() + ".ROOT";
	String SCOPE_REQUEST = "request";
	String SCOPE_SESSION = "session";
	String SCOPE_APPLICATION = "application";
	String SERVLET_CONTEXT_BEAN_NAME = "servletContext";
	String CONTEXT_PARAMETERS_BEAN_NAME = "contextParameters";
	String CONTEXT_ATTRIBUTES_BEAN_NAME = "contextAttributes";
	@Nullable
	ServletContext getServletContext();

}

public interface ConfigurableWebApplicationContext extends WebApplicationContext, ConfigurableApplicationContext {
	String APPLICATION_CONTEXT_ID_PREFIX = WebApplicationContext.class.getName() + ":";
	String SERVLET_CONFIG_BEAN_NAME = "servletConfig";
	void setServletContext(@Nullable ServletContext servletContext);
	void setServletConfig(@Nullable ServletConfig servletConfig);

	ServletConfig getServletConfig();
    // 设置及获取当前上下文的命名空间，命名空间用于区分不同的web容器的配置，在查找配置时会根据命名空间查找
    // 默认不进行命名空间配置，配置会在/WEB-INF/applicationContext.xml下查找
    // 如果配置了，会在/WEB-INF+"namespace"+/applicationContext.xml下查找
    // 根容器没有Namespace
	void setNamespace(@Nullable String namespace);
	@Nullable
	String getNamespace();

	void setConfigLocation(String configLocation);
	void setConfigLocations(String... configLocations);

	@Nullable
	String[] getConfigLocations();

}

总结

扩展beanFactory一般都在ConfigurableBeanFactory做一些手脚，applicationContext也是在ConfigurableApplicationContext做一些手脚，因为流程一般是固定的，没什么可以边的，但是内部组件我们是需要自己去定制；