spring之beanFactory

最新推荐文章于 2023-03-18 22:43:20 发布

你的boy_Z

最新推荐文章于 2023-03-18 22:43:20 发布

阅读量349

点赞数

分类专栏： spring

本文链接：https://blog.csdn.net/qq_36628536/article/details/113753451

版权

spring 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Spring学习之BeanFactory

学习契机：在学习工厂模式的时候想到了它，本人觉得设计模式的学习结合Spring 一起是一种很棒方式，可以快速的理解该模式的意义和使用场景，也可以加深对Spring的理解。

1、工厂模式

是一种创造型的模式，也就是我们业务需要创建一个对象时候可以考虑用到的模式。

应用场景：以往的创造对象我们直接new（）一个对象，这种模式简单，但是对客户端暴露了对象的结构，另外对象与客户端的耦合性很高（也就是说我们如果new（）对象的结构发生了改变，我们需要修改客户端的代码）。再想想如果我们想拓展我们的程序（物流公司为例），之前我们物流只包括陆运对象（new 陆运（）），现在我们想加入海运，这时候我们就要重写我们的程序，利用工厂模式很好解决这个问题。客户端创建的对象全部利用工厂（接口）来创建，而各个子工厂（陆运工厂和海运工厂）中各自实现它们自己的创建逻辑。这样我们在增加或者修改物流方式，我们不需要修改客户端代码，只需要修改子工厂代码就可以了。

2、BeanFactory的定义

根据源码注释获得以下信息：

用于访问Spring bean容器的根接口
它是bean容器的基本客户端视图，ListableBeanFactory（它的实现类）和ConfigurableBeanFactory是根据不同的业务需求创建出来的。符合工厂模式的概念，不同的子工厂具有相同父工厂功能，也具体有自己的业务功能
实现该接口的对象都包含一组BeanDefinitionMap，对象根据唯一的beanDefinition生成不同类型的bean，包括单列和原型，虽然是不同类型，但是生成它们的api（getBean()）都是同一个
Bean Factory优点，就是它集中了应用组件的管理，应用中的组件不需要单独的去读取配置。而是通过BeanFactory 统一读取，然后创建不同的对象。这里应该是节省了io开销的意思。
HierarchicalBeanFactory 和ListableBeanFactory的区别，前者在获取bean获取不到时，会向其直接父容器获取。前者可以重写父容器存在的bean；

3、BeanFactory体系

在这里插入图片描述

我们先关注上图以BeanFacotory接口为顶层接口的结构逻辑；

1、BeanFactory

public interface BeanFactory {

	/**
	 * 如果bean属于FactoryBean类型，并名字加了&,通过ge'tBean返回的就是这个FactoryBean
	 * 否则返回的就是FactoryBean生产的bean
	 */
	String FACTORY_BEAN_PREFIX = "&";


	/**
	 *根据bean的名字获取bean,如果本工厂获取不到，去本工厂的父工厂获取。
	 */
	Object getBean(String name) throws BeansException;

2、ListableBeanFactory

通过名字可以猜到，这定义的一个可列举（迭代）的BeanFactory，通过这个BeanFactory 可以查找特定的Bean，相比顶级的BeanFactory，其查询更加多样化，牵涉到了BeanDefinition，BeanName，注解。

//继承了BeanFactory接口
//它提供了枚举所有bean实例的功能，而不是通过getBean(name)一个一个查
public interface ListableBeanFactory extends BeanFactory {

	/**
	 * 查看benaName对应的bean的beanDefinition是否存在在该工厂
	 */
	boolean containsBeanDefinition(String beanName);

	/**
	 * 获取该工厂含有的BeanDefinition数量
	 */
	int getBeanDefinitionCount();

	/**
	 * 获取该工厂含有的BeanDefinition的名字
	 */
	String[] getBeanDefinitionNames();

	/**
	 * 返回对于指定类型 获取bean的名字
	 */
	String[] getBeanNamesForType(ResolvableType type);

	

	/*
	 *根据类来获取BeanNames, includeNonSIngletions：是否包括原型的类；allowEagerInit，是否包括已经初始化过的bean
	 */
	String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit);

