BeanDefinition 及其构造方式 BeanDefinitionBuilder, AbstractBeanDefinition

BeanDefinition 及其构造方式 BeanDefinitionBuilder, AbstractBeanDefinition

前言

  1. 本文基于 jdk 8, spring-framework 5.2.x 编写。
  2. @author JellyfishMIX - github / blog.jellyfishmix.com
  3. LICENSE GPL-2.0

BeanDefinition

BeanDefinition 的属性

spring IoC 容器中的每一个 bean 都会有一个对应的 BeanDefinition 实例,该实例负责保存 bean 对象的所有必要信息,如下所示:

属性(property)说明
classbean 全类名,必须是具体类,不能是抽象类或接口(因为抽象类或接口不能实例化)
namebean 的名称或 id
scopebean 的作用域
constructor argumentsbean 构造器参数(用于依赖注入)
propertiesbean 属性设置(用于依赖注入)
autowiring modebean 自动绑定模式(例如通过名称 byName)
lazy initialization modebean 延迟初始化模式(延迟和非延迟)
initialization methodbean 初始化回调方法名称
destruction methodbean 销毁回调方法名称

需要说明的一点是:如果是自己直接通过 SingletonBeanRegistry#registerSingleton 向容器手动注入 Bean 的,不会存在这份 Bean 定义信息,这点需要注意。 Spring 内部有不少这样的例子(因为这种Bean非常简单,不需要定义信息):

beanFactory.registerSingleton(ENVIRONMENT_BEAN_NAME, getEnvironment());
bf.registerSingleton(WebApplicationContext.SERVLET_CONTEXT_BEAN_NAME, servletContext);
Collections.unmodifiableMap(attributeMap));

三种 BeanDefinition:

  1. GenericBeanDefinition: 通用的 BeanDefinition,可以有 parentBeanDefinition。源码的实现非常简单,只增加了一个 parentName 的属性值,其余的实现都在父类 AbstractBeanDefinition 里。
    1. 通过 xml 方式配置 bean,最初被加载进来都是一个 GenericBeanDefinition,之后再逐渐解析的。
  2. ChildBeanDefinition: 子 BeanDefinition,依赖于父类 RootBeanDefinition
    1. 它可以继承它父类的设置,即 ChildBeanDefinition 对 RootBeanDefinition 有一定的依赖关系。
    2. 从 spring 2.5 开始,提供了一个更好的 GenericBeanDefinition,所以以后推荐使用它,不使用 ChildBeanDefinition。
  3. RootBeanDefinition: 根 BeanDefinition,不能有 parentBeanDefinition
    1. 在 配置文件中可以定义父和子,子用 ChildBeanDefiniton 表示,而没有父的用 RootBeanDefinition 表示。
BeanDefinitionBuilder 中与三种 BeanDefinition 对应的构造方法
/**
 * Programmatic means of constructing
 * {@link org.springframework.beans.factory.config.BeanDefinition BeanDefinitions}
 * using the builder pattern. Intended primarily for use when implementing Spring 2.0
 * {@link org.springframework.beans.factory.xml.NamespaceHandler NamespaceHandlers}.
 *
 * @author Rod Johnson
 * @author Rob Harrop
 * @author Juergen Hoeller
 * @since 2.0
 */
