spring基础-核心类DefaultListableBeanFactory（一）：ConfigurableListableBeanFactory接口

最新推荐文章于 2023-11-15 17:28:27 发布

陈小亮L

最新推荐文章于 2023-11-15 17:28:27 发布

阅读量2.4k

点赞数 2

分类专栏： spring基础文章标签： spring

本文链接：https://blog.csdn.net/u011151359/article/details/99718484

版权

spring基础专栏收录该内容

4 篇文章 1 订阅

订阅专栏

文章目录

spring基础核心类DefaultListableBeanFactory（一）：ConfigurableListableBeanFactory接口
- 一.ConfigurableListableBeanFactory接口

spring基础核心类DefaultListableBeanFactory（一）：ConfigurableListableBeanFactory接口

DefaultListableBeanFactory是整个bean加载的核心部分，是spring注册及加载bean的默认实现。

DefaultListableBeanFactory继承了AbstractAutowireCapableBeanFactory类，实现了ConfigurableListableBeanFactory和BeanDefinitionRegistry接口。

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
		implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
}

DefaultListableBeanFactory类的层次结构图：

在这里插入图片描述

由上面的层次结构图发现：
DefaultListableBeanFactory继承了AbstractAutowireCapableBeanFactory类，实现了ConfigurableListableBeanFactory和BeanDefinitionRegistry接口。

一.ConfigurableListableBeanFactory接口

DefaultListableBeanFactory类实现了ConfigurableListableBeanFactory接口。
ConfigurableListableBeanFactory接口：实现对工厂的配置以及对bean属性的自动装配。

查看

public interface ConfigurableListableBeanFactory
		extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

	//忽略自动装配的依赖类型
	void ignoreDependencyType(Class<?> type);

    //忽略自动装配的接口
	void ignoreDependencyInterface(Class<?> ifc);

    //注册一个可分解的依赖
	void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);

    // 判断指定的Bean是否有资格作为自动装配的候选者
	boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
			throws NoSuchBeanDefinitionException;

	//根据beanName获取beanDefinition实例
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	Iterator<String> getBeanNamesIterator();

	void clearMetadataCache();

    //暂时冻结所有的Bean配置
	void freezeConfiguration();

    //判断本工厂配置是否被冻结
	boolean isConfigurationFrozen();

    //使所有的非延迟加载的单例类都实例化。
	void preInstantiateSingletons() throws BeansException;
}

ConfigurableListableBeanFactory接口层次结构图：
在这里插入图片描述

ConfigurableListableBeanFactory接口继承了ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory接口。而ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory都继承了BeanFactory接口。

1、BeanFactory接口

其中BeanFactory接口是spring中所有工厂类的超类，最基础的对象容器视图。

Spring自带了多个容器实现，可以归为两种不同的类型。

BeanFactory（由org.springframework.beans.factory.BeanFactory接口定义）是最简单的容器，提供基本的DI支持。
ApplicationContext（由org.springframework.context.ApplicationContext接口定义）应用上下文，基于BeanFactory构建，并提供应用框架级别的服务，例如从属性文件解析文本信息以及发布应用事件给感兴趣的事件监听者。

public interface BeanFactory {

	 /*区分FactoryBean实例和FactoryBean创建的实例*/
	 //如果&开始则获取FactoryBean;否则获取createBean创建的实例
	String FACTORY_BEAN_PREFIX = "&";

	  /*获取一个对象实例，单例对象返回都是对象的引用*/
	Object getBean(String name) throws BeansException;

	 /*获取一个对象实例,requiredType是一个接口，或者实例类的父类*/
	<T> T getBean(String name, @Nullable Class<T> requiredType) throws BeansException;
	
    /*获取一个对象实例,args是创建实例具体参数*/
	Object getBean(String name, Object... args) throws BeansException;
	
   /*获取一个对象实例,requiredType是一个接口，或者实例类的父类*/
	<T> T getBean(Class<T> requiredType) throws BeansException;

	<T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
	
	/*判断对象工厂中是否有指定名称name的对象*/
	boolean containsBean(String name);

	/*判断对象工厂中名称name的对象是否是单例的*/
	boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
   
   /*判断对象工厂中名称name的对象是否是prototype类型的*/
	boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

   /*判断对象工厂中名称name的实例是否typeToMatch类型匹配*/
	boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;

	boolean isTypeMatch(String name, @Nullable Class<?> typeToMatch) throws NoSuchBeanDefinitionException;

 	/*判断对象工厂中名称name实例的类型*/
	@Nullable
	Class<?> getType(String name) throws NoSuchBeanDefinitionException;
 
   /*判断对象工厂中名称name的别称*/
    String[] getAliases(String name);
}

在上文的ConfigurableListableBeanFactory接口层次结构图中可以看到：
BeanFactory有三个子类：ListableBeanFactory, AutowireCapableBeanFactory, HierarchicalBeanFactory。

