183°

Spring5源码分析-BeanDefinition详解

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();

}

 BeanDefinition是Spring描述一个Bean的包装类,Spring后面的操作都依赖于解析对应Bean的属性做出相应的动作执行,完成我们所感受到的功能

比如Bean是否单例,是否延迟加载,是否是Primary Bean,是否有DependsOn的条件,是否允许被用于自动注入,是否有INIT方法等等,Spring解析到这些内容都会做出对应的响应。

本文由【特拉仔】发布于开源中国,原文链接:https://my.oschina.net/u/3049601/blog/3127635

全部评论: 0

    我有话说: