Spring容器架构
Spring容器家族
BeanFactory：Spring容器的基石，顶级容器接口
在Spring官网文档中，称org.springframework.context.ApplicationContext这个接口就代表了Spring的容器，在解释ApplicationContext之前，必须要先介绍Spring容器的基石，BeanFactory接口。ApplicationContext就是继承了BeanFactory接口的一种高级容器接口。而BeanFactory是简略容器的代表，是Spring容器家族的基石，所有的容器都必须实现这个接口。
BeanFactory接口的源码，次要规定了一些容器的基本功能，其中有7个获取Bean或者Bean提供者的办法，5个判断型的办法，2个获取类型的办法，1个获取别名的办法。通过这些办法，能够看出BeanFactory是一个典型的工厂模式的工厂接口。
public interface BeanFactory { /** * 对FactoryBean的转移定义，提供获取FactoryBean实例的办法。 * 如果定义bean时是通过工厂模式配置Bean的，那么通过bean的名字检索FactoryBean时 * 失去的会是FactoryBean生产进去的实例，如果想得到工厂自身，须要进行本义 */ String FACTORY_BEAN_PREFIX = "&"; /** * 不同的获取Bean的办法 */ Object getBean(String var1) throws BeansException; <T> T getBean(String var1, Class<T> var2) throws BeansException; Object getBean(String var1, Object... var2) throws BeansException; <T> T getBean(Class<T> var1) throws BeansException; <T> T getBean(Class<T> var1, Object... var2) throws BeansException; /** * 获取Bean的提供者（工厂） */ <T> ObjectProvider<T> getBeanProvider(Class<T> var1); <T> ObjectProvider<T> getBeanProvider(ResolvableType var1); // 检索是否蕴含指定名字的bean boolean containsBean(String name); // 判断指定名字的bean是否为单例 boolean isSingleton(String name) throws NoSuchBeanDefinitionException; // 判断指定名字的bean是否为原型 boolean isPrototype(String name) throws NoSuchBeanDefinitionException; /** * 指定名字的Bean是否匹配指定的类型 */ boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException; boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException; /** * 获取指定名字的Bean的类型 */ @Nullable Class<?> getType(String name) throws NoSuchBeanDefinitionException; @Nullable Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException; // 获取指定名字Bean的所有别名 String[] getAliases(String name);}顶级二级接口：ListableBeanFactory和HierarchicalBeanFactroy。
ListableBeanFactory：该接口领有列出工厂中所有Bean的能力。ListableBeanFactory次要对外提供了批量获取Bean和BeanDefinition的办法，拓展类了BeanFactory的性能，是一个十分重要的接口。
public interface ListableBeanFactory extends BeanFactory { // 检索是否蕴含给定beanName的BeanDefinition boolean containsBeanDefinition(String beanName); // 获取工厂中BeanDefinition的数量 int getBeanDefinitionCount(); // 获取工厂中所有BeanDefinition的Names String[] getBeanDefinitionNames(); // 获取指定类型的beanNames String[] getBeanNamesForType(ResolvableType type); String[] getBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit); String[] getBeanNamesForType(@Nullable Class<?> type); String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit); // 依据指定的类型来获取所有Bean <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; // 依据指定的间接获取beanNames String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType); // 获取所有指定注解标注的Bean实例，Autowired就是应用的该接口 Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException; // 查找指定Bean中含有的注解类型 @Nullable <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws NoSuchBeanDefinitionException;}HierarchicalBeanFactroy接口：顾名思义，这是一个分层的工厂。该接口实现了Bean工厂的分层。提供了一个十分重要的性能——工厂分层，通过工厂分层，SpringIoC容器能够建设父子层级关联的容器体系，子容器能够拜访父容器中的Bean，而父容器不能拜访子容器中的Bean。在容器内，Bean的id必须是惟一的，但子容器能够领有一个和父容器id雷同的Bean。父子容器层级体系加强了Spring容器架构的扩展性和灵活性，因为第三方能够通过编程的形式，为一个曾经存在的容器增加一个或多个非凡用处的子容器，以提供一些额定的性能，Spring应用父子容器实现了很多性能，比方在Spring MVC中，展示层Bean位于一个子容器中，而业务层和长久层的Bean位于父容器中。这样，展示层Bean就能够援用业务层和长久层的Bean，而业务层和长久层的Bean则看不到展示层的Bean。
public interface HierarchicalBeanFactory extends BeanFactory { /** * 返回父级工厂 */ @Nullable BeanFactory getParentBeanFactory(); /** * 检索本地工厂是否蕴含指定名字的Bean */ boolean containsLocalBean(String name);}
简单配置的Bean工厂：ConfigurableBeanFactory接口
ConfigurableBeanFactory接口是一个继承了HierarchicalBeanFactroy的子接口，同时该接口还继承了SingletonBeanRegistry接口，SingletonBeanRegistry是一个用来注册单例类的接口，提供了批准拜访单例Bean的性能，ConfigurableBeanFactory接口次要扩大了一些简单的对单例Bean的配置与操作，尽管这个接口并没有被ApplicationContext高级容器体系所继承，然而个别的容器实现类都会继承或实现这个接口，目标是应用一种对立的形式对外裸露治理单例Bean的形式。SingletonBeanRegistry接口的办法如下图：
public interface SingletonBeanRegistry { /** * 单例的注册，如果脱离生命周期独自调用该办法，就是单纯的注册而不执行 * 诸如生命周期回调等相干 * 通常，是容器在基于 BeanDefinition 创立 singleton 时调用该办法的 */ void registerSingleton(String beanName, Object singletonObject); /** * 获取以及实例化实现的 singleton * 1）手动 registerSingleton 注册的 * 2）容器基于 BeanDefinition 实例化实现后注册的 */ @Nullable Object getSingleton(String beanName); /** * 查看指定 singleton 是否存在 * 该办法 + ListableBeanFactory#containsBeanDefinition：能够查看以后容器中是否能够 * 获取到指定 name 的 bean，无论它是否实例化实现 * BeanFactory#containsBean 在上一步根底上，还能够查找父级容器 */ boolean containsSingleton(String beanName); // 上述 singleton 名称数组 String[] getSingletonNames(); // 上述 singleton 个数 int getSingletonCount(); // 单例锁对象 Object getSingletonMutex();}ConfigurableBeanFactory接口的办法：
public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry { //单例 String SCOPE_SINGLETON = "singleton"; //原型 String SCOPE_PROTOTYPE = "prototype"; //设置父类的BeanFactory,能够在HierarchicalBeanFactory中看到父类的BeanFactory的设置 void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException; //设置类加载器 void setBeanClassLoader(ClassLoader beanClassLoader); //获取类加载器 ClassLoader getBeanClassLoader(); //设置长期加载器 void setTempClassLoader(ClassLoader tempClassLoader); //获取长期加载器 ClassLoader getTempClassLoader(); //设置是否缓存源，false，从新从类加载器加载 void setCacheBeanMetadata(boolean cacheBeanMetadata); //是否缓存了definitions boolean isCacheBeanMetadata(); //bean的表达式解析 void setBeanExpressionResolver(BeanExpressionResolver resolver); //获取bean的表达式解析 BeanExpressionResolver getBeanExpressionResolver(); //设置一个转换服务 void setConversionService(ConversionService conversionService); //获取一个转换服务 ConversionService getConversionService(); //设置属性注册员 void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar); //注册属性编辑器 void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass); //简单属性编辑器 void copyRegisteredEditorsTo(PropertyEditorRegistry registry); //设置类型转换器 void setTypeConverter(TypeConverter typeConverter); //获取类型转换器 TypeConverter getTypeConverter(); // 减少一个嵌入式的StringValueResolve void addEmbeddedValueResolver(StringValueResolver valueResolver); //确定定是否有一个嵌入式的value resolver曾经在这个bean factory中注册了,并且能够通过resolveEmbeddedValue函数来利用. String resolveEmbeddedValue(String value); //减少一个BeanPostProcessor的处理器 前后 void addBeanPostProcessor(BeanPostProcessor beanPostProcessor); //获取BeanPostProcessor的数量 int getBeanPostProcessorCount(); //注册bean的范畴 void registerScope(String scopeName, Scope scope); //获取bean的范畴 String[] getRegisteredScopeNames(); //获取注册的范畴 Scope getRegisteredScope(String scopeName); //返回本工厂的一个平安拜访上下文 AccessControlContext getAccessControlContext(); //复制其余工程的属性配置 void copyConfigurationFrom(ConfigurableBeanFactory otherFactory); //给指定的bean注册别名 void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException; //依据StringValueResolver来移除bean void resolveAliases(StringValueResolver valueResolver); //返回合并后的Beandefinition BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; //判断bean是否是FactoryBean boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException; //设置一个是否正在创立的bean void setCurrentlyInCreation(String beanName, boolean inCreation); //判断bean是否正在创立 boolean isCurrentlyInCreation(String beanName); //为bean注册一个依赖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); //销毁指定的 void destroyScopedBean(String beanName); //销毁单例对象 void destroySingletons(); }
主动装配工厂：AutowireCapableBeanFactory接口
间接继承自BeanFactory接口，次要作用是将主动拆卸的能力对外裸露进去，能够通过实现此接口实现主动拆卸能力，然而失常状况下不应该应用该接口。此接口次要针对框架之外，没有向Spring托管的Bean的利用。public interface AutowireCapableBeanFactory extends BeanFactory { /** * Constant that indicates no externally defined autowiring. Note that * BeanFactoryAware etc and annotation-driven injection will still be applied. * @see #createBean * @see #autowire * @see #autowireBeanProperties */ //表明没有内部定义主动拆卸的bean int AUTOWIRE_NO = 0; //依据名称主动拆卸bean（实用于Bean所有属性的setter） int AUTOWIRE_BY_NAME = 1; //依据类型主动拆卸bean（实用于Bean所有属性的setter） int AUTOWIRE_BY_TYPE = 2; //依据结构器主动拆卸bean（构造函数） int AUTOWIRE_CONSTRUCTOR = 3; //通过class的外部来主动拆卸bean //曾经被启用 @Deprecated int AUTOWIRE_AUTODETECT = 4; //------------------------------------------------------------------------- // Typical methods for creating and populating external bean instances //------------------------------------------------------------------------- //依据给定的class创立bean <T> T createBean(Class<T> beanClass) throws BeansException; //通过调用给定Bean的after-instantiation及post-processing接口，对bean进行配置。 void autowireBean(Object existingBean) throws BeansException; // 配置参数中指定的bean，包含主动拆卸其域，对其利用如setBeanName性能的回调函数。 Object configureBean(Object existingBean, String beanName) throws BeansException; //解析出在Factory中与指定Bean有指定依赖关系的Bean Object resolveDependency(DependencyDescriptor descriptor, String beanName) throws BeansException; // 创立一个指定class的实例，通过参数能够指定其主动拆卸模式（by-name or by-type）. Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException; //通过指定的主动拆卸策略来初始化一个Bean。 Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException; // 通过指定的主动拆卸形式来对给定的Bean进行主动拆卸 void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck) throws BeansException; //将参数中指定了那么的Bean，注入给定实例当中 void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException; //初始化参数中指定的Bean，调用任何其注册的回调函数如setBeanName、setBeanFactory等。 Object initializeBean(Object existingBean, String beanName) throws BeansException; //调用参数中指定Bean的postProcessBeforeInitialization办法 Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException; // 调用参数中指定Bean的postProcessAfterInitialization办法 Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException; //销毁参数中指定的Bean void destroyBean(Object existingBean); //解析指定Bean在Factory中的依赖关系 Object resolveDependency(DependencyDescriptor descriptor, String beanName, Set<String> autowiredBeanNames, TypeConverter typeConverter) throws BeansException; }- Bean工厂接口的集大成者：ConfigurableListableBeanFactory 接口
继承了ListableBeanFactory和可配置bean工厂ConfigurableBeanFactory接口的子接口，同时它还继承了AutowireCapableBeanFactory接口，并且本身还扩大了一些性能 可配置bean工厂
ConfigurableBeanFactory接口，有两个父接口，一个为HierarchicalBeanFactory，一个为SingletonBeanRegistryConfigurableBeanFactory接口源码ConfigurableBeanFactory接口次要提供了，bean作用域，类加载器，长期类加载器，Spring EL解决器，转换服务 ConversionService，属性编辑器注册器，嵌入值解决器，bean后处理的配置操作，同时提供了，是否缓存bean的元数据，设置bean的创立状态，判断bean是否为工厂bean，拷贝bean工厂的配置，获取bean的定义，设置bean的别名，解决基于bean的name的依赖，获取bean的依赖bean信息和获取依赖于bean的bean的name操作，还有销毁给定作用域的bean。须要留神的是，设置bean的创立状态操作属于容器的外部操作，获取作用域时，不包含单例和原型作用域。此接口不可能在利用中间接调用，要配合{@link org.springframework.beans.factory.BeanFactory} 或@link org.springframework.beans.factory.ListableBeanFactory}应用。此接口的扩大接口，运行框架外部应用，用于拜访bean工厂的配置办法。
package org.springframework.beans.factory.config;import java.beans.PropertyEditor;import java.security.AccessControlContext;import org.springframework.beans.PropertyEditorRegistrar;import org.springframework.beans.PropertyEditorRegistry;import org.springframework.beans.TypeConverter;import org.springframework.beans.factory.BeanDefinitionStoreException;import org.springframework.beans.factory.BeanFactory;import org.springframework.beans.factory.HierarchicalBeanFactory;import org.springframework.beans.factory.NoSuchBeanDefinitionException;import org.springframework.core.convert.ConversionService;import org.springframework.util.StringValueResolver;/** *ConfigurableBeanFactory是一个大多数bean工厂都会实现的接口。为配置bean工厂和工厂接口中客户端操作， *提供了便当。 * 配置bean工厂不认为者能够在利用代码中，间接应用：应配合{@link org.springframework.beans.factory.BeanFactory} * 或@link org.springframework.beans.factory.ListableBeanFactory}应用。 * 此接口的扩大接口，运行框架外部应用，用于拜访bean工厂的配置办法。 * * @author Juergen Hoeller * @since 03.11.2003 * @see org.springframework.beans.factory.BeanFactory * @see org.springframework.beans.factory.ListableBeanFactory * @see ConfigurableListableBeanFactory */public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry { /** * 规范的单例作用域模式标识。个别的作用域能够通过{@code registerScope}办法注册。 * @see #registerScope */ String SCOPE_SINGLETON = "singleton"; /** * 规范的原型作用域模式标识。个别的作用域能够通过{@code registerScope}办法注册。 * @see #registerScope */ String SCOPE_PROTOTYPE = "prototype"; /** * 设置bean工厂的父bean工厂。须要留神的是，如果父类bean工厂在工厂初始化的时候，如果不可能， * 应该在结构内部进行设置，这时父类不能扭转。 * @param parentBeanFactory the parent BeanFactory * @throws IllegalStateException if this factory is already associated with * a parent BeanFactory * @see #getParentBeanFactory() */ void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException; /** * 设置工厂加载bean类的类加载器。默认为以后线程上下文的类加载器。 * 须要留神的是，如果类的定义还有对应的bean类型解决器，类加载器只能利用于bean的定义。 * 从spring2.0开始，一旦工厂解决bean的定义，仅仅领有bean类型名字的bean定义能力被解决。 * @param beanClassLoader the class loader to use, * or {@code null} to suggest the default class loader */ void setBeanClassLoader(ClassLoader beanClassLoader); /** * 返回以后bean工厂的类加载器。 */ ClassLoader getBeanClassLoader(); /** * 设置工厂的长期类加载器，个别用于类型匹配的目标。默认为无，简略地应用规范的bean类型加载器。 * 如果处于加载织入工夫（load-time weaving），为确保理论的bean类型尽可能的懒加载， * 一个长期的类加载器通常须要指定。一旦在bean工厂启动实现阶段后，长期类加载器将会被移除。 * @since 2.5 */ void setTempClassLoader(ClassLoader tempClassLoader); /** * 返回长期类加载器 * if any. * @since 2.5 */ ClassLoader getTempClassLoader(); /** *设置是否缓存bean的元数据，比方bean的定义，bean类型解决器。默认是缓存。 * 敞开缓存bean元数据，将会开启一些非凡bean定义对象的热刷新。如果敞开缓存， * 任何bean实例创立时，将会从新为新创建的类查问bean类加载器。 */ void setCacheBeanMetadata(boolean cacheBeanMetadata); /** * 返回以后是否缓存bean的元数据。 */ boolean isCacheBeanMetadata(); /** * 设置bean定义中的表达式值的解析器。BeanExpressionResolver * 默认状况下，bean工厂中，是不反对表达式的。利用上下文将会设置一个规范的表达式策略 * 解析器，以对立的Spring EL 兼容模式，反对"#{...}"表达式。 * @since 3.0 */ void setBeanExpressionResolver(BeanExpressionResolver resolver); /** * 获取bean定义中的表达式值的解析器 * @since 3.0 */ BeanExpressionResolver getBeanExpressionResolver(); /** * 设置用于转换bean的属性的转换服务ConversionService。能够作为java bean的属性 * 编辑器PropertyEditors的一种代替。 * @since 3.0 */ void setConversionService(ConversionService conversionService); /** * 获取类型转换服务 * @since 3.0 */ ConversionService getConversionService(); /** * 增加一个属性编辑注册器利用到所有bean的创立过程。 * 属性编辑注册器创立一个属性编辑器实例，并注册到给定的注册器中，并尝试刷新每个bean的创立。 * 留神须要防止与定制编辑器之间的同步，因而个别状况下，最好应用addPropertyEditorRegistrar办法， * 代替{@link #registerCustomEditor}办法。 * @param registrar the PropertyEditorRegistrar to register */ void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar); /** * 注册给定的定制属性编辑器到给定类型的所有属性。在工厂配置的过程中调用。 * 留神此办法注册一个共享的定制编辑器实例，能够线程平安地拜访编辑器实例。 * 最好应用addPropertyEditorRegistrar办法， 代替{@link #registerCustomEditor}办法。 * 以防止定制编辑器的同步。 * @param requiredType type of the property * @param propertyEditorClass the {@link PropertyEditor} class to register */ void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass); /** * 初始化曾经注册到bean工厂的属性编辑注册器与定制编辑器的关系。 * @param registry the PropertyEditorRegistry to initialize */ void copyRegisteredEditorsTo(PropertyEditorRegistry registry); /** * 谁知bean工厂用于bean属性值或结构参数值转换的类型转化器。 * 此办法将会重写默认属性编辑器机制，因而使任何定制编辑器或编辑注册器不相干。 * @see #addPropertyEditorRegistrar * @see #registerCustomEditor * @since 2.5 */ void setTypeConverter(TypeConverter typeConverter); /** * 获取bean工厂的类型转换器。有类型转化器是非线程平安的，每次调用，返回的可能是一个新的实例。 * 如果默认的属性编辑器机制激活，通过返回的类型转换器，能够理解到所有注册的属性编辑器。 * @since 2.5 */ TypeConverter getTypeConverter(); /** * Add a String resolver for embedded values such as annotation attributes. * @param valueResolver the String resolver to apply to embedded values * @since 3.0 */ void addEmbeddedValueResolver(StringValueResolver valueResolver); /** * 判断是否注册嵌入值解决器到bean工厂，能够用于{@link #resolveEmbeddedValue(String)}办法。 * @since 4.3 */ boolean hasEmbeddedValueResolver(); /** * 解决给定的嵌入值，比方注解属性 * @param value the value to resolve * @return the resolved value (may be the original value as-is) * @since 3.0 */ String resolveEmbeddedValue(String value); /** * 增加一个bean后处理器，将会用于bean工厂创立的bean。在工厂配置的工厂，将会调用。 * 须要留神的是，bean后处理器解决的程序与注册的程序无关；任何实现{@link org.springframework.core.Ordered} * 接口的bean后处理器的排序语义将会被疏忽。在程序中注册一个bean后处理器，将会主动探测上下文中的 * bean后处理器。 * @param beanPostProcessor the post-processor to register */ void addBeanPostProcessor(BeanPostProcessor beanPostProcessor); /** * 获取以后注册的bean后处理器数量。时 */ int getBeanPostProcessorCount(); /** * 依赖于给定作用的实现，注册给定的作用域， * @param scopeName the scope identifier * @param scope the backing Scope implementation */ void registerScope(String scopeName, Scope scope); /** * 返回以后注册的作用与的name集。 * 此办法将会返回显示地注册的作用域。 * 单例和原型模式作用域不会裸露。 * @return the array of scope names, or an empty array if none * @see #registerScope */ String[] getRegisteredScopeNames(); /** * 依据给定作用域的name，返回相应的实现。此办法将会返回显示地注册的作用域。 * 单例和原型模式作用域不会裸露。 * @param scopeName the name of the scope * @return the registered Scope implementation, or {@code null} if none * @see #registerScope */ Scope getRegisteredScope(String scopeName); /** * 返回以后工厂相干的平安访问控制上下文java.security.AccessControlContext。 * @return the applicable AccessControlContext (never {@code null}) * @since 3.0 */ AccessControlContext getAccessControlContext(); /** * 从给定的工厂，拷贝所有相干的配置。 * 应包含所有规范的配置，bean后处理器，作用域，工厂外部设置。 * 不包含任何理论bean定义的元数据，比方bean定义对象，bean的别名。 * @param otherFactory the other BeanFactory to copy from */ void copyConfigurationFrom(ConfigurableBeanFactory otherFactory); /** * 创立给定bean name的别名。这个办法反对bean的name，在XML配置中，属于非法，xml只反对ids别名。 * 在工厂配置，常常配置调用，然而也能够应用运行时注册别名。因而，一个工厂的实现， * 应该同步别名拜访。 * @param beanName the canonical name of the target bean * @param alias the alias to be registered for the bean * @throws BeanDefinitionStoreException if the alias is already in use * 如果别名曾经存在，则抛出BeanDefinitionStoreException。 */ void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException; /** * 在解决所有指标name的别名和注册到工厂的别名，应用给定的StringValueResolver。 * <p>The value resolver may for example resolve placeholders * in target bean names and even in alias names. * 值解决的例子，比方解决给定bean的名称甚至别名中的占位符。 * @param valueResolver the StringValueResolver to apply * @since 2.5 */ void resolveAliases(StringValueResolver valueResolver); /** * 返回给定bean的名称对应的合并bean定义，如果须要应用它的父工厂合并一个孩子的bean定义。 * 思考先人bean工厂中的bean定义。 * @param beanName the name of the bean to retrieve the merged definition for * @return a (potentially merged) BeanDefinition for the given bean * @throws NoSuchBeanDefinitionException if there is no bean definition with the given name * @since 2.5 */ BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; /** * 查看给定name的bean是否在工厂中。 * @param name the name of the bean to check * @return whether the bean is a FactoryBean * ({@code false} means the bean exists but is not a FactoryBean) * @throws NoSuchBeanDefinitionException if there is no bean with the given name * @since 2.5 */ boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException; /** * 显示地管制指定bean的创立状态，仅仅容器外部应用。 * @param beanName the name of the bean * @param inCreation whether the bean is currently in creation * @since 3.1 */ void setCurrentlyInCreation(String beanName, boolean inCreation); /** * 判断以后bean是否创立。 * @param beanName the name of the bean * @return whether the bean is currently in creation * @since 2.5 */ boolean isCurrentlyInCreation(String beanName); /** * 注册一个依赖bean到给定的bean，在给定bean销毁前销毁依赖的bean。 * @param beanName the name of the bean * @param dependentBeanName the name of the dependent bean * @since 2.5 */ void registerDependentBean(String beanName, String dependentBeanName); /** * 返回依赖于给定bean的所有bean的name。 * @param beanName the name of the bean * @return the array of dependent bean names, or an empty array if none * @since 2.5 */ String[] getDependentBeans(String beanName); /** * 返回给定bean的所有依赖bean的name。 * @param beanName the name of the bean * @return the array of names of beans which the bean depends on, * or an empty array if none * @since 2.5 */ String[] getDependenciesForBean(String beanName); /** * 依据bean的定义，销毁给定bean的实例，通常为一个原型bean实例。 * 在析构的过程中，任何异样应该被捕获，同时log，而不是传给办法的调用者。 * @param beanName the name of the bean definition * @param beanInstance the bean instance to destroy */ void destroyBean(String beanName, Object beanInstance); /** * 销毁以后指标作用的指定作用域bean。 * 在析构的过程中，任何异样应该被捕获，同时log，而不是传给办法的调用者。 * @param beanName the name of the scoped bean */ void destroyScopedBean(String beanName); /** * 销毁所有工厂中的单例bean，包含外部bean，比方曾经被注册为disposable的bean。 * 在工厂敞开的时候，将会被调用。 * 在析构的过程中，任何异样应该被捕获，同时log，而不是传给办法的调用者。 */ void destroySingletons();}SingletonBeanRegistry接口源码
package org.springframework.beans.factory.config;/** *SingletonBeanRegistry接口为共享bean实例的注册器。能够被{@link org.springframework.beans.factory.BeanFactory}， *实现，以对立的形式裸露单例管理器。 *ConfigurableBeanFactory接口拓展了此接口 * @author Juergen Hoeller * @since 2.0 * @see ConfigurableBeanFactory * @see org.springframework.beans.factory.support.DefaultSingletonBeanRegistry * @see org.springframework.beans.factory.support.AbstractBeanFactory */public interface SingletonBeanRegistry { /** * 注册给定存在的单例对象到bean注册器的给定bean的name下。 * 给定的实例，应该齐全初始化；注册器不会执行任何初始化回调（在非凡状况下，不会调用 * InitializingBean的 {@code afterPropertiesSet} 办法。 * 给定的实例不会接口任何析构回调（如DisposableBean的{@code destroy}办法）。 * 当一个齐全运行的bean工厂的外部，如果bean应该承受初始化和析构回调，应该注册一个bean定义， * 而不是曾经存在的实例。 * 在注册配置的过程中，会被调用，然而也能够用在单例运行时注册。因而注册器应该实现单例拜访的同步； * 如果反对单例的bean工厂懒加载初始化，不得不实现同步。 * @param beanName the name of the bean * @param singletonObject the existing singleton object * @see org.springframework.beans.factory.InitializingBean#afterPropertiesSet * @see org.springframework.beans.factory.DisposableBean#destroy * @see org.springframework.beans.factory.support.BeanDefinitionRegistry#registerBeanDefinition */ void registerSingleton(String beanName, Object singletonObject); /** * 返回给定bean的名称下的注册单例对象。仅仅查看曾经初始化的单例对象，而不会返回还没有初始化 * 的单例bean定义。 * 此办法的次要目标为拜访手动注册(see {@link #registerSingleton})的单例bean。 * 亦能够用于以bean定义模式的已创立的单例bean定义。 * 须要留神的是:此办法不能辨认工厂bean的前缀或别名。在获取单例实例前，必须解决bean的name先。 * @param beanName the name of the bean to look for * @return the registered singleton object, or {@code null} if none found * @see ConfigurableListableBeanFactory#getBeanDefinition */ Object getSingleton(String beanName); /** * 查看以后注册器是否包含给定name的单例实例。仅仅查看曾经初始化的单例对象，而不会返回还没有初始化 * 的单例bean定义。 * 此办法的次要目标为拜访手动注册(see {@link #registerSingleton})的单例bean。 * 亦能够用于查看是否存在以bean定义模式的已创立的单例bean定义。 * 查看bean工厂是否蕴含给定name的bean定义，能够应用ListableBeanFactory的{@code containsBeanDefinition} * 办法。应用{@code containsBeanDefinition}和{@code containsSingleton}办法，能够判断bean工厂是否一个 * 本地的bean实例。个别应用bean工厂的 {@code containsBean}办法，查看bean工厂是否晓得给定name对应的bean（无论 * 是手动注册的单例bean，还是通过bean定义创立的bean），也能够用于查看先人工厂 * 须要留神的是:此办法不能辨认工厂bean的前缀或别名。在检查单例实例状态前，必须解决bean的name先 * @param beanName the name of the bean to look for * @return if this bean factory contains a singleton instance with the given name * @see #registerSingleton * @see org.springframework.beans.factory.ListableBeanFactory#containsBeanDefinition * @see org.springframework.beans.factory.BeanFactory#containsBean */ boolean containsSingleton(String beanName); /** * 返回注册到注册器的单例bean的name。仅仅查看曾经初始化的单例对象，而不会返回还没有初始化 * 的单例bean定义。 * 此办法的次要目标为拜访手动注册(see {@link #registerSingleton})的单例bean。 * 亦能够用于查看是否存在以bean定义模式的已创立的单例bean定义。 * @return the list of names as a String array (never {@code null}) * @see #registerSingleton * @see org.springframework.beans.factory.support.BeanDefinitionRegistry#getBeanDefinitionNames * @see org.springframework.beans.factory.ListableBeanFactory#getBeanDefinitionNames */ String[] getSingletonNames(); /** * 返回注册到注册器的单例bean数量。仅仅查看曾经初始化的单例对象，而不会返回还没有初始化 * 的单例bean定义。 * 此办法的次要目标为拜访手动注册(see {@link #registerSingleton})的单例bean。 * 亦能够用于查看是否存在以bean定义模式的已创立的单例bean定义。 * @return the number of singleton beans * @see #registerSingleton * @see org.springframework.beans.factory.support.BeanDefinitionRegistry#getBeanDefinitionCount * @see org.springframework.beans.factory.ListableBeanFactory#getBeanDefinitionCount */ int getSingletonCount(); /** * 返回注册器应用的单例互质锁。 * @return the mutex object (never {@code null}) * @since 4.2 */ Object getSingletonMutex();}
- HierarchicalBeanFactroy接口：顾名思义，这是一个分层的工厂。该接口实现了Bean工厂的分层。提供了一个十分重要的性能——工厂分层，通过工厂分层，SpringIoC容器能够建设父子层级关联的容器体系，子容器能够拜访父容器中的Bean，而父容器不能拜访子容器中的Bean。在容器内，Bean的id必须是惟一的，但子容器能够领有一个和父容器id雷同的Bean。父子容器层级体系加强了Spring容器架构的扩展性和灵活性，因为第三方能够通过编程的形式，为一个曾经存在的容器增加一个或多个非凡用处的子容器，以提供一些额定的性能，Spring应用父子容器实现了很多性能，比方在Spring MVC中，展示层Bean位于一个子容器中，而业务层和长久层的Bean位于父容器中。这样，展示层Bean就能够援用业务层和长久层的Bean，而业务层和长久层的Bean则看不到展示层的Bean。
- ConfigurableListableBeanFactory接口次要提供了，注册给定主动注入值的依赖类型，决定给定name的对应bean，是否能够作为其余bean中申明匹配的主动依赖注入类型的候选，此操作查看先人工厂。获取给定name的bean的定义，疏忽给定类型或接口的依赖主动注入，获取工厂中的bean的name集操作，同时提供了革除不被思考的bean的元数据缓存， 解冻bean工厂的bean的定义，判断bean工厂的bean定义是否解冻，以及确保所有非懒加载单例bean被初始化，包含工厂bean相干操作。须要留神的是，bean工厂解冻后，注册的bean定义不能在批改，及进一步的后处理；如果确保所有非懒加载单例bean被初始化失败，记得调用{@link #destroySingletons()}办法，革除曾经初始化的单例bean。
/** * ConfigurableListableBeanFactory是大多数listable bean工厂实现的配置接口，为剖析批改bean的定义 * 或单例bean预初始化提供了便当。 * 此接口为bean工厂的子接口，不意味着能够在失常的利用代码中应用，在典型的利用中，应用{@link org.springframework.beans.factory.BeanFactory} * 或者{@link org.springframework.beans.factory.ListableBeanFactory}。当须要拜访bean工厂配置办法时， * 此接口只容许框架外部应用。 * @author Juergen Hoeller * @since 03.11.2003 * @see org.springframework.context.support.AbstractApplicationContext#getBeanFactory() */public interface ConfigurableListableBeanFactory extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory { /** * 疏忽给定的依赖类型的主动注入，比方String。默认为无。 * @param type the dependency type to ignore */ void ignoreDependencyType(Class<?> type); /** * 疏忽给定的依赖接口的主动注入。 * 利用上下文留神解决依赖的其余办法，比方通过BeanFactoryAware的BeanFactory， * 通过ApplicationContextAware的ApplicationContext。 * 默认，仅仅BeanFactoryAware接口被疏忽。如果想要更多的类型被疏忽，调用此办法即可。 * @param ifc the dependency interface to ignore * @see org.springframework.beans.factory.BeanFactoryAware * @see org.springframework.context.ApplicationContextAware */ void ignoreDependencyInterface(Class<?> ifc); /** * 注册一个与主动注入值相干的非凡依赖类型。这个办法次要用于，工厂、上下文的援用的主动注入，然而工厂和 * 上下文的实例bean，并不工厂中：比方利用上下文的依赖，能够解决利用上下文实例中的bean。 * 须要留神的是：在一个空白的bean工厂中，没有这种默认的类型注册，设置没有bean工厂接口字节。 * @param dependencyType * 须要注册的依赖类型。典型地应用，比方一个bean工厂接口，只有给定的主动注入依赖是bean工厂的拓展即可， * 比方ListableBeanFactory。 * @param autowiredValue * 相干的主动注入的值。兴许是一个对象工厂{@link org.springframework.beans.factory.ObjectFactory}的实现， * 运行懒加载形式解决理论的目标值。 */ void registerResolvableDependency(Class<?> dependencyType, Object autowiredValue); /** * 决定给定name的对应bean，是否能够作为其余bean中申明匹配的主动依赖注入类型的候选。此办法查看先人工厂。 * @param beanName the name of the bean to check * 须要查看的bean的name * @param descriptor the descriptor of the dependency to resolve * 依赖形容 * @return whether the bean should be considered as autowire candidate * 返回bean是否为主动注入的候选 * @throws NoSuchBeanDefinitionException if there is no bean with the given name */ boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor) throws NoSuchBeanDefinitionException; /** * 返回给定bean的bean定义，运行拜访bean的属性值和结构参数（能够在bean工厂后处理器解决的过程中批改）。 * 返回的bean定义不应该为bean定义的copy，而是原始注册到bean工厂的bean的定义。意味着，如果须要， * 应该投射到一个更准确的类型。 * 此办法不思考先人工厂。即只能拜访以后工厂中bean定义。 * @param beanName the name of the bean * @return the registered BeanDefinition * @throws NoSuchBeanDefinitionException if there is no bean with the given name * defined in this factory */ BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException; /** * 返回以后工厂中的所有bean的name的对立视图集。 * 包含bean的定义，及主动注册的单例bean实例，首先bean定义与bean的name统一，而后依据类型、注解检索bean的name。 * @return the composite iterator for the bean names view * @since 4.1.2 * @see #containsBeanDefinition * @see #registerSingleton * @see #getBeanNamesForType * @see #getBeanNamesForAnnotation */ Iterator<String> getBeanNamesIterator(); /** * 革除整合bean定义的缓存，移除还没有缓存所有元数据的bean。 * 典型的触发场景，在原始的bean定义批改之后，比方利用 {@link BeanFactoryPostProcessor}。须要留神的是， * 在以后工夫点，bean定义曾经存在的元数据将会被保留。 * @since 4.2 * @see #getBeanDefinition * @see #getMergedBeanDefinition */ void clearMetadataCache(); /** * 解冻所有bean定义，告诉上下文，注册的bean定义不能在批改，及进一步的后处理。 * <p>This allows the factory to aggressively cache bean definition metadata. */ void freezeConfiguration(); /** * 返回bean工厂中的bean定义是否曾经解冻。即不应该批改和进一步的后处理。 * @return {@code true} if the factory's configuration is considered frozen * 如果解冻，则返回true。 */ boolean isConfigurationFrozen(); /** * 确保所有非懒加载单例bean被初始化，包含工厂bean{@link org.springframework.beans.factory.FactoryBean FactoryBeans}。 * Typically invoked at the end of factory setup, if desired. * 如果须要，在bean工厂设置后，调用此办法。 * @throws BeansException * 如果任何一个单例bean不可能创立，将抛出BeansException。 * 须要留神的是：操作有可能遗留一些曾经初始化的bean，能够调用{@link #destroySingletons()}齐全分明。 * @see #destroySingletons() */ void preInstantiateSingletons() throws BeansException;}Bean工厂的形象事实基类：AbstractBeanFactory抽象类
AbstractBeanFactory这个抽象类是Spring容器体系中最重要的一个抽象类，该抽象类实现了BeanFactory重要的二级接口ConfigurableBeanFactory，实现了其中的绝大多数根本办法，实现了Bean工厂的许多重要性能，如对BeanDefinition、原型、单例Bean的各种操作。AbstractBeanFactory源码本人看,逻辑办法太多了，只列几个具体→
AbstractBeanFactory源码字段
// 父类容器private BeanFactory parentBeanFactory;// 类加载器private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();// 长期加载器private ClassLoader tempClassLoader;// bean的元数据缓存private boolean cacheBeanMetadata = true;// bean的表达式解析器private BeanExpressionResolver beanExpressionResolver;// 类型转换器private ConversionService conversionService;// 属性编辑器private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet<>(4);// 类的属性编辑器private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors = new HashMap<>(4);// 类型转换器private TypeConverter typeConverter;// 为嵌入的值(如正文属性)增加字符串解析器private final List<StringValueResolver> embeddedValueResolvers = new CopyOnWriteArrayList<>();// 后置处理器private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();// InstantiationAwareBeanPostProcessors是否已注册private volatile boolean hasInstantiationAwareBeanPostProcessors;// DestructionAwareBeanPostProcessors是否已注册private volatile boolean hasDestructionAwareBeanPostProcessors;// 作用域private final Map<String, Scope> scopes = new LinkedHashMap<>(8);// 提供平安作用域private SecurityContextProvider securityContextProvider;// 合并后的BeanDefinitionprivate final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);// bean实例是否已创立private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));// 本地缓存，正在创立的多例bean。这边用本地线程，是因为其余线程创立bean与以后线程不抵触private final ThreadLocal<Object> prototypesCurrentlyInCreation = new NamedThreadLocal<>("Prototype beans currently in creation");办法
构造函数，父类容器可作为参数传入public AbstractBeanFactory() {}**doGetBean参数：**name：bean的名称requiredType： 返回的类型args： 传递的结构参数typeCheckOnly： 查看类型public AbstractBeanFactory(@Nullable BeanFactory parentBeanFactory) { this.parentBeanFactory = parentBeanFactory;}protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType, @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException { //获取beanName，这边有三种模式，一个是原始的beanName，一个是加了&的，一个是别名 final String beanName = transformedBeanName(name); Object bean; // Eagerly check singleton cache for manually registered singletons. // 是否曾经创立了 Object sharedInstance = getSingleton(beanName); //曾经创立了，且没有结构参数，进入这个办法，如果有结构参数，往else走，也就是说不从获取bean，而间接创立bean if (sharedInstance != null && args == null) { if (logger.isTraceEnabled()) { if (isSingletonCurrentlyInCreation(beanName)) { logger.trace("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference"); } else { logger.trace("Returning cached instance of singleton bean '" + beanName + "'"); } } // 如果是一般bean，间接返回，是FactoryBean，返回他的getObject bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); } else { // Fail if we're already creating this bean instance: // We're assumably within a circular reference. // 没创立过bean或者是多例的状况或者有参数的状况 // 创立过Prototype的bean，会循环援用，抛出异样，单例才尝试解决循环依赖的问题 if (isPrototypeCurrentlyInCreation(beanName)) { throw new BeanCurrentlyInCreationException(beanName); } // Check if bean definition exists in this factory. BeanFactory parentBeanFactory = getParentBeanFactory(); // 父容器存在，本地没有以后beanName，从父容器取 if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // Not found -> check parent. // 解决后，如果是加&，就补上& String nameToLookup = originalBeanName(name); if (parentBeanFactory instanceof AbstractBeanFactory) { return ((AbstractBeanFactory) parentBeanFactory).doGetBean( nameToLookup, requiredType, args, typeCheckOnly); } else if (args != null) { // Delegation to parent with explicit args. return (T) parentBeanFactory.getBean(nameToLookup, args); } else if (requiredType != null) { // No args -> delegate to standard getBean method. return parentBeanFactory.getBean(nameToLookup, requiredType); } else { return (T) parentBeanFactory.getBean(nameToLookup); } } if (!typeCheckOnly) { // typeCheckOnly为false，将beanName放入alreadyCreated中 markBeanAsCreated(beanName); } try { // 获取BeanDefinition final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // 抽象类查看 checkMergedBeanDefinition(mbd, beanName, args); // Guarantee initialization of beans that the current bean depends on. // 如果有依赖的状况，先初始化依赖的bean String[] dependsOn = mbd.getDependsOn(); if (dependsOn != null) { for (String dep : dependsOn) { // 查看是否循环依赖，a依赖b，b依赖a。包含传递的依赖，比方a依赖b，b依赖c，c依赖a if (isDependent(beanName, dep)) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'"); } // 注册依赖关系 registerDependentBean(dep, beanName); try { // 初始化依赖的bean getBean(dep); } catch (NoSuchBeanDefinitionException ex) { throw new BeanCreationException(mbd.getResourceDescription(), beanName, "'" + beanName + "' depends on missing bean '" + dep + "'", ex); } } } // Create bean instance. // 如果是单例 if (mbd.isSingleton()) { sharedInstance = getSingleton(beanName, () -> { try { // 创立bean return createBean(beanName, mbd, args); } catch (BeansException ex) { // Explicitly remove instance from singleton cache: It might have been put there // eagerly by the creation process, to allow for circular reference resolution. // Also remove any beans that received a temporary reference to the bean. destroySingleton(beanName); throw ex; } }); // 如果是一般bean，间接返回，是FactoryBean，返回他的getObject bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd); } else if (mbd.isPrototype()) { // It's a prototype -> create a new instance. Object prototypeInstance = null; try { // 退出prototypesCurrentlyInCreation，阐明正在创立 beforePrototypeCreation(beanName); //创立bean prototypeInstance = createBean(beanName, mbd, args); } finally { // 移除prototypesCurrentlyInCreation，阐明曾经创立完结 afterPrototypeCreation(beanName); } // 如果是一般bean，间接返回，是FactoryBean，返回他的getObject bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd); } else { String scopeName = mbd.getScope(); final Scope scope = this.scopes.get(scopeName); if (scope == null) { throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'"); } try { Object scopedInstance = scope.get(beanName, () -> { beforePrototypeCreation(beanName); try { return createBean(beanName, mbd, args); } finally { afterPrototypeCreation(beanName); } }); bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd); } catch (IllegalStateException ex) { throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider " + "defining a scoped proxy for this bean if you intend to refer to it from a singleton", ex); } } } catch (BeansException ex) { cleanupAfterBeanCreationFailure(beanName); throw ex; } } // Check if required type matches the type of the actual bean instance. if (requiredType != null && !requiredType.isInstance(bean)) { try { T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType); if (convertedBean == null) { throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } return convertedBean; } catch (TypeMismatchException ex) { if (logger.isTraceEnabled()) { logger.trace("Failed to convert bean '" + name + "' to required type '" + ClassUtils.getQualifiedName(requiredType) + "'", ex); } throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass()); } } return (T) bean;}containsBean是否曾经创立bean或者定义好了bean，包含以后容器以及父容器public boolean containsBean(String name) { String beanName = transformedBeanName(name); // 已创立单例bean或者包含bean的定义 if (containsSingleton(beanName) || containsBeanDefinition(beanName)) { // 如果不是&结尾的，间接返回 // 如果是&结尾的，判断是否是FactoryBean，没有找到从父类找 return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name)); } // Not found -> check parent. // 以后容器没找到，去父类找 BeanFactory parentBeanFactory = getParentBeanFactory(); return (parentBeanFactory != null && parentBeanFactory.containsBean(originalBeanName(name)));}isSingleton指定beanName是否是单例，包含一般的bean和FactoryBean，包含以后容器以及父容器public boolean isSingleton(String name) throws NoSuchBeanDefinitionException { String beanName = transformedBeanName(name); // 如果曾经实例化了 Object beanInstance = getSingleton(beanName, false); if (beanInstance != null) { if (beanInstance instanceof FactoryBean) { // 是FactoryBean类型，name要&结尾或者FactoryBean中isSingleton办法返回为true return (BeanFactoryUtils.isFactoryDereference(name) || ((FactoryBean<?>) beanInstance).isSingleton()); } else { // 如果不是FactoryBean，name就不能是&结尾 return !BeanFactoryUtils.isFactoryDereference(name); } } // No singleton instance found -> check bean definition. // 如果以后容器还没实例化，去父类找 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // No bean definition found in this factory -> delegate to parent. return parentBeanFactory.isSingleton(originalBeanName(name)); } // 父类也没有，依据定义来判断是否是单例 // 获取合并后的BeanDefinition RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // In case of FactoryBean, return singleton status of created object if not a dereference. if (mbd.isSingleton()) { // 如果定义了是单例，判断是否是FactoryBean，如果是FactoryBean，name就要是&结尾 if (isFactoryBean(beanName, mbd)) { if (BeanFactoryUtils.isFactoryDereference(name)) { return true; } // 如果是单例，然而name不是&结尾，就从新获取factoryBean，再判断是否是单例 FactoryBean<?> factoryBean = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName); return factoryBean.isSingleton(); } else { // 如果不是FactoryBean，就不能是&结尾 return !BeanFactoryUtils.isFactoryDereference(name); } } else { return false; }}isPrototype指定beanName是否是多例，包含一般的bean和FactoryBean，包含以后容器以及父容器public boolean isPrototype(String name) throws NoSuchBeanDefinitionException { String beanName = transformedBeanName(name); // 有父容器，且没有beanName的定义，从父容器中查找 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // No bean definition found in this factory -> delegate to parent. return parentBeanFactory.isPrototype(originalBeanName(name)); } // 没有再从以后容器查找 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); if (mbd.isPrototype()) { // In case of FactoryBean, return singleton status of created object if not a dereference. // 如果是一般的bean返回true，如果是&结尾的，且是FactoryBean，返回true return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(beanName, mbd)); } // Singleton or scoped - not a prototype. // However, FactoryBean may still produce a prototype object... // 如果不是Prototype，且是&结尾，&结尾就是FactoryBean，FactoryBean是单例的，所以是返回false if (BeanFactoryUtils.isFactoryDereference(name)) { return false; } // 如果是FactoryBean，判断是否有Singleton或者Prototype if (isFactoryBean(beanName, mbd)) { final FactoryBean<?> fb = (FactoryBean<?>) getBean(FACTORY_BEAN_PREFIX + beanName); if (System.getSecurityManager() != null) { return AccessController.doPrivileged((PrivilegedAction<Boolean>) () -> ((fb instanceof SmartFactoryBean && ((SmartFactoryBean<?>) fb).isPrototype()) || !fb.isSingleton()), getAccessControlContext()); } else { return ((fb instanceof SmartFactoryBean && ((SmartFactoryBean<?>) fb).isPrototype()) || !fb.isSingleton()); } } else { return false; }}isTypeMatch指定的beanName是否与类型匹配public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException { String beanName = transformedBeanName(name); // Check manually registered singletons. // 获取单例 Object beanInstance = getSingleton(beanName, false); // 不为空并且不是NullBean类型 if (beanInstance != null && beanInstance.getClass() != NullBean.class) { if (beanInstance instanceof FactoryBean) { if (!BeanFactoryUtils.isFactoryDereference(name)) { // 不是&结尾，获取FactoryBean的getObjectType类型，再来比拟 Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance); return (type != null && typeToMatch.isAssignableFrom(type)); } else { // name是&结尾，直接判断类型FactoryBean return typeToMatch.isInstance(beanInstance); } } // 一般bean，且没有&结尾 else if (!BeanFactoryUtils.isFactoryDereference(name)) { if (typeToMatch.isInstance(beanInstance)) { // Direct match for exposed instance? return true; } // 泛型且有beanName的定义 else if (typeToMatch.hasGenerics() && containsBeanDefinition(beanName)) { // Generics potentially only match on the target class, not on the proxy... // 合并定义 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); Class<?> targetType = mbd.getTargetType(); if (targetType != null && targetType != ClassUtils.getUserClass(beanInstance)) { // Check raw class match as well, making sure it's exposed on the proxy. Class<?> classToMatch = typeToMatch.resolve(); if (classToMatch != null && !classToMatch.isInstance(beanInstance)) { return false; } if (typeToMatch.isAssignableFrom(targetType)) { return true; } } ResolvableType resolvableType = mbd.targetType; if (resolvableType == null) { resolvableType = mbd.factoryMethodReturnType; } return (resolvableType != null && typeToMatch.isAssignableFrom(resolvableType)); } } return false; } // 曾经创立了，然而没有bean的定义，阐明是空的注册进来 else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) { // null instance registered return false; } // No singleton instance found -> check bean definition. // 从父类找 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // No bean definition found in this factory -> delegate to parent. return parentBeanFactory.isTypeMatch(originalBeanName(name), typeToMatch); } // Retrieve corresponding bean definition. RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); Class<?> classToMatch = typeToMatch.resolve(); if (classToMatch == null) { classToMatch = FactoryBean.class; } Class<?>[] typesToMatch = (FactoryBean.class == classToMatch ? new Class<?>[] {classToMatch} : new Class<?>[] {FactoryBean.class, classToMatch}); // Check decorated bean definition, if any: We assume it'll be easier // to determine the decorated bean's type than the proxy's type. BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) { RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd); Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd, typesToMatch); if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) { return typeToMatch.isAssignableFrom(targetClass); } } Class<?> beanType = predictBeanType(beanName, mbd, typesToMatch); if (beanType == null) { return false; } // Check bean class whether we're dealing with a FactoryBean. if (FactoryBean.class.isAssignableFrom(beanType)) { if (!BeanFactoryUtils.isFactoryDereference(name) && beanInstance == null) { // If it's a FactoryBean, we want to look at what it creates, not the factory class. beanType = getTypeForFactoryBean(beanName, mbd); if (beanType == null) { return false; } } } else if (BeanFactoryUtils.isFactoryDereference(name)) { // Special case: A SmartInstantiationAwareBeanPostProcessor returned a non-FactoryBean // type but we nevertheless are being asked to dereference a FactoryBean... // Let's check the original bean class and proceed with it if it is a FactoryBean. beanType = predictBeanType(beanName, mbd, FactoryBean.class); if (beanType == null || !FactoryBean.class.isAssignableFrom(beanType)) { return false; } } ResolvableType resolvableType = mbd.targetType; if (resolvableType == null) { resolvableType = mbd.factoryMethodReturnType; } if (resolvableType != null && resolvableType.resolve() == beanType) { return typeToMatch.isAssignableFrom(resolvableType); } return typeToMatch.isAssignableFrom(beanType);}public boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException { // 类型转换后调用下面的办法 return isTypeMatch(name, ResolvableType.forRawClass(typeToMatch));}getType获取指定beanName的类型public Class<?> getType(String name) throws NoSuchBeanDefinitionException { String beanName = transformedBeanName(name); // Check manually registered singletons. Object beanInstance = getSingleton(beanName, false); // 曾经实例化并且不是NullBean if (beanInstance != null && beanInstance.getClass() != NullBean.class) { // 如果是FactoryBean，且没有&，阐明是取FactoryBean的getObjectType类型 if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) { return getTypeForFactoryBean((FactoryBean<?>) beanInstance); } else { // 间接返回类型 return beanInstance.getClass(); } } // No singleton instance found -> check bean definition. // 没有实例过，从父容器看看有没有实例化 BeanFactory parentBeanFactory = getParentBeanFactory(); if (parentBeanFactory != null && !containsBeanDefinition(beanName)) { // No bean definition found in this factory -> delegate to parent. return parentBeanFactory.getType(originalBeanName(name)); } // 都没有实例化，从定义里查找 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // Check decorated bean definition, if any: We assume it'll be easier // to determine the decorated bean's type than the proxy's type. BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); if (dbd != null && !BeanFactoryUtils.isFactoryDereference(name)) { RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd); Class<?> targetClass = predictBeanType(dbd.getBeanName(), tbd); if (targetClass != null && !FactoryBean.class.isAssignableFrom(targetClass)) { return targetClass; } } Class<?> beanClass = predictBeanType(beanName, mbd); // Check bean class whether we're dealing with a FactoryBean. if (beanClass != null && FactoryBean.class.isAssignableFrom(beanClass)) { if (!BeanFactoryUtils.isFactoryDereference(name)) { // If it's a FactoryBean, we want to look at what it creates, not at the factory class. return getTypeForFactoryBean(beanName, mbd); } else { return beanClass; } } else { return (!BeanFactoryUtils.isFactoryDereference(name) ? beanClass : null); }}getBeanClassLoader类加载器、长期加载器// 设置类加载器public void setBeanClassLoader(@Nullable ClassLoader beanClassLoader) { this.beanClassLoader = (beanClassLoader != null ? beanClassLoader : ClassUtils.getDefaultClassLoader());}// 获取类加载器public ClassLoader getBeanClassLoader() { return this.beanClassLoader;}// 设置长期加载器，如果波及到加载时编织，通常只指定一个长期类装入器，以确保理论的bean类被尽可能提早地装入public void setTempClassLoader(@Nullable ClassLoader tempClassLoader) { this.tempClassLoader = tempClassLoader;}// 获取长期加载器public ClassLoader getTempClassLoader() { return this.tempClassLoader;}isCacheBeanMetadatabean的元数据缓存，默认为true。如果为false，每次创立bean都要从类加载器获取信息// 设置是否缓存public void setCacheBeanMetadata(boolean cacheBeanMetadata) { this.cacheBeanMetadata = cacheBeanMetadata;}// 获取是否缓存public boolean isCacheBeanMetadata() { return this.cacheBeanMetadata;}getTypeConverter类型转换器// 设置类型转换器public void setTypeConverter(TypeConverter typeConverter) { this.typeConverter = typeConverter;}// 获取自定义的类型转换器，这边间接取类型转换器protected TypeConverter getCustomTypeConverter() { return this.typeConverter;}// 获取类型转换器public TypeConverter getTypeConverter() { TypeConverter customConverter = getCustomTypeConverter(); if (customConverter != null) { return customConverter; } else { // Build default TypeConverter, registering custom editors. // 没有设值就初始化一个SimpleTypeConverter SimpleTypeConverter typeConverter = new SimpleTypeConverter(); typeConverter.setConversionService(getConversionService()); registerCustomEditors(typeConverter); return typeConverter; }}后置器// 减少后置处理器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 // 如果是上面两个类型，标记位就设置true if (beanPostProcessor instanceof InstantiationAwareBeanPostProcessor) { this.hasInstantiationAwareBeanPostProcessors = true; } if (beanPostProcessor instanceof DestructionAwareBeanPostProcessor) { this.hasDestructionAwareBeanPostProcessors = true; } // Add to end of list this.beanPostProcessors.add(beanPostProcessor);}// 获取后置处理器的个数public int getBeanPostProcessorCount() { return this.beanPostProcessors.size();}// 获取后置处理器public List<BeanPostProcessor> getBeanPostProcessors() { return this.beanPostProcessors;}AbstractBeanFactory的继承关系
- AbstractBeanFactory其实还继承了另外一个抽象类——
FactoryBeanRegistrySupport - AbstractBeanFactory另一个继承关系
这个继承体系是Spring的AliasRegistry体系，也就是别名注册接口体系
AbstractBeanFactory既然继承了这个体系，阐明容器自身也是个别名注册器、FactroyBean注册器和单例Bean注册器，也会保护别名注册表、反对FactroyBean的注册和单例Bean注册的各种操作（注册、获取、移除、销毁等）。
- AbstractBeanFactory其实还继承了另外一个抽象类——
第一个能够独立运行的容器实现类——DefaultListableBeanFactory类
DefaultListableBeanFactory类是Spring提供的默认简略容器实现类，也是从BeanFactory接口一路继承与实现下来的第一个能够独立运行的容器类，该类间接继承了AbstractBeanFactory抽象类，同时还实现了Spring集大成的容器接口——ConfigurableListableBeanFactory 接口，这保障了DefaultListableBeanFactory残缺实现了简略容器中对Bean的各种操作性能。
而且咱们还在源码中发现，DefaultListableBeanFactory同时还实现了BeanDefinitionRegistry接口，对于这个接口的具体介绍见：向容器中注册BeanDefinition——BeanDefinitionRegistry。正是因为实现了此接口，所以DefaultListableBeanFactory也是一个BeanDefinition注册器，领有了注册BeanDefinition的作用。能够从源码中发现，DefaultListableBeanFactory中保护了一个beanDefinitionMap，即BeanDefinition注册表。源码解析
字段
// JSR-330 反对private static Class<?> javaxInjectProviderClass;// DefaultListableBeanFactory援用的缓存private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories = new ConcurrentHashMap<>(8);// 序列号idprivate String serializationId;// 是否容许用雷同的名称从新注册不同的定义private boolean allowBeanDefinitionOverriding = true;// 是否容许懒加载private boolean allowEagerClassLoading = true;// 依赖排序程序private Comparator<Object> dependencyComparator;// 解析器，用于查看bean定义是否为主动拆卸候选private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();// 依赖类型和主动注入值的映射private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);// BeanDefinition和beanName的映射private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);// 依赖类型和单例、非单例bean的映射private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);// 依赖类型和单例bean的映射private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);// bean定义名称列表，按注册顺序排列。private volatile List<String> beanDefinitionNames = new ArrayList<>(256);// 手动注册的单例，按注册顺序排列private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);// 固定配置的缓存的bean定义名数组private volatile String[] frozenBeanDefinitionNames;// 是否能够缓存所有bean的bean定义元数据private volatile boolean configurationFrozen = false;办法
//构造方法public DefaultListableBeanFactory() { super();}public DefaultListableBeanFactory(@Nullable BeanFactory parentBeanFactory) { super(parentBeanFactory);}//序列号设置，同时设置到serializableFactories中public void setSerializationId(@Nullable String serializationId) { if (serializationId != null) { serializableFactories.put(serializationId, new WeakReference<>(this)); } else if (this.serializationId != null) { serializableFactories.remove(this.serializationId); } this.serializationId = serializationId;}public String getSerializationId() { return this.serializationId;}//get、set略过//复制其余配置信息public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory) { super.copyConfigurationFrom(otherFactory); if (otherFactory instanceof DefaultListableBeanFactory) { DefaultListableBeanFactory otherListableFactory = (DefaultListableBeanFactory) otherFactory; this.allowBeanDefinitionOverriding = otherListableFactory.allowBeanDefinitionOverriding; this.allowEagerClassLoading = otherListableFactory.allowEagerClassLoading; this.dependencyComparator = otherListableFactory.dependencyComparator; // A clone of the AutowireCandidateResolver since it is potentially BeanFactoryAware... setAutowireCandidateResolver(BeanUtils.instantiateClass(getAutowireCandidateResolver().getClass())); // Make resolvable dependencies (e.g. ResourceLoader) available here as well... this.resolvableDependencies.putAll(otherListableFactory.resolvableDependencies); }}//获取beanpublic <T> T getBean(Class<T> requiredType) throws BeansException { // 依据class类型获取bean return getBean(requiredType, (Object[]) null);}public <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException { Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false); if (resolved == null) { throw new NoSuchBeanDefinitionException(requiredType); } return (T) resolved;}//获取bean的提供者public <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType) throws BeansException { return getBeanProvider(ResolvableType.forRawClass(requiredType));}public <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType) { return new BeanObjectProvider<T>() { @Override public T getObject() throws BeansException { T resolved = resolveBean(requiredType, null, false); if (resolved == null) { throw new NoSuchBeanDefinitionException(requiredType); } return resolved; } @Override public T getObject(Object... args) throws BeansException { T resolved = resolveBean(requiredType, args, false); if (resolved == null) { throw new NoSuchBeanDefinitionException(requiredType); } return resolved; } @Override @Nullable public T getIfAvailable() throws BeansException { return resolveBean(requiredType, null, false); } @Override @Nullable public T getIfUnique() throws BeansException { return resolveBean(requiredType, null, true); } @Override public Stream<T> stream() { return Arrays.stream(getBeanNamesForTypedStream(requiredType)) .map(name -> (T) getBean(name)) .filter(bean -> !(bean instanceof NullBean)); } @Override public Stream<T> orderedStream() { String[] beanNames = getBeanNamesForTypedStream(requiredType); Map<String, T> matchingBeans = new LinkedHashMap<>(beanNames.length); for (String beanName : beanNames) { Object beanInstance = getBean(beanName); if (!(beanInstance instanceof NullBean)) { matchingBeans.put(beanName, (T) beanInstance); } } Stream<T> stream = matchingBeans.values().stream(); return stream.sorted(adaptOrderComparator(matchingBeans)); } };}//bean的解析private <T> T resolveBean(ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) { NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull); if (namedBean != null) { return namedBean.getBeanInstance(); } BeanFactory parent = getParentBeanFactory(); // 如果父类是DefaultListableBeanFactory，调用父类的resolveBean办法 if (parent instanceof DefaultListableBeanFactory) { return ((DefaultListableBeanFactory) parent).resolveBean(requiredType, args, nonUniqueAsNull); } else if (parent != null) { // 如果父类不是DefaultListableBeanFactory，且不为空，获取父类的bean的提供者 ObjectProvider<T> parentProvider = parent.getBeanProvider(requiredType); if (args != null) { // 有参结构 return parentProvider.getObject(args); } else { // 无参结构，getIfAvailable：理论存在才返回一个实例，* getIfUnique： 有多个实例时，返回默认的实例（比方primary） return (nonUniqueAsNull ? parentProvider.getIfUnique() : parentProvider.getIfAvailable()); } } return null;}//通过ResolvableType获取bean名称private String[] getBeanNamesForTypedStream(ResolvableType requiredType) { return BeanFactoryUtils.beanNamesForTypeIncludingAncestors(this, requiredType);}//查看此bean工厂是否蕴含具备指定名称的bean定义。public boolean containsBeanDefinition(String beanName) { Assert.notNull(beanName, "Bean name must not be null"); return this.beanDefinitionMap.containsKey(beanName);}//获取bean定义的个数public int getBeanDefinitionCount() { return this.beanDefinitionMap.size();}//不思考此工厂可能参加的任何层次结构，并且疏忽通过bean定义以外的其余形式注册的任何单例beanpublic String[] getBeanDefinitionNames() { String[] frozenNames = this.frozenBeanDefinitionNames; if (frozenNames != null) { return frozenNames.clone(); } else { return StringUtils.toStringArray(this.beanDefinitionNames); }}//依据bean定义或factorybean中getObjectType的值判断，返回与给定类型(包含子类)匹配的bean的名称。public String[] getBeanNamesForType(ResolvableType type) { Class<?> resolved = type.resolve(); if (resolved != null && !type.hasGenerics()) { return getBeanNamesForType(resolved, true, true); } else { return doGetBeanNamesForType(type, true, true); }}public String[] getBeanNamesForType(@Nullable Class<?> type) { return getBeanNamesForType(type, true, true);}@Overridepublic String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) { if (!isConfigurationFrozen() || type == null || !allowEagerInit) { return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit); } Map<Class<?>, String[]> cache = (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType); String[] resolvedBeanNames = cache.get(type); if (resolvedBeanNames != null) { return resolvedBeanNames; } resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true); if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) { cache.put(type, resolvedBeanNames); } return resolvedBeanNames;}//依据bean定义或factorybean中getObjectType的值判断，返回与给定类型(包含子类)匹配的bean的名称。private String[] doGetBeanNamesForType(ResolvableType type, boolean includeNonSingletons, boolean allowEagerInit) { List<String> result = new ArrayList<>(); // Check all bean definitions. // 遍历所有的beanName for (String beanName : this.beanDefinitionNames) { // Only consider bean as eligible if the bean name // is not defined as alias for some other bean. // 没有别名 if (!isAlias(beanName)) { try { // 合并bean的定义 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); // Only check bean definition if it is complete. if (!mbd.isAbstract() && (allowEagerInit || (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) && !requiresEagerInitForType(mbd.getFactoryBeanName()))) { // In case of FactoryBean, match object created by FactoryBean. // 是否是FactoryBean boolean isFactoryBean = isFactoryBean(beanName, mbd); BeanDefinitionHolder dbd = mbd.getDecoratedDefinition(); boolean matchFound = (allowEagerInit || !isFactoryBean || (dbd != null && !mbd.isLazyInit()) || containsSingleton(beanName)) && (includeNonSingletons || (dbd != null ? mbd.isSingleton() : isSingleton(beanName))) && isTypeMatch(beanName, type); if (!matchFound && isFactoryBean) { // In case of FactoryBean, try to match FactoryBean instance itself next. beanName = FACTORY_BEAN_PREFIX + beanName; matchFound = (includeNonSingletons || mbd.isSingleton()) && isTypeMatch(beanName, type); } if (matchFound) { result.add(beanName); } } } catch (CannotLoadBeanClassException ex) { if (allowEagerInit) { throw ex; } // Probably a class name with a placeholder: let's ignore it for type matching purposes. if (logger.isTraceEnabled()) { logger.trace("Ignoring bean class loading failure for bean '" + beanName + "'", ex); } onSuppressedException(ex); } catch (BeanDefinitionStoreException ex) { if (allowEagerInit) { throw ex; } // Probably some metadata with a placeholder: let's ignore it for type matching purposes. if (logger.isTraceEnabled()) { logger.trace("Ignoring unresolvable metadata in bean definition '" + beanName + "'", ex); } onSuppressedException(ex); } } } // Check manually registered singletons too. for (String beanName : this.manualSingletonNames) { try { // In case of FactoryBean, match object created by FactoryBean. if (isFactoryBean(beanName)) { if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) { result.add(beanName); // Match found for this bean: do not match FactoryBean itself anymore. continue; } // In case of FactoryBean, try to match FactoryBean itself next. beanName = FACTORY_BEAN_PREFIX + beanName; } // Match raw bean instance (might be raw FactoryBean). if (isTypeMatch(beanName, type)) { result.add(beanName); } } catch (NoSuchBeanDefinitionException ex) { // Shouldn't happen - probably a result of circular reference resolution... if (logger.isTraceEnabled()) { logger.trace("Failed to check manually registered singleton with name '" + beanName + "'", ex); } } } return StringUtils.toStringArray(result);}//是否马上返回bean以确定类型private boolean requiresEagerInitForType(@Nullable String factoryBeanName) { return (factoryBeanName != null && isFactoryBean(factoryBeanName) && !containsSingleton(factoryBeanName));}//获取bean名称和实例的映射public <T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException { return getBeansOfType(type, true, true);}public <T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit) throws BeansException { // 依据类型获取到bean名称 String[] beanNames = getBeanNamesForType(type, includeNonSingletons, allowEagerInit); Map<String, T> result = new LinkedHashMap<>(beanNames.length); // 遍历所有名称，通过bean名称获取实例，如果不是NullBean退出到result for (String beanName : beanNames) { try { Object beanInstance = getBean(beanName); if (!(beanInstance instanceof NullBean)) { result.put(beanName, (T) beanInstance); } } catch (BeanCreationException ex) { Throwable rootCause = ex.getMostSpecificCause(); if (rootCause instanceof BeanCurrentlyInCreationException) { BeanCreationException bce = (BeanCreationException) rootCause; String exBeanName = bce.getBeanName(); if (exBeanName != null && isCurrentlyInCreation(exBeanName)) { if (logger.isTraceEnabled()) { logger.trace("Ignoring match to currently created bean '" + exBeanName + "': " + ex.getMessage()); } onSuppressedException(ex); // Ignore: indicates a circular reference when autowiring constructors. // We want to find matches other than the currently created bean itself. continue; } } throw ex; } } return result;}//依据注解获取bean的名称public String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType) { List<String> result = new ArrayList<>(); // 遍历所有的bean的，把不是抽象类的，以及有annotationType注解的退出到result for (String beanName : this.beanDefinitionNames) { BeanDefinition beanDefinition = getBeanDefinition(beanName); if (!beanDefinition.isAbstract() && findAnnotationOnBean(beanName, annotationType) != null) { result.add(beanName); } } // 遍历所有的manualSingletonNames，把没有退出到result的以及有annotationType注解的退出到result for (String beanName : this.manualSingletonNames) { if (!result.contains(beanName) && findAnnotationOnBean(beanName, annotationType) != null) { result.add(beanName); } } return StringUtils.toStringArray(result);}//依据注解获取bean的实例public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) { // 依据注解获取bean的名称 String[] beanNames = getBeanNamesForAnnotation(annotationType); Map<String, Object> result = new LinkedHashMap<>(beanNames.length); // 遍历bean的名称，获取bean的实例 for (String beanName : beanNames) { Object beanInstance = getBean(beanName); if (!(beanInstance instanceof NullBean)) { result.put(beanName, beanInstance); } } return result;}//依据beanName获取注解public <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType) throws NoSuchBeanDefinitionException { A ann = null; // 获取class Class<?> beanType = getType(beanName); if (beanType != null) { // class不为空，获取注解 ann = AnnotationUtils.findAnnotation(beanType, annotationType); } // 没获取到注解，且有定义过，从定义里的beanClass获取 if (ann == null && containsBeanDefinition(beanName)) { BeanDefinition bd = getMergedBeanDefinition(beanName); if (bd instanceof AbstractBeanDefinition) { AbstractBeanDefinition abd = (AbstractBeanDefinition) bd; if (abd.hasBeanClass()) { ann = AnnotationUtils.findAnnotation(abd.getBeanClass(), annotationType); } } } return ann;}//注册依赖类型和主动注入值public void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue) { Assert.notNull(dependencyType, "Dependency type must not be null"); if (autowiredValue != null) { if (!(autowiredValue instanceof ObjectFactory || dependencyType.isInstance(autowiredValue))) { throw new IllegalArgumentException("Value [" + autowiredValue + "] does not implement specified dependency type [" + dependencyType.getName() + "]"); } this.resolvableDependencies.put(dependencyType, autowiredValue); }}//指定的bean是否是主动注入的候选public boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor) throws NoSuchBeanDefinitionException { return isAutowireCandidate(beanName, descriptor, getAutowireCandidateResolver());}protected boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor, AutowireCandidateResolver resolver) throws NoSuchBeanDefinitionException { String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName); // 定义过的，从定义里找 if (containsBeanDefinition(beanDefinitionName)) { return isAutowireCandidate(beanName, getMergedLocalBeanDefinition(beanDefinitionName), descriptor, resolver); } // 创立过的单例，从新创立RootBeanDefinition else if (containsSingleton(beanName)) { return isAutowireCandidate(beanName, new RootBeanDefinition(getType(beanName)), descriptor, resolver); } // 都没找到，从父类找 BeanFactory parent = getParentBeanFactory(); if (parent instanceof DefaultListableBeanFactory) { // No bean definition found in this factory -> delegate to parent. return ((DefaultListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor, resolver); } else if (parent instanceof ConfigurableListableBeanFactory) { // If no DefaultListableBeanFactory, can't pass the resolver along. return ((ConfigurableListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor); } else { return true; }}protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd, DependencyDescriptor descriptor, AutowireCandidateResolver resolver) { String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName); // 解析 resolveBeanClass(mbd, beanDefinitionName); if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) { new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd); } // 从别名里找 return resolver.isAutowireCandidate( new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);}//从beanDefinitionMap找bean的定义public BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException { BeanDefinition bd = this.beanDefinitionMap.get(beanName); if (bd == null) { if (logger.isTraceEnabled()) { logger.trace("No bean named '" + beanName + "' found in " + this); } throw new NoSuchBeanDefinitionException(beanName); } return bd;}//获取bean的迭代名称，包含自定的和手动注册的public Iterator<String> getBeanNamesIterator() { CompositeIterator<String> iterator = new CompositeIterator<>(); iterator.add(this.beanDefinitionNames.iterator()); iterator.add(this.manualSingletonNames.iterator()); return iterator;}//清理元数据缓存public void clearMetadataCache() { super.clearMetadataCache(); clearByTypeCache();}//解冻以后的bean的信息public void freezeConfiguration() { this.configurationFrozen = true; this.frozenBeanDefinitionNames = StringUtils.toStringArray(this.beanDefinitionNames);}//配置解冻public boolean isConfigurationFrozen() { return this.configurationFrozen;}//是否曾经解冻了或者是否已创立protected boolean isBeanEligibleForMetadataCaching(String beanName) { return (this.configurationFrozen || super.isBeanEligibleForMetadataCaching(beanName));}//确保实例化了所有非lazy-init单例public void preInstantiateSingletons() throws BeansException { if (logger.isTraceEnabled()) { logger.trace("Pre-instantiating singletons in " + this); } // Iterate over a copy to allow for init methods which in turn register new bean definitions. // While this may not be part of the regular factory bootstrap, it does otherwise work fine. List<String> beanNames = new ArrayList<>(this.beanDefinitionNames); // Trigger initialization of all non-lazy singleton beans... // 遍历beanNames for (String beanName : beanNames) { RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName); // 不是形象的，并且是单例且没有懒加载 if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) { //FactoryBean的状况，加&获取 if (isFactoryBean(beanName)) { Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); if (bean instanceof FactoryBean) { final FactoryBean<?> factory = (FactoryBean<?>) bean; boolean isEagerInit; if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) { isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit, getAccessControlContext()); } else { isEagerInit = (factory instanceof SmartFactoryBean && ((SmartFactoryBean<?>) factory).isEagerInit()); } if (isEagerInit) { getBean(beanName); } } } else { // 不是FactoryBean间接获取 getBean(beanName); } } } // Trigger post-initialization callback for all applicable beans... // 获取单例bean后，如果是SmartInitializingSingleton类型，再调用afterSingletonsInstantiated办法 for (String beanName : beanNames) { Object singletonInstance = getSingleton(beanName); if (singletonInstance instanceof SmartInitializingSingleton) { final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance; if (System.getSecurityManager() != null) { AccessController.doPrivileged((PrivilegedAction<Object>) () -> { smartSingleton.afterSingletonsInstantiated(); return null; }, getAccessControlContext()); } else { smartSingleton.afterSingletonsInstantiated(); } } }}//把beanName和beanDefinition放入beanDefinitionMap中public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition) throws BeanDefinitionStoreException { Assert.hasText(beanName, "Bean name must not be empty"); Assert.notNull(beanDefinition, "BeanDefinition must not be null"); if (beanDefinition instanceof AbstractBeanDefinition) { try { // 注册前的查看，次要查看methodOverrides，methodOverrides和factoryBeanName不能共存 // methodOverrides对应的办法，要存在 ((AbstractBeanDefinition) beanDefinition).validate(); } catch (BeanDefinitionValidationException ex) { throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex); } } // 获取bean的定义 BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName); // 存在的状况 if (existingDefinition != null) { // 不容许笼罩，抛异样 if (!isAllowBeanDefinitionOverriding()) { throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition); } // 比方是ROLE_APPLICATION，给用户应用的，新确实是ROLE_SUPPORT，齐全外部应用，就抛异样 else if (existingDefinition.getRole() < beanDefinition.getRole()) { // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE if (logger.isInfoEnabled()) { logger.info("Overriding user-defined bean definition for bean '" + beanName + "' with a framework-generated bean definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]"); } } // 参考AbstractBeanDefinition的equals办法 else if (!beanDefinition.equals(existingDefinition)) { if (logger.isDebugEnabled()) { logger.debug("Overriding bean definition for bean '" + beanName + "' with a different definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]"); } } else { if (logger.isTraceEnabled()) { logger.trace("Overriding bean definition for bean '" + beanName + "' with an equivalent definition: replacing [" + existingDefinition + "] with [" + beanDefinition + "]"); } } // 注册beanDefinition this.beanDefinitionMap.put(beanName, beanDefinition); } else { // 不存在的状况，有bean创立了 if (hasBeanCreationStarted()) { // Cannot modify startup-time collection elements anymore (for stable iteration) // 加锁，注册beanDefinition，记录beanDefinitionNames，如果有手动注册的记录，则移除 synchronized (this.beanDefinitionMap) { this.beanDefinitionMap.put(beanName, beanDefinition); List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1); updatedDefinitions.addAll(this.beanDefinitionNames); updatedDefinitions.add(beanName); this.beanDefinitionNames = updatedDefinitions; if (this.manualSingletonNames.contains(beanName)) { Set<String> updatedSingletons = new LinkedHashSet<>(this.manualSingletonNames); updatedSingletons.remove(beanName); this.manualSingletonNames = updatedSingletons; } } } else { // Still in startup registration phase // 注册beanDefinition，记录beanDefinitionNames，如果有手动注册的记录，则移除 this.beanDefinitionMap.put(beanName, beanDefinition); this.beanDefinitionNames.add(beanName); this.manualSingletonNames.remove(beanName); } // 有注册过，固定解冻的记录则清空 this.frozenBeanDefinitionNames = null; } // 重置beanName的缓存 if (existingDefinition != null || containsSingleton(beanName)) { resetBeanDefinition(beanName); }}//移除beanpublic void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException { Assert.hasText(beanName, "'beanName' must not be empty"); // 移除 BeanDefinition bd = this.beanDefinitionMap.remove(beanName); // 为空阐明之前不存在 if (bd == null) { if (logger.isTraceEnabled()) { logger.trace("No bean named '" + beanName + "' found in " + this); } throw new NoSuchBeanDefinitionException(beanName); } // 曾经创立bean了，要加锁 if (hasBeanCreationStarted()) { // Cannot modify startup-time collection elements anymore (for stable iteration) synchronized (this.beanDefinitionMap) { List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames); updatedDefinitions.remove(beanName); this.beanDefinitionNames = updatedDefinitions; } } else { // Still in startup registration phase // 还没创立，间接移除 this.beanDefinitionNames.remove(beanName); } this.frozenBeanDefinitionNames = null; resetBeanDefinition(beanName);}//重置bean的定义protected void resetBeanDefinition(String beanName) { // Remove the merged bean definition for the given bean, if already created. // bean定义删除 clearMergedBeanDefinition(beanName); // Remove corresponding bean from singleton cache, if any. Shouldn't usually // be necessary, rather just meant for overriding a context's default beans // (e.g. the default StaticMessageSource in a StaticApplicationContext). // bean销毁 destroySingleton(beanName); // Notify all post-processors that the specified bean definition has been reset. for (BeanPostProcessor processor : getBeanPostProcessors()) { if (processor instanceof MergedBeanDefinitionPostProcessor) { ((MergedBeanDefinitionPostProcessor) processor).resetBeanDefinition(beanName); } } // Reset all bean definitions that have the given bean as parent (recursively). // 子类重置 for (String bdName : this.beanDefinitionNames) { if (!beanName.equals(bdName)) { BeanDefinition bd = this.beanDefinitionMap.get(bdName); if (beanName.equals(bd.getParentName())) { resetBeanDefinition(bdName); } } }}//注册单例，手动注册的单例，保留在manualSingletonNamespublic 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<>(this.manualSingletonNames.size() + 1); updatedSingletons.addAll(this.manualSingletonNames); updatedSingletons.add(beanName); this.manualSingletonNames = updatedSingletons; } } } else { // Still in startup registration phase if (!this.beanDefinitionMap.containsKey(beanName)) { this.manualSingletonNames.add(beanName); } } clearByTypeCache();}//销毁bean，还要移除manualSingletonNames的beanpublic void destroySingleton(String beanName) { super.destroySingleton(beanName); this.manualSingletonNames.remove(beanName); clearByTypeCache();}//销毁所有bean，还要移除manualSingletonNames的所有beanpublic void destroySingletons() { super.destroySingletons(); this.manualSingletonNames.clear(); clearByTypeCache();}//革除依赖类型的映射private void clearByTypeCache() { this.allBeanNamesByType.clear(); this.singletonBeanNamesByType.clear();}//通过类型解析beanpublic <T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException { NamedBeanHolder<T> namedBean = resolveNamedBean(ResolvableType.forRawClass(requiredType), null, false); if (namedBean != null) { return namedBean; } // 为空去父类查找 BeanFactory parent = getParentBeanFactory(); if (parent instanceof AutowireCapableBeanFactory) { return ((AutowireCapableBeanFactory) parent).resolveNamedBean(requiredType); } throw new NoSuchBeanDefinitionException(requiredType);}private <T> NamedBeanHolder<T> resolveNamedBean( ResolvableType requiredType, @Nullable Object[] args, boolean nonUniqueAsNull) throws BeansException { Assert.notNull(requiredType, "Required type must not be null"); // 获取候选bean String[] candidateNames = getBeanNamesForType(requiredType); if (candidateNames.length > 1) { List<String> autowireCandidates = new ArrayList<>(candidateNames.length); for (String beanName : candidateNames) { if (!containsBeanDefinition(beanName) || getBeanDefinition(beanName).isAutowireCandidate()) { autowireCandidates.add(beanName); } } if (!autowireCandidates.isEmpty()) { candidateNames = StringUtils.toStringArray(autowireCandidates); } } // 只有一个候选，就确定是这个了 if (candidateNames.length == 1) { String beanName = candidateNames[0]; return new NamedBeanHolder<>(beanName, (T) getBean(beanName, requiredType.toClass(), args)); } else if (candidateNames.length > 1) { Map<String, Object> candidates = new LinkedHashMap<>(candidateNames.length); for (String beanName : candidateNames) { // 无参，间接获取bean的类型 if (containsSingleton(beanName) && args == null) { Object beanInstance = getBean(beanName); candidates.put(beanName, (beanInstance instanceof NullBean ? null : beanInstance)); } else { // 有参，通过beanName获取类型 candidates.put(beanName, getType(beanName)); } } // 获取次要的一个 String candidateName = determinePrimaryCandidate(candidates, requiredType.toClass()); if (candidateName == null) { // 没获取到，从最高级的获取 candidateName = determineHighestPriorityCandidate(candidates, requiredType.toClass()); } if (candidateName != null) { // 获取到了，创立一个NamedBeanHolder返回 Object beanInstance = candidates.get(candidateName); if (beanInstance == null || beanInstance instanceof Class) { beanInstance = getBean(candidateName, requiredType.toClass(), args); } return new NamedBeanHolder<>(candidateName, (T) beanInstance); } if (!nonUniqueAsNull) { throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet()); } } return null;}//依据工厂中定义的bean解析指定的依赖项public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException { descriptor.initParameterNameDiscovery(getParameterNameDiscoverer()); if (Optional.class == descriptor.getDependencyType()) { return createOptionalDependency(descriptor, requestingBeanName); } else if (ObjectFactory.class == descriptor.getDependencyType() || ObjectProvider.class == descriptor.getDependencyType()) { return new DependencyObjectProvider(descriptor, requestingBeanName); } else if (javaxInjectProviderClass == descriptor.getDependencyType()) { return new Jsr330Factory().createDependencyProvider(descriptor, requestingBeanName); } else { Object result = getAutowireCandidateResolver().getLazyResolutionProxyIfNecessary( descriptor, requestingBeanName); if (result == null) { result = doResolveDependency(descriptor, requestingBeanName, autowiredBeanNames, typeConverter); } return result; }}//依据工厂中定义的bean解析指定的依赖项public Object doResolveDependency(DependencyDescriptor descriptor, @Nullable String beanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException { InjectionPoint previousInjectionPoint = ConstructorResolver.setCurrentInjectionPoint(descriptor); try { // spring第一次创立依赖的时候，会寄存在shortcut，前面就不必再解析了 Object shortcut = descriptor.resolveShortcut(this); if (shortcut != null) { return shortcut; } // 获取注入属性的类型 Class<?> type = descriptor.getDependencyType(); // 解决@Value的值 Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor); if (value != null) { // 解析value if (value instanceof String) { String strVal = resolveEmbeddedValue((String) value); BeanDefinition bd = (beanName != null && containsBean(beanName) ? getMergedBeanDefinition(beanName) : null); value = evaluateBeanDefinitionString(strVal, bd); } TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter()); try { return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor()); } catch (UnsupportedOperationException ex) { // A custom TypeConverter which does not support TypeDescriptor resolution... return (descriptor.getField() != null ? converter.convertIfNecessary(value, type, descriptor.getField()) : converter.convertIfNecessary(value, type, descriptor.getMethodParameter())); } } // 对数组容器的解决， Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter); if (multipleBeans != null) { return multipleBeans; } // 对非数组、容器对象的解决，键值对 Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor); if (matchingBeans.isEmpty()) { // 为空，且required为true，抛异样 if (isRequired(descriptor)) { raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor); } return null; } String autowiredBeanName; Object instanceCandidate; // 有多个的状况，筛选一个 if (matchingBeans.size() > 1) { autowiredBeanName = determineAutowireCandidate(matchingBeans, descriptor); if (autowiredBeanName == null) { if (isRequired(descriptor) || !indicatesMultipleBeans(type)) { return descriptor.resolveNotUnique(descriptor.getResolvableType(), matchingBeans); } else { // In case of an optional Collection/Map, silently ignore a non-unique case: // possibly it was meant to be an empty collection of multiple regular beans // (before 4.3 in particular when we didn't even look for collection beans). return null; } } instanceCandidate = matchingBeans.get(autowiredBeanName); } else { // We have exactly one match. // 只有一个，间接返回 Map.Entry<String, Object> entry = matchingBeans.entrySet().iterator().next(); autowiredBeanName = entry.getKey(); instanceCandidate = entry.getValue(); } if (autowiredBeanNames != null) { autowiredBeanNames.add(autowiredBeanName); } if (instanceCandidate instanceof Class) { instanceCandidate = descriptor.resolveCandidate(autowiredBeanName, type, this); } Object result = instanceCandidate; if (result instanceof NullBean) { if (isRequired(descriptor)) { raiseNoMatchingBeanFound(type, descriptor.getResolvableType(), descriptor); } result = null; } if (!ClassUtils.isAssignableValue(type, result)) { throw new BeanNotOfRequiredTypeException(autowiredBeanName, type, instanceCandidate.getClass()); } return result; } finally { ConstructorResolver.setCurrentInjectionPoint(previousInjectionPoint); }}//解析数组容器private Object resolveMultipleBeans(DependencyDescriptor descriptor, @Nullable String beanName, @Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) { final Class<?> type = descriptor.getDependencyType(); if (descriptor instanceof StreamDependencyDescriptor) { Map<String, Object> matchingBeans = findAutowireCandidates(beanName, type, descriptor); if (autowiredBeanNames != null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } Stream<Object> stream = matchingBeans.keySet().stream() .map(name -> descriptor.resolveCandidate(name, type, this)) .filter(bean -> !(bean instanceof NullBean)); if (((StreamDependencyDescriptor) descriptor).isOrdered()) { stream = stream.sorted(adaptOrderComparator(matchingBeans)); } return stream; } else if (type.isArray()) { // 数组的状况 Class<?> componentType = type.getComponentType(); ResolvableType resolvableType = descriptor.getResolvableType(); Class<?> resolvedArrayType = resolvableType.resolve(type); if (resolvedArrayType != type) { componentType = resolvableType.getComponentType().resolve(); } if (componentType == null) { return null; } Map<String, Object> matchingBeans = findAutowireCandidates(beanName, componentType, new MultiElementDescriptor(descriptor)); if (matchingBeans.isEmpty()) { return null; } if (autowiredBeanNames != null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter()); Object result = converter.convertIfNecessary(matchingBeans.values(), resolvedArrayType); if (result instanceof Object[]) { Comparator<Object> comparator = adaptDependencyComparator(matchingBeans); if (comparator != null) { Arrays.sort((Object[]) result, comparator); } } return result; } else if (Collection.class.isAssignableFrom(type) && type.isInterface()) { // 容器的状况 Class<?> elementType = descriptor.getResolvableType().asCollection().resolveGeneric(); if (elementType == null) { return null; } Map<String, Object> matchingBeans = findAutowireCandidates(beanName, elementType, new MultiElementDescriptor(descriptor)); if (matchingBeans.isEmpty()) { return null; } if (autowiredBeanNames != null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter()); Object result = converter.convertIfNecessary(matchingBeans.values(), type); if (result instanceof List) { Comparator<Object> comparator = adaptDependencyComparator(matchingBeans); if (comparator != null) { ((List<?>) result).sort(comparator); } } return result; } else if (Map.class == type) { // map的状况 ResolvableType mapType = descriptor.getResolvableType().asMap(); Class<?> keyType = mapType.resolveGeneric(0); if (String.class != keyType) { return null; } Class<?> valueType = mapType.resolveGeneric(1); if (valueType == null) { return null; } Map<String, Object> matchingBeans = findAutowireCandidates(beanName, valueType, new MultiElementDescriptor(descriptor)); if (matchingBeans.isEmpty()) { return null; } if (autowiredBeanNames != null) { autowiredBeanNames.addAll(matchingBeans.keySet()); } return matchingBeans; } else { return null; }}//Required是否为trueprivate boolean isRequired(DependencyDescriptor descriptor) { return getAutowireCandidateResolver().isRequired(descriptor);}//注入属性是数组或者容器private boolean indicatesMultipleBeans(Class<?> type) { return (type.isArray() || (type.isInterface() && (Collection.class.isAssignableFrom(type) || Map.class.isAssignableFrom(type))));}//适配依赖比拟器private Comparator<Object> adaptDependencyComparator(Map<String, ?> matchingBeans) { Comparator<Object> comparator = getDependencyComparator(); if (comparator instanceof OrderComparator) { return ((OrderComparator) comparator).withSourceProvider( createFactoryAwareOrderSourceProvider(matchingBeans)); } else { return comparator; }}//比拟器private Comparator<Object> adaptOrderComparator(Map<String, ?> matchingBeans) { Comparator<Object> dependencyComparator = getDependencyComparator(); OrderComparator comparator = (dependencyComparator instanceof OrderComparator ? (OrderComparator) dependencyComparator : OrderComparator.INSTANCE); return comparator.withSourceProvider(createFactoryAwareOrderSourceProvider(matchingBeans));}//创立工厂获取程序提供者private OrderComparator.OrderSourceProvider createFactoryAwareOrderSourceProvider(Map<String, ?> beans) { IdentityHashMap<Object, String> instancesToBeanNames = new IdentityHashMap<>(); beans.forEach((beanName, instance) -> instancesToBeanNames.put(instance, beanName)); return new FactoryAwareOrderSourceProvider(instancesToBeanNames);}//查找Auto候选人protected Map<String, Object> findAutowireCandidates( @Nullable String beanName, Class<?> requiredType, DependencyDescriptor descriptor) { // 获取批评类型的beanName String[] candidateNames = BeanFactoryUtils.beanNamesForTypeIncludingAncestors( this, requiredType, true, descriptor.isEager()); // 寄存后果 Map<String, Object> result = new LinkedHashMap<>(candidateNames.length); // 如果遍历的类型是指定的类型或者子类的话，报错在result for (Map.Entry<Class<?>, Object> classObjectEntry : this.resolvableDependencies.entrySet()) { Class<?> autowiringType = classObjectEntry.getKey(); if (autowiringType.isAssignableFrom(requiredType)) { Object autowiringValue = classObjectEntry.getValue(); autowiringValue = AutowireUtils.resolveAutowiringValue(autowiringValue, requiredType); if (requiredType.isInstance(autowiringValue)) { result.put(ObjectUtils.identityToString(autowiringValue), autowiringValue); break; } } } for (String candidate : candidateNames) { // 如果不是自援用，且合乎注入的条件 if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, descriptor)) { addCandidateEntry(result, candidate, descriptor, requiredType); } } // result为空 if (result.isEmpty()) { // 注入属性是数组和容器类型，对泛型查看 boolean multiple = indicatesMultipleBeans(requiredType); // Consider fallback matches if the first pass failed to find anything... DependencyDescriptor fallbackDescriptor = descriptor.forFallbackMatch(); for (String candidate : candidateNames) { if (!isSelfReference(beanName, candidate) && isAutowireCandidate(candidate, fallbackDescriptor) && (!multiple || getAutowireCandidateResolver().hasQualifier(descriptor))) { addCandidateEntry(result, candidate, descriptor, requiredType); } } // 为空，且不是数组和容器类型，增加自援用 if (result.isEmpty() && !multiple) { // Consider self references as a final pass... // but in the case of a dependency collection, not the very same bean itself. for (String candidate : candidateNames) { if (isSelfReference(beanName, candidate) && (!(descriptor instanceof MultiElementDescriptor) || !beanName.equals(candidate)) && isAutowireCandidate(candidate, fallbackDescriptor)) { addCandidateEntry(result, candidate, descriptor, requiredType); } } } } return result;}//退出到candidate，在主候选项抉择之前避免晚期的bean初始化。private void addCandidateEntry(Map<String, Object> candidates, String candidateName, DependencyDescriptor descriptor, Class<?> requiredType) { if (descriptor instanceof MultiElementDescriptor) { Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this); if (!(beanInstance instanceof NullBean)) { candidates.put(candidateName, beanInstance); } } else if (containsSingleton(candidateName) || (descriptor instanceof StreamDependencyDescriptor && ((StreamDependencyDescriptor) descriptor).isOrdered())) { Object beanInstance = descriptor.resolveCandidate(candidateName, requiredType, this); candidates.put(candidateName, (beanInstance instanceof NullBean ? null : beanInstance)); } else { candidates.put(candidateName, getType(candidateName)); }}//确定Auto的候选人protected String determineAutowireCandidate(Map<String, Object> candidates, DependencyDescriptor descriptor) { Class<?> requiredType = descriptor.getDependencyType(); // 如果是次要的，间接返回 String primaryCandidate = determinePrimaryCandidate(candidates, requiredType); if (primaryCandidate != null) { return primaryCandidate; } // 如果是最高级的，间接返回 String priorityCandidate = determineHighestPriorityCandidate(candidates, requiredType); if (priorityCandidate != null) { return priorityCandidate; } // Fallback // 如果不是次要和最高级的 for (Map.Entry<String, Object> entry : candidates.entrySet()) { String candidateName = entry.getKey(); Object beanInstance = entry.getValue(); if ((beanInstance != null && this.resolvableDependencies.containsValue(beanInstance)) || matchesBeanName(candidateName, descriptor.getDependencyName())) { return candidateName; } } return null;}//断定状况（如果是次要的状况）protected String determinePrimaryCandidate(Map<String, Object> candidates, Class<?> requiredType) { String primaryBeanName = null; for (Map.Entry<String, Object> entry : candidates.entrySet()) { String candidateBeanName = entry.getKey(); Object beanInstance = entry.getValue(); if (isPrimary(candidateBeanName, beanInstance)) { if (primaryBeanName != null) { boolean candidateLocal = containsBeanDefinition(candidateBeanName); boolean primaryLocal = containsBeanDefinition(primaryBeanName); if (candidateLocal && primaryLocal) { throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(), "more than one 'primary' bean found among candidates: " + candidates.keySet()); } else if (candidateLocal) { primaryBeanName = candidateBeanName; } } else { primaryBeanName = candidateBeanName; } } } return primaryBeanName;}//如果是最高级的状况protected String determineHighestPriorityCandidate(Map<String, Object> candidates, Class<?> requiredType) { String highestPriorityBeanName = null; Integer highestPriority = null; for (Map.Entry<String, Object> entry : candidates.entrySet()) { String candidateBeanName = entry.getKey(); Object beanInstance = entry.getValue(); if (beanInstance != null) { Integer candidatePriority = getPriority(beanInstance); if (candidatePriority != null) { if (highestPriorityBeanName != null) { if (candidatePriority.equals(highestPriority)) { throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(), "Multiple beans found with the same priority ('" + highestPriority + "') among candidates: " + candidates.keySet()); } else if (candidatePriority < highestPriority) { highestPriorityBeanName = candidateBeanName; highestPriority = candidatePriority; } } else { highestPriorityBeanName = candidateBeanName; highestPriority = candidatePriority; } } } } return highestPriorityBeanName;}//是否为次要的，即有primaryprotected boolean isPrimary(String beanName, Object beanInstance) { if (containsBeanDefinition(beanName)) { return getMergedLocalBeanDefinition(beanName).isPrimary(); } BeanFactory parent = getParentBeanFactory(); return (parent instanceof DefaultListableBeanFactory && ((DefaultListableBeanFactory) parent).isPrimary(beanName, beanInstance));}//获取优先级protected Integer getPriority(Object beanInstance) { Comparator<Object> comparator = getDependencyComparator(); if (comparator instanceof OrderComparator) { return ((OrderComparator) comparator).getPriority(beanInstance); } return null;}//确定给定的候选名称是否与bean名或别名匹配存储在这个bean定义中protected boolean matchesBeanName(String beanName, @Nullable String candidateName) { return (candidateName != null && (candidateName.equals(beanName) || ObjectUtils.containsElement(getAliases(beanName), candidateName)));}//是否自援用private boolean isSelfReference(@Nullable String beanName, @Nullable String candidateName) { return (beanName != null && candidateName != null && (beanName.equals(candidateName) || (containsBeanDefinition(candidateName) && beanName.equals(getMergedLocalBeanDefinition(candidateName).getFactoryBeanName()))));}//没有匹配，抛异样private void raiseNoMatchingBeanFound( Class<?> type, ResolvableType resolvableType, DependencyDescriptor descriptor) throws BeansException { checkBeanNotOfRequiredType(type, descriptor); throw new NoSuchBeanDefinitionException(resolvableType, "expected at least 1 bean which qualifies as autowire candidate. " + "Dependency annotations: " + ObjectUtils.nullSafeToString(descriptor.getAnnotations()));}//查看private void checkBeanNotOfRequiredType(Class<?> type, DependencyDescriptor descriptor) { for (String beanName : this.beanDefinitionNames) { RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); Class<?> targetType = mbd.getTargetType(); // 指定的的类型是mbd的targetType子类且合乎主动注入条件 if (targetType != null && type.isAssignableFrom(targetType) && isAutowireCandidate(beanName, mbd, descriptor, getAutowireCandidateResolver())) { // Probably a proxy interfering with target type match -> throw meaningful exception. Object beanInstance = getSingleton(beanName, false); // 获取bean的类型 Class<?> beanType = (beanInstance != null && beanInstance.getClass() != NullBean.class ? beanInstance.getClass() : predictBeanType(beanName, mbd)); // 理论类型不是指定类型的子类 if (beanType != null && !type.isAssignableFrom(beanType)) { throw new BeanNotOfRequiredTypeException(beanName, type, beanType); } } } // 从父类查看 BeanFactory parent = getParentBeanFactory(); if (parent instanceof DefaultListableBeanFactory) { ((DefaultListableBeanFactory) parent).checkBeanNotOfRequiredType(type, descriptor); }}//创立一个Optional的依赖private Optional<?> createOptionalDependency( DependencyDescriptor descriptor, @Nullable String beanName, final Object... args) { DependencyDescriptor descriptorToUse = new NestedDependencyDescriptor(descriptor) { @Override public boolean isRequired() { return false; } @Override public Object resolveCandidate(String beanName, Class<?> requiredType, BeanFactory beanFactory) { return (!ObjectUtils.isEmpty(args) ? beanFactory.getBean(beanName, args) : super.resolveCandidate(beanName, requiredType, beanFactory)); } }; Object result = doResolveDependency(descriptorToUse, beanName, null, null); return (result instanceof Optional ? (Optional<?>) result : Optional.ofNullable(result));}//重写toString办法public String toString() { StringBuilder sb = new StringBuilder(ObjectUtils.identityToString(this)); sb.append(": defining beans ["); sb.append(StringUtils.collectionToCommaDelimitedString(this.beanDefinitionNames)); sb.append("]; "); BeanFactory parent = getParentBeanFactory(); if (parent == null) { sb.append("root of factory hierarchy"); } else { sb.append("parent: ").append(ObjectUtils.identityToString(parent)); } return sb.toString();}
- 面向用户的高级容器——ApplicationContext接口体系
ApplicationContext间接翻译也被称作利用上下文，其实这个字面很难被了解，Context的意思是上下文、环境，其实集体认为翻译成应用环境可能会更好一些，能够认为ApplicationContext是一种定义了保护BeanDefinition和实例化对象之间协作关系的高级接口，而这个高级接口，又是利用了Spring中一般容器来实现的，所以也被称作高级容器，也是咱们平时认为的Spring容器体系，因为BeanFactroy尽管也是容器，然而平时咱们间接接触不到，作为用户，平时在应用的时候，咱们间接用的是ApplicationContext高级容器，也就是说，高级容器是面向用户的，而一般容器是面向框架的，是Spring容器的基石。
ApplicationContext接口继承自BeanFactory的二级接口ListableBeanFactory和HierarchicalBeanFactroy。所以高级容器其实也是在一般容器的根底上实现的，在一般容器的根底上扩大除了十分丰盛的性能接口来供用户应用，如果深刻去浏览源码，会发现其实在高级容器的一个很重要的抽象类AbstractRefreshableApplicationContext外部，是有一个公有的一般容器对象的，而咱们罕用的一些高级容器实现类，比方FileSystemXmlApplicationContext、AnnotatioConfigWebApplicationContext等都继承自这个抽象类，也就是说都继承了这个一般容器对象：
这个外部的DefaultListableBeanFactory对象，通常也被称作外部容器，Spring的设计大量使用了委托模式的思维，这里在高级容器外部实例化一个外部容器进去，将一般容器的所有操作都委托给外部容器去实现，而高级容器自身只须要关注与拓展面向用户的操作即可。
下图是ApplicationContext体系类图，之后咱们将开展剖析一下这个体系：
高级容器的顶级接口——ApplicationContext接口
首先，ApplicationContext接口继承自ListableBeanFactory和HierarchicalBeanFactroy，也就是ApplicationContext上面的接口和类，都继承或者实现了BeanFactroy体系中的大部分性能，包含对BeanDefinition的单个与批量操作和容器分层的办法。在此基础上，ApplicationContext还同时继承了其它四个接口，对容器进行了办法的扩大 - AbstractAutowireCapableBeanFactory次要是用于主动拆卸，Bean的创立、属性填充、连贯(包含主动拆卸)、初始化和销毁，以及BeanPostProcessor的调用。
spring学习之源码剖析--AbstractAutowireCapableBeanFactory - SegmentFault 思否