	/**
	 * 根据class获取一个beanName 和 bean对应的map
	 */
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type) throws BeansException;

	/**
	 * 和上面的方法功能一致，只是增加了是否包含原型和是否考虑已经初始化的bean的条件筛选
	 */
	<T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
			throws BeansException;

	/**
	 * 获取标注了某种注解的bean的name
	 */
	String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType);

	/**
	 * 获取标注了某种注解的beanName和bean的实例
	 */
	Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) throws BeansException;

	/**
	 * 获取指定bean名称 和指定注解类型的注解对象
	 */
	@Nullable
	<A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
			throws NoSuchBeanDefinitionException;

3、HierarchicalBeanFactory

分层式的BeanFactory, 它实现了分层式工厂应该有的功能，既然分层就应该可以获取其父容器，并且要能够获取该层内bean。

public interface HierarchicalBeanFactory extends BeanFactory {

	/**
	 * 返回父亲Bean工厂，如果没有就是none。设置父工厂，通过ConfigurableBeanFactory接口实现
	 */
	@Nullable
	BeanFactory getParentBeanFactory();

	/**
	 * 获取本地工厂中对应beanName的bean，也就是说不去其父工厂获取，相对于getBean（）来说。
	 */
	boolean containsLocalBean(String name);

4、AutowireCapableBeanFactory

自动注入bean工厂；

自动注入可以说是IOC的一个核心功能，spring 通过该工厂接口来定义这个功能的基础方法。

@autowrire @resource 和xml配置文件都可以实现自动注入功能。

而@AutoWrite 是根据bean的type，如果找到多个去找@Primary,再去找@Order,在去找@PriotiryOrder,最后找name;

@Resouece是通过name，默认以byName的方式去匹配与属性名相同的bean的id，如果没有找到就会以byType的方式查找，如果byType查找到多个的话，使用@Qualifier注解（spring注解）指定某个具体名称的bean。

public interface AutowireCapableBeanFactory extends BeanFactory {

	/**
	 * 常量，表示没有自动装配的Bean
	 */
	int AUTOWIRE_NO = 0;

	/**
	 * 常量，表示根据name自动装配Bean
	 */
	int AUTOWIRE_BY_NAME = 1;

	/**
	 * 常量，表示根据type自动装配Bean
	 */
	int AUTOWIRE_BY_TYPE = 2;

	/**
	 * 常量，表示自动注入构造器的bean
	 */
	int AUTOWIRE_CONSTRUCTOR = 3;


	/**
	 * 已经初始化过bean对象的后缀，区分bean是否被初始化
	 */
	String ORIGINAL_INSTANCE_SUFFIX = ".ORIGINAL";


	//-------------------------------------------------------------------------
	// Typical methods for creating and populating external bean instances
	//-------------------------------------------------------------------------

	/**
	 * 根据提供的bean的class，创建一个新的bean，并执行该bean包括的所有BeanPostProcessor；
	   它不适用于传统的 by-name by-type 
	 */
	<T> T createBean(Class<T> beanClass) throws BeansException;

	/**
	 * 利用autowriteBeanProperties来为存在的bean赋值。
	 	通过应用after-instantiation接口和 bean property post-processing
	 */
	void autowireBean(Object existingBean) throws BeansException;

	/**
	 * 自动装配属性,填充属性值,使用诸如setBeanName,setBeanFactory这样的工厂回调填充属性,最好还要调用post processor
	 */
	Object configureBean(Object existingBean, String beanName) throws BeansException;


	//-------------------------------------------------------------------------
	// Specialized methods for fine-grained control over the bean lifecycle
    // 在bean的生命周期进行细粒度控制的专门方法
	//-------------------------------------------------------------------------

	/**
	 * 会执行bean完整的初始化,包括BeanPostProcessors和initializeBean
	 */
	Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	/**
	 * 根据给定的自动注入方式实例化一个bean并注完成自动注入 注意这里是实例化一个bean, 可以通过实现InstantiationAwareBeanPostProcessor
	 */
	Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException;

	/**
	 * 根据名称 和根据类型来注入一个存在的bean的 properties
	 */
	void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)
			throws BeansException;