public final class BeanDefinitionBuilder {

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link GenericBeanDefinition}.
	 *
	 * 创建一个通用的 beanDefinition,什么属性都不填充
	 */
	public static BeanDefinitionBuilder genericBeanDefinition() {
		return new BeanDefinitionBuilder(new GenericBeanDefinition());
	}

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link GenericBeanDefinition}.
	 *
	 * 创建一个通用的 beanDefinition,填充 bean 的 className
	 *
	 * @param beanClassName the class name for the bean that the definition is being created for
	 */
	public static BeanDefinitionBuilder genericBeanDefinition(String beanClassName) {
		BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
		builder.beanDefinition.setBeanClassName(beanClassName);
		return builder;
	}

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link GenericBeanDefinition}.
	 *
	 * 创建一个通用的 beanDefinition,填充 bean 的 class
	 *
	 * @param beanClass the {@code Class} of the bean that the definition is being created for
	 */
	public static BeanDefinitionBuilder genericBeanDefinition(Class<?> beanClass) {
		BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
		builder.beanDefinition.setBeanClass(beanClass);
		return builder;
	}

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link GenericBeanDefinition}.
	 *
	 * 创建一个通用的 beanDefinition,填充 bean 的 class,填充一个 bean 实例创建时会调用的回调函数
	 *
	 * @param beanClass the {@code Class} of the bean that the definition is being created for
	 * @param instanceSupplier a callback for creating an instance of the bean
	 * @since 5.0
	 */
	public static <T> BeanDefinitionBuilder genericBeanDefinition(Class<T> beanClass, Supplier<T> instanceSupplier) {
		BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new GenericBeanDefinition());
		builder.beanDefinition.setBeanClass(beanClass);
		builder.beanDefinition.setInstanceSupplier(instanceSupplier);
		return builder;
	}

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link RootBeanDefinition}.
	 *
	 * 创建一个根 beanDefinition,填充 bean 的 className
	 *
	 * @param beanClassName the class name for the bean that the definition is being created for
	 */
	public static BeanDefinitionBuilder rootBeanDefinition(String beanClassName) {
		return rootBeanDefinition(beanClassName, null);
	}

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link RootBeanDefinition}.
	 *
	 * 创建一个根 beanDefinition,填充 bean 的 className,填充构造 bean 实例使用的方法名
	 *
	 * @param beanClassName the class name for the bean that the definition is being created for
	 * @param factoryMethodName the name of the method to use to construct the bean instance  构造 bean 实例使用的方法名
	 */
	public static BeanDefinitionBuilder rootBeanDefinition(String beanClassName, @Nullable String factoryMethodName) {
		BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new RootBeanDefinition());
		builder.beanDefinition.setBeanClassName(beanClassName);
		builder.beanDefinition.setFactoryMethodName(factoryMethodName);
		return builder;
	}

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link RootBeanDefinition}.
	 *
	 * 创建一个根 beanDefinition,填充 bean 的 class
	 *
	 * @param beanClass the {@code Class} of the bean that the definition is being created for
	 */
	public static BeanDefinitionBuilder rootBeanDefinition(Class<?> beanClass) {
		return rootBeanDefinition(beanClass, null);
	}

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link RootBeanDefinition}.
	 *
	 * 创建一个根 beanDefinition,填充 bean 的 class,填充构造 bean 实例使用的方法名
	 *
	 * @param beanClass the {@code Class} of the bean that the definition is being created for
	 * @param factoryMethodName the name of the method to use to construct the bean instance
	 */
	public static BeanDefinitionBuilder rootBeanDefinition(Class<?> beanClass, @Nullable String factoryMethodName) {
		BeanDefinitionBuilder builder = new BeanDefinitionBuilder(new RootBeanDefinition());
		builder.beanDefinition.setBeanClass(beanClass);
		builder.beanDefinition.setFactoryMethodName(factoryMethodName);
		return builder;
	}

	/**
	 * Create a new {@code BeanDefinitionBuilder} used to construct a {@link ChildBeanDefinition}.
	 *
	 * 创建一个子 beanDefinition,填充父 beanDefinition 的名字
	 *
	 * @param parentName the name of the parent bean
	 */
	public static BeanDefinitionBuilder childBeanDefinition(String parentName) {
		return new BeanDefinitionBuilder(new ChildBeanDefinition(parentName));
	}


	/**
	 * The {@code BeanDefinition} instance we are creating.
	 *
	 * 创建出的 beanDefinition 实例
	 */
	private final AbstractBeanDefinition beanDefinition;

AbstractBeanDefinition

