SpringIoc源码（二）- BeanFactory（一）- 结构梳理(DefaultListableBeanFactory)

最新推荐文章于 2023-02-14 10:26:27 发布

it_lihongmin

最新推荐文章于 2023-02-14 10:26:27 发布

阅读量385

点赞数 1

分类专栏： Spring源码文章标签： XmlBeanFactory DefaultListableBeanFactory SingletonBeanRegistry BeanDefinitionRegistry AliasRegistry

本文链接：https://blog.csdn.net/it_lihongmin/article/details/102926202

版权

Spring源码专栏收录该内容

55 篇文章 23 订阅

订阅专栏

一、接口

1、BeanFactory

1）、FACTORY_BEAN_PREFIX

2）、ObjectProvider

3）、ResolvableType

2、AliasRegistry

3、BeanDefinitionRegistry

3、SingletonBeanRegistry

二、抽象类

1、SimpleAliasRegistry

2、DefaultSingletonBeanRegistry

3、FactoryBeanRegistrySupport

4、AbstractBeanFactory

5、AbstractAutowireCapableBeanFactory

6、DefaultListableBeanFactory

7、XmlBeanFactory

BeanFactory主要实现都集中在DefaultListableBeanFactory中，那么可以先看一下其结构就知道有什么功能了。BeanFactory会先将需要注册的每一个Bean的所有信息解析后，以BeanDefinition的形式保存容器中。

而解析就有很多种，之前用的最多的是Spring配置的xml中，使用Resource加载并解析成Document，再将Document解析成BeanDefinition；后面可以使用ComponentScan扫描包的方式；ImportAware等形式。

最后使用BeanFactory的getBean方法，将使用依赖注入的方式将BeanDefinition解析初始化为Bean实例，放入BeanFactory容器中。

从两张不同视角的图看到BeanFactory的继承体系，才觉得慢慢理解了Java的接口的定义，每一种接口类型就定义了和每一层BeanFactory的抽象都会增加不同的功能（能力）。所以分为两个方面进行分析，接口和每一层对接口的实现。

一、接口

最顶层的接口有BeanFactory，用于定义Bean的核心方法，getBean等。BeanDefinitionRegistry用于将解析的BeanDefinition进行注册存储。SingletonBeanRegistry用于在getBean时将单例的Bean注册存储。

1、BeanFactory

先看看BeanFactory最顶层接口都定义了哪些方法：

public interface BeanFactory {

    // FactoryBean前缀
    String FACTORY_BEAN_PREFIX = "&";

    // 根据Bean名称，Class，或者参数   获取Bean
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;
    <T> T getBean(Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;

    // 根据Class获取生产的工厂
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    // 根据Class<T>(Bean类型和其泛型类型)，获取生产的工厂
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);

    // 是否包含该名称的Bean
    boolean containsBean(String name);
    // 是否单例的Bean
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    // 是否原型的Bean
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    // 这个名称bean，是否对应Class<T>(Bean类型和其泛型类型)
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    // 这个名称bean，是否Class类型
    boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    // 获取这个名称Bean的Class类型
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    // 这个名称的Bean,是否FactoryBean生产的
    Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
    // 获取这个名称Bean的别名
    String[] getAliases(String name);
}

1）、FACTORY_BEAN_PREFIX

BeanFactory的Spring的核心，该工厂是一个抽象工厂，能够生成不同类型的Bean。比如我们每一个Bean（比如UserService）就是一个抽象工厂生成的Bean。

为了扩展，Spring定义了一种FactoryBean机制，当getBean没有获取到时会使用FactoryBean的getObject方法，获取到的是什么那么该Bean就是什么。那么每一种FactoryBean（比如JndiObjectFactoryBean）本身也是也是像UserService一样是BeanFactory抽象工厂生成出来的一种Bean。那么FactoryBean本身即是一个Bean，又是一个生产Bean（比如UserFactoryBean的getObject返回的是一个User对象）的工厂，并且被BeanFactory进行管理。

那么在使用BeanFactory的getBean获FactoryBean类型的Bean时，如果getBean(FACTORY_BEAN_PREFIX+"beanName")，那么返回的是FactoryBean本身，否则返回的是当前FactoryBean的getObject返回的对象。

2）、ObjectProvider

上面的方法中好几个都用到了ObjectProvider类型，看看其结构：

