使用 BeanDefinition 描述 Spring Bean

什麼是BeanDefinition

在Java中，一切皆對象。在JDK中使用java.lang.Class來描述類這個對象。

在Spring中，存在bean這樣一個概念，那Spring又是怎麼抽象bean這個概念，用什麼類來描述bean這個對象呢？Spring使用BeanDefinition來描述bean。

BeanDefinition

BeanDefinition繼承了AttributeAccessor和BeanMetadataElement接口。在Spring中充斥着大量的各類接口，每種接口都擁有不一樣的能力，某個類實現了某個接口，也就相應的擁有了某種能力。

AttributeAccessor

顧名思義，這是一個屬性訪問者，它提供了訪問屬性的能力。

BeanMetadataElement

BeanMetadataElement中只有一個方法，用來獲取元數據元素的配置源對象：

public interface BeanMetadataElement {
	@Nullable
	Object getSource();
}
複製代碼

BeanDefinition

BeanDefinition接口是Spring對bean的抽象。

咱們能夠從源碼中能夠看出，Spring是怎麼描述一個bean：

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. */
	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 */
	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. */
	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. */
	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. */
	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. */
	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 */
	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 */
	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}) */
	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}) */
	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 */
	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 */
	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}. * * @see #ROLE_APPLICATION * @see #ROLE_SUPPORT * @see #ROLE_INFRASTRUCTURE * @since 5.1 */
	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 whether this a <b>Singleton</b>, with a single, shared instance * returned on all calls. * * @see #SCOPE_SINGLETON */
	boolean isSingleton();

	/** * Return whether this a <b>Prototype</b>, with an independent instance * returned for each call. * * @see #SCOPE_PROTOTYPE * @since 3.0 */
	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();
}
複製代碼

AnnotatedBeanDefinition

AnnotatedBeanDefinition 繼承了BeanDefinition，拓展了BeanDefinition接口的能力：

BeanDefinition常見實現類

• ChildBeanDefinition
• RootBeanDefinition
• GenericBeanDefinition
• AnnotatedGenericBeanDefinition
• ScannedGenericBeanDefinition

BeanDefinitionBuilder

BeanDefinitionBuilder是Builder模式的應用。經過這個類咱們能夠方便的構建BeanDefinition的實例對象。舉個例子：

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {

	@Override
	public void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {
		BeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition(OrderService.class)
				//這裏的屬性名是根據setter方法
				.addPropertyReference("dao", "orderDao")
				.setInitMethodName("init")
				.setScope(BeanDefinition.SCOPE_SINGLETON)
				.getBeanDefinition();

		registry.registerBeanDefinition("orderService", beanDefinition);

	}

	@Override
	public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
		//do nothing
	}
}
複製代碼

關於BeanDefinitionRegistryPostProcessor，這裏先簡單介紹一下，詳細的咱們後面再說。

BeanDefinitionRegistryPostProcessor繼承了BeanFactoryPostProcessor接口，同時又增長了一個新的方法BeanDefinitionRegistryPostProcessor#postProcessBeanDefinitionRegistry，該方法容許程序員經過代碼編碼的方式手動往程序中註冊BeanDefinition。

實例中的具體程序已上傳到github：github.com/shenjianeng…

---

歡迎各位關注公衆號，你們一塊兒學習成長。