	/**
	 * 将指定beanName对应的bean Definition的 property value 应用到 existingBean,
	 * 个人理解就是把一个bean的属性 转移到另一个bean
	 */
	void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException;

	/**
	 * 初始化给定的存在的bean， 可以设置BeanName,BeanFactory. beanName参数，只有需要使用BeanPostProcessor时候传入
	 */
	Object initializeBean(Object existingBean, String beanName) throws BeansException;

	/**
	 * 执行给定bean的postProcessBeforeInitailization方法 初始化执行之前
	 * 这时候返回的bean就可能是方法包装过的bean
	 */
	Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
			throws BeansException;

	/**
	 * 执行给定bean的postProcessAfterInitailization方法 初始化执行之后.
	 * 这时候返回的bean就可能是方法包装过的bean
	 */
	Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
			throws BeansException;

	/**
	 * 摧毁指定的bean
	 */
	void destroyBean(Object existingBean);

}

这个BeanFactory 提供了给bean注入属性的功能，并提供在创建一个bean的时候执行bean的生命周期接口来改变bean的能力。

小结

上面三种Facttory是BeanFactory的直系亲属，它们三个提供了三种能力，分别是获取多个bean的能力，给beanFactory提供分层的能力，以及提供bean自动注入和改变bean的能力。三个接口三个职责，职能单一模式。符合工厂模式。不同的工厂具有不同的创造能力。

接下来我们在看看其它更多样的BeanFactory

5、ConfigurableBeanFactory

public interface ConfigurableBeanFactory extends HierarchicalBeanFactory, SingletonBeanRegistry {

	/**
	 *bean 范围定义 单列
	 */
	String SCOPE_SINGLETON = "singleton";

	/**
	 *bean 范围定义 原型
	 */
	String SCOPE_PROTOTYPE = "prototype";


	/**
	 *设置父容器
	 */
	void setParentBeanFactory(BeanFactory parentBeanFactory) throws IllegalStateException;

	/**
	 * 设置bean的类加载器，这个类加载器模式是运行的线程的加载器，还有就是这个类加载器只应用与bean definitions 而不会加载一个 resolved bean class??? 这里没看懂
	 */
	void setBeanClassLoader(@Nullable ClassLoader beanClassLoader);

	/**
	 * 返回这个工厂的类加载器 来加载bean
	 */
	@Nullable
	ClassLoader getBeanClassLoader();

	/**
	 * 设置该容器的临时类加载器，只要在涉及到加载时编织才会涉及临时的类加载器，从而确保编制的类？？？？ 尽可能的延迟加载。推测和延迟加载有关。(这里是通过特殊的类加载器实现aop)
	 * @since 2.5
	 */
	void setTempClassLoader(@Nullable ClassLoader tempClassLoader);

	@Nullable
	ClassLoader getTempClassLoader();

	/**
	 * 设置是否缓存bean的元数据（beanDefinitions和已经解析的class）,通过合并的方式。
	 * 默认时开启缓存的，如果关闭缓存，每一次创建bean都会利用类加载器加载最新的bean class 来解析生成对象
	 */
	void setCacheBeanMetadata(boolean cacheBeanMetadata);

	/**
	 * 返回是否开启了缓存
	 */
	boolean isCacheBeanMetadata();