为什么BeanFactory会分三个子类？
每个接口都有他使用的场合，它主要是为了区分在Spring内部在操作过程中对象的传递和转化过程中，对对象的数据访问所做的限制。

ListableBeanFactory接口表示这些Bean是可列表的
HierarchicalBeanFactory表示的是这些Bean是有继承关系的，也就是每个Bean有可能有父Bean。
AutowireCapableBeanFactory接口定义Bean的自动装配规则

1.1、ListableBeanFactory接口

获取bean时,Spring 鼓励使用这个接口定义的api。扩展BeanFactory接口,提供所有bean 实例的枚举,不再需要客户端通过一个个bean。

这个接口中的方法只会考虑本factory定义的bean.这些方法会忽略ConfigurableBeanFactory的registerSingleton注册的单例bean,getBeanNamesOfType和getBeansOfType是例外,一样会考虑手动注册的单例.当然BeanFactory的getBean一样可以透明访问这些特殊bean.当然在典型情况下,所有的bean都是由external bean定义,所以应用不需要顾虑这些差别

public interface ListableBeanFactory extends BeanFactory {

    //对于给定的beanName是否含有BeanDefinition
	boolean containsBeanDefinition(String beanName);

    //返回工厂的BeanDefinition总数
	int getBeanDefinitionCount();

    //返回工厂中所有Bean定义的名字
	String[] getBeanDefinitionNames();

	//根据bean的类型获取beanNames
	//这边的方法仅检查顶级bean.它不会检查嵌套的bean.FactoryBean创建的bean会匹配为FactoryBean而不是原始类型.
	String[] getBeanNamesForType(ResolvableType type);

	//获取给定类型的beanNames(包括子类),通过bean 定义或者FactoryBean的getObjectType判断.
	//返回对于指定类型Bean（包括子类）的所有beanNames
	String[] getBeanNamesForType(@Nullable Class<?> type);

    //返回指定类型的beanNames  
    //includeNonSingletons为false表示只取单例Bean，true则不是
    //allowEagerInit为true表示立刻加载，false表示延迟加载
	String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

    //根据类型（包括子类）返回指定beanName和bean的Map
	<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;

    //查找使用注解的类
	String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

    //根据注解类型，查找所有有这个注解的beanName和bean的Map
	Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

    // 根据指定beanName和注解类型查找指定的bean
	@Nullable
	<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
			throws NoSuchBeanDefinitionException;
}

ListableBeanFactory工厂中扩展了

3个 BeanDefinition有关的接口，
3个根据指定类型返回beanName的数组
2个根据指定类型返回bean和存储Bean的Map集合
3个和注解有关的返回bean和beanMap的接口方法

1.2、HierarchicalBeanFactory接口

HierarchicalBeanFactory 提供父容器的访问功能.至于父容器的设置,需要找ConfigurableBeanFactory的setParentBeanFactory(接口把设置跟获取给拆开了!).

public interface HierarchicalBeanFactory extends BeanFactory {

    //返回工厂的父工厂，实现了工厂的分层。
	@Nullable
	BeanFactory getParentBeanFactory();

    //判断本地工厂是否包含bean（忽略其他所有父工厂）
	boolean containsLocalBean(String name);

}

1.3、AutowireCapableBeanFactory接口

AutowireCapableBeanFactory接口继承自BeanFacotory，它扩展了自动装配的功能，根据类定义BeanDefinition装配Bean、执行前、后处理器等。

这个接口其实是扩展了Bean的自动装配方法和前后处理器BeanPostProcessors


public interface AutowireCapableBeanFactory extends BeanFactory {

    //工厂没有自动装配的Bean
	int AUTOWIRE_NO = 0;

    //根据名称自动装配的Bean
	int AUTOWIRE_BY_NAME = 1;

    //表明根据类型自动装配
	int AUTOWIRE_BY_TYPE = 2;

    //根据构造方法快速装配的bean
	int AUTOWIRE_CONSTRUCTOR = 3;

    //Bean的class内部来进行装配，Spring 3.0开始被弃用
	@Deprecated
	int AUTOWIRE_AUTODETECT = 4;

    //根据bena的类型来创建Bean实例
	<T> T createBean(Class<T> beanClass) throws BeansException;

    ///给定对象，在后处理bean，进行自动装配
	void autowireBean(Object existingBean) throws BeansException;

    //根据Bean的BeanDefinition,来装配这个未加工的Object
	Object configureBean(Object existingBean, String beanName) throws BeansException;
	
	//会执行bean完整的初始化,包括BeanPostProcessors和initializeBean
	Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	//传入指定的Bean的类型，指定的装配的策略，是否依赖检查 来创建一个完全新的Bean
	Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

    //自动装配
	void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
			throws BeansException;

	//初始化之前执行BeanPostProcessors
	void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;


	Object initializeBean(Object existingBean, String beanName) throws BeansException;

	
	Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException;


	Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException;

    //销毁指定的Bean
	void destroyBean(Object existingBean);