BeanDefinition 是个接口,AbstractBeanDefinition 是这个接口的实现类,很多常见的 bean 属性在 AbstractBeanDefinition 中。这是经典的工厂模式,抽象出接口去规范工厂生产的实体类的行为。

另外 GenericBeanDefinition 只是子类实现,大部分的属性在 AbstractBeanDefinition 中。

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
        implements BeanDefinition, Cloneable {
    /**
	 * bean 对应的 class(用一个 Class 对象来表示)
	 */
	@Nullable
	private volatile Object beanClass;

	/**
	 * bean 的作用范围
	 * 对应 bean 属性 scope
	 */
	@Nullable
	private String scope = SCOPE_DEFAULT;

	/**
	 * 是否是抽象类
	 * 对应 bean 属性 abstract
	 */
	private boolean abstractFlag = false;

	/**
	 * 是否延迟加载
	 * 对应 bean 属性 lazy-init
	 */
	@Nullable
	private Boolean lazyInit;

	/**
	 * 自动装配模式,自动注入模式
	 * 对应 bean 属性 autowire
	 */
	private int autowireMode = AUTOWIRE_NO;

	/**
	 * 依赖检查模式
	 */
	private int dependencyCheck = DEPENDENCY_CHECK_NONE;

	/**
	 * 用来表示一个 bean 的实例化依靠另一个 bean 先实例化
	 * 这里只会存放<bean/>标签的depends-on属性或是@DependsOn注解的值
	 */
	@Nullable
	private String[] dependsOn;

	/**
	 * autowire-candidate 属性设置为 false,这样容器在查找自动装配对象时,
	 * 将不考虑该 bean,即它不会被考虑作为其他 bean 自动装配的候选者,
	 * 但是该 bean 本身还是可以使用自动装配来注入其他 bean 的
	 */
	private boolean autowireCandidate = true;

	/**
	 * 当某个 bean 的某个属性自动装配有多个候选者(候选者包括此 bean)时,是否优先注入,即 @Primary 注解
	 * 对应 bean 属性 primary
	 */
	private boolean primary = false;

	/**
	 * 用于记录 qualifier
	 * AutowireCandidateQualifier 用于解析自动装配的候选者
	 */
	private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>();

	/**
	 * 用于初始化 bean 的回调函数,一旦指定,这个方法会覆盖工厂方法以及构造函数中的元数据
	 * 可以理解为,通过这个函数的逻辑初始化 bean,而不是构造函数或是工厂方法
	 */
	@Nullable
	private Supplier<?> instanceSupplier;

	/**
	 * 是否允许访问非 public 方法和属性,应用场景是构造函数, 工厂方法, init, destroy 方法解析构造函数
	 */
	private boolean nonPublicAccessAllowed = true;

	/**
	 * 指定解析构造函数的模式,是宽松还是严格
	 * 如果为false,则在以下情况
	 * interface ITest{}
	 * class ITestImpl implements ITest{};
	 * class Main {
	 *     Main(ITest i) {}
	 *     Main(ITestImpl i) {}
	 * }
	 * 抛出异常,因为Spring无法准确定位哪个构造函数程序设置
	 */
	private boolean lenientConstructorResolution = true;

	/**
	 * bean 的 factoryBeanName
	 * <bean id = "currentTime" factory-bean = "instanceFactoryBean" factory-method = "createTime" />
	 */
	@Nullable
	private String factoryBeanName;

	/**
	 * bean 的 factoryMethodName
	 * <bean id = "currentTime" factory-bean = "instanceFactoryBean" factory-method = "createTime" />
	 */
	@Nullable
	private String factoryMethodName;

	/**
	 * 记录构造函数注入属性,对应 bean 属性 constructor-arg
	 */
	@Nullable
	private ConstructorArgumentValues constructorArgumentValues;

	/**
	 * 普通属性集合
	 */
	@Nullable
	private MutablePropertyValues propertyValues;

	/**
	 * 方法重写的持有者,记录 lookup-method, replaced-method 元素
	 */
	private MethodOverrides methodOverrides = new MethodOverrides();

	/**
	 * 初始化方法
	 */
	@Nullable
	private String initMethodName;

	/**
	 * 销毁方法
	 */
	@Nullable
	private String destroyMethodName;

	/**
	 * 是否执行 init-method
	 */
	private boolean enforceInitMethod = true;

	/**
	 * 是否执行 destroy-method
	 */
	private boolean enforceDestroyMethod = true;

	/**
	 * 是否是合成类。根据用户自定义的类生成的 bean 不是合成类,应用程序(框架)生成的是合成类(例如生成 aop 代理类时,不是用户自定义的,这个就是合成类)
	 */
	private boolean synthetic = false;

	/**
	 * 这个 bean 的角色,ROLE_APPLICATION:用户,ROLE_INFRASTRUCTURE:完全内部使用,与用户无关,
	 * ROLE_SUPPORT:某些庞大配置的一部分
	 */
	private int role = BeanDefinition.ROLE_APPLICATION;

	/**
	 * bean 的描述
	 */
	@Nullable
	private String description;

	/**
	 * 这个 bean 定义的资源
	 */
	@Nullable
	private Resource resource;
}