	/**
	 * 为bean definition 指定表达式解析策略
	 */
	void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver);

	/**
	 * 返回bean定义值中表达式的解析策略
	 */
	@Nullable
	BeanExpressionResolver getBeanExpressionResolver();

	/**
	 * 指定用于转换的Spring 3.0 ConversionService属性值，以替代JavaBeans PropertyEditors
	 * @since 3.0
	 */
	void setConversionService(@Nullable ConversionService conversionService);

	/**
	 * 
	 */
	@Nullable
	ConversionService getConversionService();

	/**
	 * 注册属性编辑器
	 */
	void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar);

	void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass);

	void copyRegisteredEditorsTo(PropertyEditorRegistry registry);

	void setTypeConverter(TypeConverter typeConverter);

	TypeConverter getTypeConverter();

	/**
	 * 为嵌入的值（例如注释属性）添加字符串解析器
	 */
	void addEmbeddedValueResolver(StringValueResolver valueResolver);
    
	boolean hasEmbeddedValueResolver();
    
	@Nullable
	String resolveEmbeddedValue(String value);

	/**
	 * 添加一个新的BeanPostProcessor，它将应用于该工厂创建的bean. 
	 * 在出厂配置期间调用。
	 * <p>Note: 这里注册的后置处理器按照注册顺序调用;. 
	 * 自动注入的后置处理器，总是晚于编程植入的后置处理器；
	 */
	void addBeanPostProcessor(BeanPostProcessor beanPostProcessor);

	/**
	 * 获取beanPostProcessor的数量.
	 */
	int getBeanPostProcessorCount();


	void registerScope(String scopeName, Scope scope);

	String[] getRegisteredScopeNames();

	@Nullable
	Scope getRegisteredScope(String scopeName);

	/**
	 * 提供与此工厂有关的安全访问控制上下文
	 */
	AccessControlContext getAccessControlContext();

	/**
	 *把一个工厂的配置拷贝到该工厂，但是不包含 BeanDefinition 和 bean name 别名
	 */
	void copyConfigurationFrom(ConfigurableBeanFactory otherFactory);

	/**
	 * 给bean注册别名（类似与我们的mapper文件的别名）
	 */
	void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException;

	/**
	 * 解析别名
	 */
	void resolveAliases(StringValueResolver valueResolver);

	/**
	 * 返回一个合并的 bean definition对象，要考虑其父容器中是否存在同名的 bean definition对象
	 * @since 2.5
	 */
	BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	/**
	 * 判断这个bean是不是一个工厂bean
	 */
	boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException;


	/**
	 * 为指定bean注册一个依赖的bean。注意，销毁this bean之前 会销毁依赖的bean
	 */
	void registerDependentBean(String beanName, String dependentBeanName);

	/**
	 * 返回所有依赖这个bean的bean Names
	 */
	String[] getDependentBeans(String beanName);

	/**
	 * 返回指定bean 依赖的所有beanNames
	 */
	String[] getDependenciesForBean(String beanName);

	/**
	 * 销毁bean
	 */
	void destroyBean(String beanName, Object beanInstance);

	/**
	 * 销毁指定scope的bean
	 */
	void destroyScopedBean(String beanName);

	/**
	 * 摧毁单列bean，一般在工厂停工时被调用
	 */
	void destroySingletons();

ConfigurableBeanFactory 继承了HierarchicalBeanFactory(具有分层的能力) SingletonBeanRegistry, 我们在看一下SingletonBeanRegistry的源码：

5、1 SingletonBeanRegistry

public interface SingletonBeanRegistry {

	/**
	 * 将指定对象 以指定名称注册成单例的bean，注意这个对象一定是
	 */
	void registerSingleton(String beanName, Object singletonObject);

	/**
	 * 获取一个一个已经实例化的单例对象，不会返回未实例化的bean definition 对象
	 */
	@Nullable
	Object getSingleton(String beanName);

	/**
	 *查看这个registry是否包含一个指定名字的bean，查询只会在实例化过后的bean中进行， 
	 * 用 ListableBeanFactory's {@code containsBeanDefinition}.
	 * and {@code containsSingleton} 可以查询一个指定BeanDefinition的bean是否在存在
	 */
	boolean containsSingleton(String beanName);

	/**
	 * 获取已经实例化的单例bean的名字s
	 */
	String[] getSingletonNames();

	/**
	 * 获取已经实例化的单例bean的名字s
	 */
	int getSingletonCount();