public interface ObjectProvider<T> extends ObjectFactory<T>, Iterable<T> {
    
    T getObject(Object... args) throws BeansException;

    T getIfAvailable() throws BeansException;

    // ......
}

是ObjectFactory的子类，就是获取生产对于Bean的工厂。

3）、ResolvableType

当定义了一个Bean类型为public class User<Document> （或者）更复杂的是父类也定义了泛型。那么一个Class<?>肯定是不能更好的表达其含义的。泛型在编译器后由类型的擦除，运行是都是Object类型，所以需要记录下其状态。可以看一个其内部方法。

public static ResolvableType forClassWithGenerics(Class<?> clazz, Class<?>... generics) {
    Assert.notNull(clazz, "Class must not be null");
    Assert.notNull(generics, "Generics array must not be null");
    ResolvableType[] resolvableGenerics = new ResolvableType[generics.length];
    for (int i = 0; i < generics.length; i++) {
        resolvableGenerics[i] = forClass(generics[i]);
    }
    return forClassWithGenerics(clazz, resolvableGenerics);
}

比如当前Bean类型为，A<B>那么可以：

ResolvableType resolvableType = ResolvableType.forClassWithGenerics(A, B);

各种重载的getBean是使用最广泛的，经常在项目总进行使用。对上面三点理解后其方法也就比较好理解了。

2、AliasRegistry

public interface AliasRegistry {
    // 注册一个别名
    void registerAlias(String name, String alias);
    // 删除一个别名
    void removeAlias(String alias);
    // 当前这个名称是否有别名
    boolean isAlias(String name);
    // 获取所有的别名
    String[] getAliases(String name);
}

3、BeanDefinitionRegistry

public interface BeanDefinitionRegistry extends AliasRegistry {
    // 指定名称，注册BeanDefinition
    void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
            throws BeanDefinitionStoreException;
    // 删除名称为beanName的BeanDefinition
    void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    // 获取名称为beanName的BeanDefinition
    BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;
    // 是否有名称为beanName的BeanDefinition
    boolean containsBeanDefinition(String beanName);
    // 获取所有的BeanDefinition的名称
    String[] getBeanDefinitionNames();
    // 注册了多少个BeanDefinition
    int getBeanDefinitionCount();
    // Bean名称是否在使用
    boolean isBeanNameInUse(String beanName);
}

3、SingletonBeanRegistry

public interface SingletonBeanRegistry {
    // 注册单例的Bean
    void registerSingleton(String beanName, Object singletonObject);
    // 根据名称获取单例的Bean
    Object getSingleton(String beanName);
    // 是否有这个名称的单例Bean
    boolean containsSingleton(String beanName);
    // 获取所有的单例Bean的名称
    String[] getSingletonNames();
    // 获取单例Bean的个数
    int getSingletonCount();
    /**
     * Return the singleton mutex used by this registry (for external collaborators).
     * @return the mutex object (never {@code null})
     * @since 4.2
     */
    Object getSingletonMutex();
}

二、抽象类

1、SimpleAliasRegistry

public class SimpleAliasRegistry implements AliasRegistry {

    private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);
}

SimpleAliasRegistry只是实现了AliasRegistry接口，实现了所有的方法。由于一个Bean的名称可能有多个别名，所以Spring使用的是ConcurrentHashMap进行存储，key的别名，value是名称。

2、DefaultSingletonBeanRegistry

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {

    /**
     * 缓存已经初始化好的单利Bean
     */
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);

    /**
     * 缓存单利好的Bean名称和生产的 ObjectFactory.
     */
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

    /**
     * 缓存依赖注入提前暴露的Bean，也是单利循环依赖注入实现的根本
     */
    private final Map<String, Object> earlySingletonObjects = new HashMap<>(16);

    /**
     * 已经实例好的单利Bean，LinkedHashSet有序，按照bean名称进行排序
     */
    private final Set<String> registeredSingletons = new LinkedHashSet<>(256);

    /**
     * 当前正在创建中的Bean名称
     */
    private final Set<String> singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /**
     * Names of beans currently excluded from in creation checks.
     */
    private final Set<String> inCreationCheckExclusions =
            Collections.newSetFromMap(new ConcurrentHashMap<>(16));

    /**
     * 可以理解为异常的Trace
     */
    @Nullable
    private Set<Exception> suppressedExceptions;

    /**
     * 是否在DestroySingleton中的标志
     */
    private boolean singletonsCurrentlyInDestruction = false;

    /**
     * 实现了DisposableBean接口的Bean（生命周期的销户阶段）
     */
    private final Map<String, Object> disposableBeans = new LinkedHashMap<>();

    /**
     * 包含bean名称之间的映射：bean名称到bean包含的一组bean名称
     */
    private final Map<String, Set<String>> containedBeanMap = new ConcurrentHashMap<>(16);

    /**
     * 当前Bean依赖的 Bean列表（Autowried等的Bean名称集合）
     */
    private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);

    /**
     * 当前Bean依赖的 所有依赖列表
     */
    private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);
}