AbstractBeanDefinition 定义了一系列描述 bean 的属性,可以看到 bean 属性的某些默认值(例如默认为单例)。这个类的属性部分可以在 xml 配置文件中找到相应的属性或是标签(例如 AbstractBeanDefinition 的 scope 属性对应 xml 配置文件中的 scope 属性)。

BeanDefinition 的构造方式

  1. 通过 BeanDefinitionBuilder
  2. 通过 AbstractBeanDefinition 及其派生类
    public static void main(String[] args) {
        // 1. 通过 BeanDefinitionBuilder 构建
        BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);
        // 设置 bean 属性,builder 模式可以做到链式调用
        beanDefinitionBuilder.addPropertyValue("id", 1).addPropertyValue("name", "小明");
        // 获取 BeanDefinition 实例
        BeanDefinition abstractBeanDefinition = beanDefinitionBuilder.getBeanDefinition();

        // BeanDefinition 不是 Bean 的终态,可以自定义修改

        // 2. 通过 AbstractBeanDefinition 及其派生类构建
        AbstractBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
        // 设置 bean 类型
        genericBeanDefinition.setBeanClass(User.class);
        // 通过 MutablePropertyValues 批量操作属性,这也是一种链式调用
        MutablePropertyValues propertyValues = new MutablePropertyValues();
        // propertyValues.add("id", 1);
        // propertyValues.add("name", "小明");
        propertyValues.add("id", 1).add("name", "小明");
        genericBeanDefinition.setPropertyValues(propertyValues);
    }

BeanDefinition 什么时候会用到?

spirng 的 ioc 容器实例化 bean 的过程需要 BeanDefinition 中的信息,它是实例化 Bean 的原材料。

例如 org.springframework.context.config.AbstractPropertyLoadingBeanDefinitionParser,这是一个 BeanDefinitionParser (接口)的实现类,用来解析 xml 中的 context:property-… 这样的元素。

解析 xml 时使用 BeanDefinition

package org.springframework.beans.factory.xml;

/**
 * Abstract parser for &lt;context:property-.../&gt; elements.
 * 
 *
 *
 * @author Juergen Hoeller
 * @author Arjen Poutsma
 * @author Dave Syer
 * @since 2.5.2
 */
abstract class AbstractPropertyLoadingBeanDefinitionParser extends AbstractSingleBeanDefinitionParser {	
    