	Object getSingletonMutex();

该类主要实现了单例类注册和获取的功能。

而ConfigurableBeanFactory类继承了HierarchicalBeanFactory 、和SingletonBeanRegistry，说明它是具有分层和注册单例功能的工厂，同事其本身实现了很多配置接口。比如：设置改工厂的父工厂（也是分层工厂子类的一种实现）、设置bean的类加载器（和临时加载器）、设置工厂是否开启缓存、设置bean definition 指定表达式解析策略等等，和添加bean的后置处理器等功能，可以看出来这个工厂的功能还是很多的。

6、ConfigurableListableBeanFactory

public interface ConfigurableListableBeanFactory
		extends ListableBeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory {

	/**
	 * 忽略自动装配的类型，如果是该类型就不进行自动装配
	 */
	void ignoreDependencyType(Class<?> type);

	/**
	 *自动装配时忽略指定依赖的接口 
	 * 该方法主要应用在应用容器注册的一些组件已经通过其它方式被加载，比如依赖了一个beanFactory,并且它已	  *	经通过beanFactoryAware装配了。默认忽略BeanFactory接口。
	 */
	void ignoreDependencyInterface(Class<?> ifc);

	/**
	 *根据指定的自动装配值注册指定的依赖
	 */
	void registerResolvableDependency(Class<?> dependencyType, @Nullable Object autowiredValue);

	/**
	 * 确定指定的bean是否符合自动装配候选条件
	 */
	boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor)
			throws NoSuchBeanDefinitionException;

	/**
	 *返回指定bean名称对应的已经注册在该工厂（不向父工厂获取）的 local bean definition。
	 * 我们可以根据这个definition获取该bean的属性值和构造函数的参数
	 */
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	/**
	 * 返回对此工厂管理的所有bean名称的统一视图。
	 *包括Bean定义名称以及手动注册的单例实例的名称，并且始终将Bean定义名称排在首位，类似于特定于类型/	 	  *注释的Bean名称检索的工作方式。
	 */
	Iterator<String> getBeanNamesIterator();

	/**
	 * 删除工厂中缓存的合并beanDefinition
	 * 应用场景：在触发BeanFactoryPostProcesser之后，因为这个接口可能改变工厂的bean definintion
	 */
	void clearMetadataCache();

	/**
	 *冻结工厂所有的bean definitions,是工厂的bean definitions 不在修改和没有后置处理器要触发的信号 
	 * 冻结之后 工厂就可以缓存bean definition了。
	 */
	void freezeConfiguration();

	/**
	 * 返回该工厂是否被冻结
	 */
	boolean isConfigurationFrozen();

	/**
	 * 确保所有的非延迟加载的单例bean已经被实例化。 
	 * 如果需要调用这个接口，一般都是在工厂设置结束之后调用。
	 */
	void preInstantiateSingletons() throws BeansException;

ConfigurationListableBeanFactory接口，主要实现了自动装配的配置、获取BeanDefinition、和工厂缓存管理等一些功能。

到这里位置，我们把左边BeanFactory 接口以及其子类都看的差不多了，我们了解了各个工厂接口所具有的能力，大概了解了BeanFactory所具有的功能，我们接下来看看右边的对象。

7、BeanDefinitionRegistry

根据名字我们可以知道，这是一个BeanDefinition的注册器，我们根据源码来查看一下它具有什么功能。

public interface BeanDefinitionRegistry extends AliasRegistry {

	/**
	 *为指定beanName 注册一个指定的beanDefinition
	 */
	void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
			throws BeanDefinitionStoreException;

	/**
	 * 移除指定beanName 所对应的beanDefinition
	 */
	void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	/**
	 * 获取指定bean的bean definition
	 */
	BeanDefinition getBeanDefinition(String beanName) throws NoSuchBeanDefinitionException;

	/**
	 *判断该注册器中是否含有指定beanName的BeanDefinition
	 */
	boolean containsBeanDefinition(String beanName);

	/**
	 *返回所有的BeanDefinitionNames
	 */
	String[] getBeanDefinitionNames();

	/**
	 *获取bean definition 的数量
	 */
	int getBeanDefinitionCount();