主要是对SingletonBeanRegistry的实现，所以定义了很多容器去装载单利Bean信息，已经依赖注入的Bean集合的关系、实现销毁的Bean集合。后面都会使用。

3、FactoryBeanRegistrySupport

public abstract class FactoryBeanRegistrySupport extends DefaultSingletonBeanRegistry {

	/** 
     * 缓存FactoryBean形式创建的Bean，的beanName和FactoryBean
     */
	private final Map<String, Object> factoryBeanObjectCache = new ConcurrentHashMap<>(16);
}

结构很清晰，就是为了增加FactoryBean扩展类型的支持，所以用容器装beanName和FactoryBean的关系，至于创建好的Bean应该是交给父类DefaultSingletonBeanRegistry 去处理了。

4、AbstractBeanFactory

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
    /**
     * 父工厂对HierarchicalBeanFactory的实现支持
     */
    @Nullable
    private BeanFactory parentBeanFactory;

    /**
     * 类加载器
     */
    @Nullable
    private ClassLoader beanClassLoader = ClassUtils.getDefaultClassLoader();

    /**
     * 临时使用的类加载器
     */
    @Nullable
    private ClassLoader tempClassLoader;

    /**
     * 缓存bean元数据还是每次访问都重新获取它
     */
    private boolean cacheBeanMetadata = true;

    /**
     * bean定义值中表达式的解析策略
     */
    @Nullable
    private BeanExpressionResolver beanExpressionResolver;

    /**
     * PropertyEditors.
     */
    @Nullable
    private ConversionService conversionService;

    /**
     * 自定义PropertyEditorRegistrars
     */
    private final Set<PropertyEditorRegistrar> propertyEditorRegistrars = new LinkedHashSet<>(4);

    /**
     * 自定义 PropertyEditors
     */
    private final Map<Class<?>, Class<? extends PropertyEditor>> customEditors = new HashMap<>(4);

    /**
     * 自定义TypeConverter
     */
    @Nullable
    private TypeConverter typeConverter;

    /**
     * 要应用的字符串解析器，例如用于注释属性值
     */
    private final List<StringValueResolver> embeddedValueResolvers = new CopyOnWriteArrayList<>();

    /**
     * 在Bean的生命周期时需要调用的BeanPostProcessor
     */
    private final List<BeanPostProcessor> beanPostProcessors = new CopyOnWriteArrayList<>();

    /**
     * 指示是否已注册任何实例化BeanPostprocessor
     */
    private volatile boolean hasInstantiationAwareBeanPostProcessors;

    /**
     * 指示是否已注册任何DestructionAwareBeanPostProcessors
     */
    private volatile boolean hasDestructionAwareBeanPostProcessors;

    /**
     * Map from scope identifier String to corresponding Scope.
     */
    private final Map<String, Scope> scopes = new LinkedHashMap<>(8);

    /**
     * 使用SecurityManager运行时使用的安全上下文
     */
    @Nullable
    private SecurityContextProvider securityContextProvider;

    /**
     * bean的RootBeanDefinition（聚合了父类等最后的BeanDefinition）的关系
     */
    private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);

    /**
     * 至少创建过一次的beanName的集合（原型创建完就交给客户端了）
     */
    private final Set<String> alreadyCreated = Collections.newSetFromMap(new ConcurrentHashMap<>(256));

    /**
     * 当前正在创建的bean的名称
     */
    private final ThreadLocal<Object> prototypesCurrentlyInCreation =
            new NamedThreadLocal<>("Prototype beans currently in creation");
}

