Spring5源码分析BeanDefinition详解

Z时代
2024-01-10
分类：综合
public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {
	/**
	 * Scope identifier for the standard singleton scope: "singleton".
	 * <p>Note that extended bean factories might support further scopes.
	 * @see #setScope
	 *
	 * 单例
	 */
	String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
	/**
	 * Scope identifier for the standard prototype scope: "prototype".
	 * <p>Note that extended bean factories might support further scopes.
	 * @see #setScope
	 *
	 * 多例
	 */
	String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;
	/**
	 * Role hint indicating that a {@code BeanDefinition} is a major part
	 * of the application. Typically corresponds to a user-defined bean.
	 */
	int ROLE_APPLICATION = 0;
	/**
	 * Role hint indicating that a {@code BeanDefinition} is a supporting
	 * part of some larger configuration, typically an outer
	 * {@link org.springframework.beans.factory.parsing.ComponentDefinition}.
	 * {@code SUPPORT} beans are considered important enough to be aware
	 * of when looking more closely at a particular
	 * {@link org.springframework.beans.factory.parsing.ComponentDefinition},
	 * but not when looking at the overall configuration of an application.
	 */
	int ROLE_SUPPORT = 1;
	/**
	 * Role hint indicating that a {@code BeanDefinition} is providing an
	 * entirely background role and has no relevance to the end-user. This hint is
	 * used when registering beans that are completely part of the internal workings
	 * of a {@link org.springframework.beans.factory.parsing.ComponentDefinition}.
	 */
	int ROLE_INFRASTRUCTURE = 2;
	// Modifiable attributes
	/**
	 * Set the name of the parent definition of this bean definition, if any.
	 *
	 * 期初理解是填的被集成类的名称，然而通过注解或者XML导入的方式都试过了，都没有设置这个值，
	 * 最后发现只有当通过XML（groovy没测试）导入的时候并且设置了<bean parent="parentName"></>才会真正设置parentName
	 * 这个值应该没什么用吧，找了一些也就是在MergeBeanDefinition的时候调用了getParentName，其他时候好像并没有
	 */
	void setParentName(@Nullable String parentName);
	/**
	 * Return the name of the parent definition of this bean definition, if any.
	 */
	@Nullable
	String getParentName();
	/**
	 * Specify the bean class name of this bean definition.
	 * <p>The class name can be modified during bean factory post-processing,
	 * typically replacing the original class name with a parsed variant of it.
	 * @see #setParentName
	 * @see #setFactoryBeanName
	 * @see #setFactoryMethodName
	 *
	 * 当前Bean的类名称，全路径名。该名称可以在自定义的BeanFactoryPostProcessor中进行修改
	 * 如果你愿意设置可以强转beanFactory为BeanDefinitionRegistry之后remove掉这个BeanName的BD
	 */
	void setBeanClassName(@Nullable String beanClassName);
	/**
	 * Return the current bean class name of this bean definition.
	 * <p>Note that this does not have to be the actual class name used at runtime, in
	 * case of a child definition overriding/inheriting the class name from its parent.
	 * Also, this may just be the class that a factory method is called on, or it may
	 * even be empty in case of a factory bean reference that a method is called on.
	 * Hence, do <i>not</i> consider this to be the definitive bean type at runtime but
	 * rather only use it for parsing purposes at the individual bean definition level.
	 * @see #getParentName()
	 * @see #getFactoryBeanName()
	 * @see #getFactoryMethodName()
	 */
	@Nullable
	String getBeanClassName();
	/**
	 * Override the target scope of this bean, specifying a new scope name.
	 * @see #SCOPE_SINGLETON
	 * @see #SCOPE_PROTOTYPE
	 *
	 * 设置单例还是原型（自己更愿意叫多例，实在不知道怎么去理解“原型” --！）
	 */
	void setScope(@Nullable String scope);
	/**
	 * Return the name of the current target scope for this bean,
	 * or {@code null} if not known yet.
	 */
	@Nullable
	String getScope();
	/**
	 * Set whether this bean should be lazily initialized.
	 * <p>If {@code false}, the bean will get instantiated on startup by bean
	 * factories that perform eager initialization of singletons.
	 * 设置Bean是否“懒加载”，如果是false，默认也是false，则在启动Spring容器的时候beanFactory就会初始化它
	 */
	void setLazyInit(boolean lazyInit);
	/**
	 * Return whether this bean should be lazily initialized, i.e. not
	 * eagerly instantiated on startup. Only applicable to a singleton bean.
	 */
	boolean isLazyInit();
	/**
	 * Set the names of the beans that this bean depends on being initialized.
	 * The bean factory will guarantee that these beans get initialized first.
	 *
	 * 设置当前Bean要依赖于@DependsOn的这些Bean都实例化之后才能进行实例化
	 */
	void setDependsOn(@Nullable String... dependsOn);
	/**
	 * Return the bean names that this bean depends on.
	 */
	@Nullable
	String[] getDependsOn();
	/**
	 * Set whether this bean is a candidate for getting autowired into some other bean.
	 * <p>Note that this flag is designed to only affect type-based autowiring.
	 * It does not affect explicit references by name, which will get resolved even
	 * if the specified bean is not marked as an autowire candidate. As a consequence,
	 * autowiring by name will nevertheless inject a bean if the name matches.
	 *
	 * 只有需要注入的Bean使用的by type注入，且autowireCandidate设置为true才会注入成功
	 * 测试一下自定义一个BeanFactoryPostProcessor把Dept的autowireCandidate设置为false，且使用by type注入是否成功
	 * --经过测试Dept的BeanDefinition的autowireCandidate=false确实会导致注入失败，有兴趣的可以试试
	 *
	 * @Component
	 * public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
	 *        @Override
	 *    public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
	 * 		BeanDefinition dept = beanFactory.getBeanDefinition("dept");
	 * 		dept.setAutowireCandidate(false);
	 *    }
	 * }
	 *
	 */
	void setAutowireCandidate(boolean autowireCandidate);
	/**
	 * Return whether this bean is a candidate for getting autowired into some other bean.
	 */
	boolean isAutowireCandidate();
	/**
	 * Set whether this bean is a primary autowire candidate.
	 * <p>If this value is {@code true} for exactly one bean among multiple
	 * matching candidates, it will serve as a tie-breaker.
	 *
	 * 设置当前的Bean是优先被注入的，比如同一个类型使用两个不同的beanName在Spring中存在两个对象，
	 * 那么被标记为primary=true的在根据by type注入的时候会优先被注入
	 */
	void setPrimary(boolean primary);
	/**
	 * Return whether this bean is a primary autowire candidate.
	 */
	boolean isPrimary();
	/**
	 * Specify the factory bean to use, if any.
	 * This the name of the bean to call the specified factory method on.
	 * @see #setFactoryMethodName
	 *
	 * 设置FactoryBean的名称  FactoryBean就是可以产生Spring Bean的Bean，通过beanName和&beanName分别得到Bean和FactoryBean实例
	 */
	void setFactoryBeanName(@Nullable String factoryBeanName);
	/**
	 * Return the factory bean name, if any.
	 */
	@Nullable
	String getFactoryBeanName();
	/**
	 * Specify a factory method, if any. This method will be invoked with
	 * constructor arguments, or with no arguments if none are specified.
	 * The method will be invoked on the specified factory bean, if any,
	 * or otherwise as a static method on the local bean class.
	 * @see #setFactoryBeanName
	 * @see #setBeanClassName
	 *
	 * 设置FactoryBeanMethod
	 */
	void setFactoryMethodName(@Nullable String factoryMethodName);
	/**
	 * Return a factory method, if any.
	 */
	@Nullable
	String getFactoryMethodName();
	/**
	 * Return the constructor argument values for this bean.
	 * <p>The returned instance can be modified during bean factory post-processing.
	 * @return the ConstructorArgumentValues object (never {@code null})
	 *
	 * 返回构造函数的参数，可以使用BeanFactoryPostProcessor修改参数
	 */
	ConstructorArgumentValues getConstructorArgumentValues();
	/**
	 * Return if there are constructor argument values defined for this bean.
	 * @since 5.0.2
	 */
	default boolean hasConstructorArgumentValues() {
		return !getConstructorArgumentValues().isEmpty();
	}
	/**
	 * Return the property values to be applied to a new instance of the bean.
	 * <p>The returned instance can be modified during bean factory post-processing.
	 * @return the MutablePropertyValues object (never {@code null})
	 * 返回Bean的属性对应的值，可以使用BeanFactoryPostProcessor修改这些值
	 */
	MutablePropertyValues getPropertyValues();
	/**
	 * Return if there are property values values defined for this bean.
	 * @since 5.0.2
	 */
	default boolean hasPropertyValues() {
		return !getPropertyValues().isEmpty();
	}
	/**
	 * Set the name of the initializer method.
	 * @since 5.1
	 *
	 * 当前Bean中添加一个初始化方法，再使用BeanFactoryPostProcessor设置它的BeanDefinition initMethodName
	 * Spring initMethod在BeanPostProcessor的postProcessBeforeInitialization之后，postProcessAfterInitialization之前被调用
	 */
	void setInitMethodName(@Nullable String initMethodName);
	/**
	 * Return the name of the initializer method.
	 * @since 5.1
	 */
	@Nullable
	String getInitMethodName();
	/**
	 * Set the name of the destroy method.
	 * @since 5.1
	 *
	 * 设置Bean被销毁时要执行的方法，可以做一些清理工作
	 */
	void setDestroyMethodName(@Nullable String destroyMethodName);
	/**
	 * Return the name of the destroy method.
	 * @since 5.1
	 */
	@Nullable
	String getDestroyMethodName();
	/**
	 * Set the role hint for this {@code BeanDefinition}. The role hint
	 * provides the frameworks as well as tools with an indication of
	 * the role and importance of a particular {@code BeanDefinition}.
	 * @since 5.1
	 * @see #ROLE_APPLICATION
	 * @see #ROLE_SUPPORT
	 * @see #ROLE_INFRASTRUCTURE
	 */
	void setRole(int role);
	/**
	 * Get the role hint for this {@code BeanDefinition}. The role hint
	 * provides the frameworks as well as tools with an indication of
	 * the role and importance of a particular {@code BeanDefinition}.
	 * @see #ROLE_APPLICATION
	 * @see #ROLE_SUPPORT
	 * @see #ROLE_INFRASTRUCTURE
	 */
	int getRole();
	/**
	 * Set a human-readable description of this bean definition.
	 * @since 5.1
	 */
	void setDescription(@Nullable String description);
	/**
	 * Return a human-readable description of this bean definition.
	 */
	@Nullable
	String getDescription();
	// Read-only attributes
	/**
	 * Return a resolvable type for this bean definition,
	 * based on the bean class or other specific metadata.
	 * <p>This is typically fully resolved on a runtime-merged bean definition
	 * but not necessarily on a configuration-time definition instance.
	 * @return the resolvable type (potentially {@link ResolvableType#NONE})
	 * @since 5.2
	 * @see ConfigurableBeanFactory#getMergedBeanDefinition
	 */
	ResolvableType getResolvableType();
	/**
	 * Return whether this a <b>Singleton</b>, with a single, shared instance
	 * returned on all calls.
	 * @see #SCOPE_SINGLETON
	 * 返回Bean是否是单例
	 */
	boolean isSingleton();
	/**
	 * Return whether this a <b>Prototype</b>, with an independent instance
	 * returned for each call.
	 * @since 3.0
	 * @see #SCOPE_PROTOTYPE
	 *
	 * 返回Bean是否是原型
	 */
	boolean isPrototype();
	/**
	 * Return whether this bean is "abstract", that is, not meant to be instantiated.
	 *
	 * 返回对象是否是抽象的，以为着不会被实例化。。。这有什么用喃？？？？
	 */
	boolean isAbstract();
	/**
	 * Return a description of the resource that this bean definition
	 * came from (for the purpose of showing context in case of errors).
	 */
	@Nullable
	String getResourceDescription();
	/**
	 * Return the originating BeanDefinition, or {@code null} if none.
	 * Allows for retrieving the decorated bean definition, if any.
	 * <p>Note that this method returns the immediate originator. Iterate through the
	 * originator chain to find the original BeanDefinition as defined by the user.
	 */
	@Nullable
	BeanDefinition getOriginatingBeanDefinition();
}