	@Override
	protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) {
		String location = element.getAttribute("location");
		if (StringUtils.hasLength(location)) {
			location = parserContext.getReaderContext().getEnvironment().resolvePlaceholders(location);
			String[] locations = StringUtils.commaDelimitedListToStringArray(location);
			builder.addPropertyValue("locations", locations);
		}

		String propertiesRef = element.getAttribute("properties-ref");
		if (StringUtils.hasLength(propertiesRef)) {
			builder.addPropertyReference("properties", propertiesRef);
		}

		String fileEncoding = element.getAttribute("file-encoding");
		if (StringUtils.hasLength(fileEncoding)) {
			builder.addPropertyValue("fileEncoding", fileEncoding);
		}

		String order = element.getAttribute("order");
		if (StringUtils.hasLength(order)) {
			builder.addPropertyValue("order", Integer.valueOf(order));
		}

		builder.addPropertyValue("ignoreResourceNotFound",
				Boolean.valueOf(element.getAttribute("ignore-resource-not-found")));

		builder.addPropertyValue("localOverride",
				Boolean.valueOf(element.getAttribute("local-override")));

		builder.setRole(BeanDefinition.ROLE_INFRASTRUCTURE);
	}
    
}

具体的逻辑我们可以先不管,能看到 builder.addPropertyValue 这样的代码,这里的 doParse 方法一边在解析 xml,一边在使用 BeanDefinitionBuilder 构建 BeanDefinition。

通过 BeanDefinition 实例化 bean

在一个 AbstractBeanFactory 的子类中,可以看到有一个方法 doCreateBean 在根据 BeanDefinition 实例化 bean。

package org.springframework.beans.factory.support;

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
		implements AutowireCapableBeanFactory {
	/**
	 * Actually create the specified bean. Pre-creation processing has already happened
	 * at this point, e.g. checking {@code postProcessBeforeInstantiation} callbacks.
	 * <p>Differentiates between default bean instantiation, use of a
	 * factory method, and autowiring a constructor.
	 * @param beanName the name of the bean
	 * @param mbd the merged bean definition for the bean
	 * @param args explicit arguments to use for constructor or factory method invocation
	 * @return a new instance of the bean
	 * @throws BeanCreationException if the bean could not be created
	 * @see #instantiateBean
	 * @see #instantiateUsingFactoryMethod
	 * @see #autowireConstructor
	 */
	protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)

bean 构建的具体逻辑我们以后再分析。这里只是举例一下 BeanDefinition 用到的地方,对 BeanDefinition 从构建到使用有一个直观的印象。

  • 2
    点赞
  • 11
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
BeanDefinitionSpring中的一个核心概念,它表示了一个Bean的定义。在Spring中,根据BeanDefinition来创建Bean对象。BeanDefinition具有很多属性用来描述Bean的信息和配置。 AnnotatedBeanDefinition是AnnotatedBeanDefinition接口的实现类,表示注解的BeanDefinition。它包含了注解元数据和基本类元数据的信息。AnnotatedBeanDefinition有两个主要的实现类:AnnotatedGenericBeanDefinition和ScannedGenericBeanDefinition。 RootBeanDefinition代表普通的BeanDefinition实现,通过直接实例化BeanDefinition对象来创建。ChildBeanDefinition代表可以设置父BeanDefinition的子BeanDefinition。GenericBeanDefinition代表一般的BeanDefinition,AnnotatedGenericBeanDefinition和ScannedGenericBeanDefinition都是它的两个主要实现类。 综上所述,BeanDefinitionSpring中用来描述Bean的定义的概念,它包含了Bean的各种属性和配置信息。AnnotatedBeanDefinition是注解的BeanDefinition的实现类,它包含了注解元数据和类元数据的信息。RootBeanDefinition和ChildBeanDefinitionBeanDefinition的不同实现方式,GenericBeanDefinition是一般的BeanDefinition,它的两个主要实现类是AnnotatedGenericBeanDefinition和ScannedGenericBeanDefinition。<span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [BeanDefinition](https://blog.csdn.net/xxssyyyyssxx/article/details/124819785)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

JellyfishMIX

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值