非常重要的一层，实现了ConfigurableBeanFactory（提供配置了Factory的方法）接口，而ConfigurableBeanFactory有继承自HierarchicalBeanFactory（定义了父子工厂相关）接口。HierarchicalBeanFactory又继承自BeanFactory，最重要的getBean的实现在这里完成。相当于这一层完成了这三个接口定义的功能的实现。

5、AbstractAutowireCapableBeanFactory

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
        implements AutowireCapableBeanFactory {

    /**
     * 创建Bean实例的策略
     */
    private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

    /**
     * 方法参数名的解析器策略
     */
    @Nullable
    private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();

    /**
     * 是否自动尝试解析bean之间的循环引用
     */
    private boolean allowCircularReferences = true;

    /**
     * 在循环引用的情况下，是否采用注入原始bean实例的方法
     */
    private boolean allowRawInjectionDespiteWrapping = false;

    /**
     * 注入Bean的时候会根据 autowire等检查依赖注入，但是有些（属性）是可以忽略的
     */
    private final Set<Class<?>> ignoredDependencyTypes = new HashSet<>();

    /**
     * 注入Bean的时候会根据 autowire等检查依赖注入，但是有些是可以忽略的，比如在构造中初始化的BeanNameAware.class
     */
    private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();

    /**
     * 当前创建的bean的名称，用于隐式依赖项注册从用户指定的供应商回调触发的getBean etc调用
     */
    private final NamedThreadLocal<String> currentlyCreatedBean = new NamedThreadLocal<>("Currently created bean");

    /**
     * 缓存未初始化完的FactoryBean实例，缓存FactoryBean的名称和对应的BeanWrapper
     */
    private final ConcurrentMap<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>();

    /**
     * 缓存工厂类的工厂方法
     */
    private final ConcurrentMap<Class<?>, Method[]> factoryMethodCandidateCache = new ConcurrentHashMap<>();

    /**
     * 已筛选PropertyDescriptor的缓存：将bean类缓存到PropertyScriptor数组
     */
    private final ConcurrentMap<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
            new ConcurrentHashMap<>();


    /**
     * 添加需要忽略的
     */
    public AbstractAutowireCapableBeanFactory() {
        super();
        ignoreDependencyInterface(BeanNameAware.class);
        ignoreDependencyInterface(BeanFactoryAware.class);
        ignoreDependencyInterface(BeanClassLoaderAware.class);
    }
}

AbstractAutowireCapableBeanFactory实现了AutowireCapableBeanFactory接口，而AutowireCapableBeanFactory接口定义了创建Bean的、自动注入、初始化以及应用Bean的后处理器。所以在这一层都进行了实现。实现了createBean、autowireBean、configureBean、autowire、applyBeanPropertyValues、initializeBean、destroyBean、resolveDependency等重要的接口方法实现。

6、DefaultListableBeanFactory

DefaultListableBeanFactory继承了上面所以的类，则拥有了所有的功能。并且支持了创建Bean注册后的处理。

7、XmlBeanFactory

虽然Xml配置文件加载Bean已经基本很少使用了，但是还是用了好几年，并且前几年也基于XmlBeanFactory去梳理源码，所以也梳理一下。

public class XmlBeanFactory extends DefaultListableBeanFactory {

    private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

    public XmlBeanFactory(Resource resource) throws BeansException {
        this(resource, null);
    }

    public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
        super(parentBeanFactory);
        this.reader.loadBeanDefinitions(resource);
    }
}

其他类型的BeanFactory都不会有基于Spring的Resource去加载Xml配置文件，并且将加载的io流转换为Document再去验证是否符合Spring定义的标签，再去加载解析整棵树的Document。最后再和@ComponentScan等一样去将BeanDefinition注册到BeanFactory的BeanDefinitionRegistry中。

所以其构造都是和Resource有关的，并且提供了成员变量XmlBeanDefinitionReader 去解析Xml文件。

it_lihongmin

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
SpringIoc源码（二）- BeanFactory（一）- 结构梳理(DefaultListableBeanFactory)

目录一、接口1、BeanFactory1）、FACTORY_BEAN_PREFIX2）、ObjectProvider3）、ResolvableType2、AliasRegistry3、BeanDefinitionRegistry3、SingletonBeanRegistry二、抽象类1、SimpleAliasRegistry2、DefaultSingle...
复制链接

扫一扫