	<T> NamedBeanHolder<T> resolveNamedBean(Class<T> requiredType) throws BeansException;

	//分解指定的依赖
	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException;

	
	@Nullable
	Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName,
			@Nullable Set<String> autowiredBeanNames, @Nullable TypeConverter typeConverter) throws BeansException;

}

ListableBeanFactory工厂

总共5个静态不可变常量来指明装配策略，其中一个常量被Spring3.0废弃、一个常量表示没有自动装配，另外3个常量指明不同的装配策略——根据名称、根据类型、根据构造方法。
6个自动装配bean的方法
2个分解指定依赖的方法

2.ConfigurableBeanFactory接口

ConfigurableBeanFactory接口的层次结构图：
在这里插入图片描述

2.1、SingletonBeanRegistry接口

此接口是针对Spring中的单例Bean设计的。提供了统一访问单例Bean的功能，BeanFactory可实现此接口以提供访问内部单例Bean的能力


public interface SingletonBeanRegistry {

    //以指定的名字将给定Object注册到BeanFactory中
	void registerSingleton(String beanName, Object singletonObject);

	//以Object的形式返回指定名字的Bean
	@Nullable
	Object getSingleton(String beanName);

	//检查此实例是否包含指定beanName的bean并且已经初始化完成的单例bean
	boolean containsSingleton(String beanName);

    //获取所有单例names
	String[] getSingletonNames();

	//返回容器内注册的单例类数量
	int getSingletonCount();

    //返回此注册中使用的单例互斥锁
	Object getSingletonMutex();

}

2.2、ConfigurableBeanFactory接口

ConfigurableBeanFactory同时继承了HierarchicalBeanFactory 和 SingletonBeanRegistry 这两个接口，即同时继承了分层和单例类注册的功能。

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

    //定义了两个作用域: 单例和原型.可以通过registerScope来添加.
    
	String SCOPE_SINGLETON = "singleton";

	String SCOPE_PROTOTYPE = "prototype";

    //设置父容器
    //搭配父接口HierarchicalBeanFactory 中得getParentBeanFactory()
	void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

    //类加载器设置与获取.默认使用当前线程中的类加载器
	void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);

	//类加载器设置与获取.默认使用当前线程中的类加载器
	@Nullable
	ClassLoader getBeanClassLoader();

	//设置、返回一个临时的类加载器
	void setTempClassLoader(@Nullable ClassLoader tempClassLoader);

    //设置、返回一个临时的类加载器
	@Nullable
	ClassLoader getTempClassLoader();

	//是否需要缓存beanMetadata,比如beanDifinition 和 解析好的classes.默认开启缓存
	void setCacheBeanMetadata(boolean cacheBeanMetadata);

    //是否需要缓存beanMetadata,比如beanDifinition 和 解析好的classes.默认开启缓存
	boolean isCacheBeanMetadata();

	//Bean表达式分解器
	//定义用于解析bean definition的表达式解析器
	void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);

    //定义用于解析bean definition的表达式解析器
	@Nullable
	BeanExpressionResolver getBeanExpressionResolver();

	//设置、返回一个转换服务   类型转化器
	void setConversionService(@Nullable ConversionService conversionService);

	//设置、返回一个转换服务   类型转化器
	@Nullable
	ConversionService getConversionService();

	//设置属性编辑
	void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

	//注册常用属性编辑器
	void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

    //用工厂中注册的通用的编辑器初始化指定的属性编辑注册器
	void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

	//BeanFactory用来转换bean属性值或者参数值的自定义转换器
	void setTypeConverter(TypeConverter typeConverter);

	//BeanFactory用来转换bean属性值或者参数值的自定义转换器
	TypeConverter getTypeConverter();

	//增加一个嵌入式的StringValueResolver
	void addEmbeddedValueResolver(StringValueResolver valueResolver);

    
	boolean hasEmbeddedValueResolver();

	//分解指定的嵌入式的值
	@Nullable
	String resolveEmbeddedValue(String value);

    //设置一个Bean后处理器
	void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

    //返回Bean后处理器的数量
	int getBeanPostProcessorCount();

    //作用域定义 注册范围
	void registerScope(String scopeName, Scope scope);

	//作用域定义 返回注册的范围名
	String[] getRegisteredScopeNames();

    //作用域定义 返回指定的范围
	@Nullable
	Scope getRegisteredScope(String scopeName);

	//访问权限控制 返回本工厂的一个安全访问上下文
	AccessControlContext getAccessControlContext();

    //复制其他工程的属性配置
	void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

	//给指定的Bean注册别名
	void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

	//根据指定的StringValueResolver移除所有的别名
	void resolveAliases(StringValueResolver valueResolver);

	//返回指定Bean合并后的Bean定义
	BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	//判断指定Bean是否为一个工厂Bean
	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);

	//销毁指定的范围Bean
	void destroyScopedBean(String beanName);

    //销毁所有的单例类
	void destroySingletons();
}