	/**
	 * 判断这个 bean definition 是否被用到。 通过判断是否有localBean 
	 */
	boolean isBeanNameInUse(String beanName);

}

我们可以看到它的大部分功能就是操作beanDefinition, 可能大家要问什么是beanDefinition,虽然我们没有自己了解过，但是可以通过名字看出来，它是bean的定义，我们生成bean 要根据bean的定义来生成，这样才能生成客户端想要的bean。

我们先来看一下beanDefinition的结构图

在这里插入图片描述

确实也很复杂，我们从核心接口 BeanDefinition开始了解；

该接口是一个bean 实例的描述，它可以描述bean的属性值、构造器的参数和其它的一些具体信息。

我们可以通过BeanFactoryPostProcessor 去修改BeanDefiniton中的值。

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
	//和ConfigurableBeanFactory 关联，引入工厂的区域概念
	String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;

	String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;


	
	int ROLE_APPLICATION = 0;
    //用户自己配置的，配置文件，注解
	int ROLE_SUPPORT = 1;
    //我是Spring自己的
	int ROLE_INFRASTRUCTURE = 2;


	// Modifiable attributes

	/**
	 * 设置这个beanDefinition 父 benaDefinition的名字.
	 */
	void setParentName(@Nullable String parentName);
	@Nullable
	String getParentName();

	/**
	 * 指定该beanDifinition 对应bean类的类名.
	 * <p>在factory的后置处理器可以更改，通常利用解析过的类名代替原始类名.
	 * @see #setParentName
	 * @see #setFactoryBeanName
	 * @see #setFactoryMethodName
	 */
	void setBeanClassName(@Nullable String beanClassName);

	@Nullable
	String getBeanClassName();

	/**
	 * 覆盖此beanDifiniton 的使用范围
	 */
	void setScope(@Nullable String scope);
	@Nullable
	String getScope();

	/**
	 *设置这个bean是否延迟加载
	 */
	void setLazyInit(boolean lazyInit);

	/**
	 *只适用于单例bean
	 */
	boolean isLazyInit();

	/**
	 * 设置这个bean依赖被初始化的bean名称，bean工厂会确保先将依赖的bean初始化掉.
	 */
	void setDependsOn(@Nullable String... dependsOn);
	@Nullable
	String[] getDependsOn();

	/**
	 * 设置这个bean是否可以成为被自动注入的bean，注意这个设置只对根据类型注入有效，不会影响根据name。 
	 */
	void setAutowireCandidate(boolean autowireCandidate);
	boolean isAutowireCandidate();

	/**
	 * 设置这个bean是否是自主注入的首选
	 */
	void setPrimary(boolean primary);
	boolean isPrimary();

	/**
	 * 指定该bean的工厂bean的名称
	 */
	void setFactoryBeanName(@Nullable String factoryBeanName);
	@Nullable
	String getFactoryBeanName();

	/**
	 * 指定一个工厂方法， 这个工厂方法会被执行携带构造器参数。
	 */
	void setFactoryMethodName(@Nullable String factoryMethodName);
	@Nullable
	String getFactoryMethodName();

	/**
	 * 返回这个bean的构造器参数值，可以通过工厂的后置处理器修改这个值
	 */
	ConstructorArgumentValues getConstructorArgumentValues();

	default boolean hasConstructorArgumentValues() {
		return !getConstructorArgumentValues().isEmpty();
	}

	/**
	 * 返回这个bean的属性值，可以通过工厂的后置处理器修改这个值
	 */
	MutablePropertyValues getPropertyValues();
	default boolean hasPropertyValues() {
		return !getPropertyValues().isEmpty();
	}

	/**
	 * 设置这个bean的初始化方法名字
	 */
	void setInitMethodName(@Nullable String initMethodName);
	@Nullable
	String getInitMethodName();

	/**
	 * 设置这个bean摧毁方法的名称
	 */
	void setDestroyMethodName(@Nullable String destroyMethodName);
	@Nullable
	String getDestroyMethodName();

	/**
	 *设置beanDefinition的权限提示
	 */
	void setRole(int role);
	int getRole();
	void setDescription(@Nullable String description);
	@Nullable
	String getDescription();


	// Read-only attributes

	/**
	 * 返回此bean定义的可解析类型，基于Bean类或其他特定的元数据
	 */
	ResolvableType getResolvableType();
	boolean isSingleton();
	boolean isPrototype();

	/**
	 * Return whether this bean is "abstract", that is, not meant to be instantiated.
	 */
	boolean isAbstract();

	/**
	 * 返回原始的BeanDefinition
	 */
	@Nullable
	BeanDefinition getOriginatingBeanDefinition();

通过上述源码，我们可以发现，beanDefinition接口定义了一个bean的一切属性。容器中的每个bean都对应一个beanDifinition。关于beanDifiniton的其它接口可以自己了解一下。

接下来我们通过一段代码，来贯穿一下整个流程；

		//手动创建一个BeanFactory
        DefaultListableBeanFactory factory = new DefaultListableBeanFactory();

        //为向注入到工厂的bean创建BeanDefinition
        AbstractBeanDefinition beanDefinition = new RootBeanDefinition(MyBean.class);
        
        factory.registerBeanDefinition("myBean",beanDefinition);
        //根据bean Name获取bean
        MyBean bean = (MyBean) factory.getBean("myBean");

        System.out.println(bean.toString());

总结

从BeanFactory接口出发，我们了解了其体系结构，首先了解它的三个直系亲属：

ListableBeanFactory(可列举的bean工厂（多花样查询，涉及到了BeanDefiniton，这里仅仅开放了获取的接口，而没有开放设置的接口)；

HierarchicalBeanFactory(分层次容器，获取父容器，检查是否含有本地bean，一样只开放了获取接口)；

AutowireCapableBeanFactory(自动装配容器)，定义了注入的三种方式，并提供了createBean（)方法以及初始化bean的方法，执行bean的后置处理器方法；

这三个直系亲属下面又派生了两个复杂的容器：ConfigurableBeanFactory 和 ConfigurableListableBeanFactory 两个容器都是以可配置为主题的容器；

ConfigutableBeanFactory: 提供了前面三个基类中开放获取接口对应的设置接口，并提供了设置改工厂的父工厂（也是分层工厂子类的一种实现）、设置bean的类加载器（和临时加载器）、设置工厂是否开启缓存、设置bean definition 指定表达式解析策略等等；

ConfigurableListableBeanFactory: 主要实现了自动装配的配置、获取BeanDefinition、和工厂缓存管理等一些功能.

ition);
//根据bean Name获取bean
MyBean bean = (MyBean) factory.getBean(“myBean”);

    System.out.println(bean.toString());




## 总结

从BeanFactory接口出发，我们了解了其体系结构，首先了解它的三个直系亲属：

ListableBeanFactory(可列举的bean工厂（多花样查询，涉及到了BeanDefiniton，这里仅仅开放了获取的接口，而没有开放设置的接口)；

HierarchicalBeanFactory(分层次容器，获取父容器，检查是否含有本地bean，一样只开放了获取接口)；

AutowireCapableBeanFactory(自动装配容器)，定义了注入的三种方式，并提供了createBean（)方法以及初始化bean的方法，执行bean的后置处理器方法；

这三个直系亲属下面又派生了两个复杂的容器：ConfigurableBeanFactory 和 ConfigurableListableBeanFactory 两个容器都是以可配置为主题的容器；

ConfigutableBeanFactory: 提供了前面三个基类中开放获取接口对应的设置接口，并提供了设置**改工厂的父工厂**（也是分层工厂子类的一种实现）、**设置bean的类加载器**（和临时加载器）、**设置工厂是否开启缓存**、设置**bean definition 指定表达式解析策略**等等；

ConfigurableListableBeanFactory:   主要实现了自动装配的配置、获取BeanDefinition、和工厂缓存管理等一些功能.

你的boy_Z

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
spring之beanFactory

Spring学习之BeanFactory学习契机：在学习工厂模式的时候想到了它，本人觉得设计模式的学习结合Spring 一起是一种很棒方式，可以快速的理解该模式的意义和使用场景，也可以加深对Spring的理解。1、工厂模式是一种创造型的模式，也就是我们业务需要创建一个对象时候可以考虑用到的模式。应用场景：以往的创造对象我们直接new（）一个对象，这种模式简单，但是对客户端暴露了对象的结构，另外对象与客户端的耦合性很高（也就是说我们如果new（）对象的结构发生了改变，我们需要修改客户端的代码）。再想想
复制链接

扫一扫