[Java知识库]Spring源码(一)-Bean的定义-BeanDefinition

BeanDefinition

在 Spring 容器中，我们广泛使用的是一个一个的 Bean，那在Spring中，我们可以如何去定义一个Bean?

• 标签

• @Bean注解

• @Component(@Service、@Controller)

还有就是可以通过BeanDefinition这个类。

比如，我们可以通过定义一个BeanDefinition对象来表示定义了一个Bean：

首先项目中添加 spring-context 依赖，如下：

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-context</artifactId>
    <version>5.2.6.RELEASE</version>
</dependency>

然后在创建User 类

public class User {
    private Long id;
    private String name;

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void init(){
		System.out.println("初始化");
	}
}

public static void main(String[] args) {
		// 定义了一个BeanDefinition
		AbstractBeanDefinition beanDefinition = BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
		// 当前Bean对象的类型
		beanDefinition.setBeanClass(User.class);
		// 将BeanDefinition注册到BeanFactory中
		DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();
		beanFactory.registerBeanDefinition("user", beanDefinition);
		// 获取Bean
		System.out.println(beanFactory.getBean("user"));
	}
结果：com.gongj.entity.User@70177ecd

我们还可以通过BeanDefinition设置一个Bean的其他属性

// 设置作用域
beanDefinition.setScope("prototype");
// 设置初始化方法
beanDefinition.setInitMethodName("init");
// 设置自动装配模型
beanDefinition.setAutowireMode(AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE); 
结果：
初始化
com.gongj.entity.User@1e88b3c

注：User类中需要添加初始化方法 init()

总之，我们通过，@Bean，@Component等方式所定义的Bean，最终都会被解析为BeanDefinition对象。要理解 BeanDefinition，我们从 BeanDefinition 的继承关系开始看起：

可以看到 BeanDefinition 是一个接口，继承自 BeanMetadataElement 和 AttributeAccessor 接口。

• AttributeAccessor：定义用于附加和访问元数据的通用协定的接口，可以是任意对象。具体的实现则是 AttributeAccessorSupport，采用 LinkedHashMap 进行存储。

public interface AttributeAccessor {
 
	//设置属性的值(名称唯一)
	void setAttribute(String name, Object value);
 
	//获得指定属性名称的值,如果不存在返回null
	Object getAttribute(String name);
 
	//删除指定的name的属性,如果不存在则返回null
	Object removeAttribute(String name);
 
      //判断指定的属性名称是否存在
	boolean hasAttribute(String name);
 
	//返回所有属性的名称
	String[] attributeNames();
}

• BeanMetadataElement：该接口只有一个方法 getSource，该方法返回 Bean 的来源。

这是 BeanDefinition 所继承的两个接口。接下来我们来看下 BeanDefinition本身：

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {

// 单例Bean还是原型Bean
 String SCOPE_SINGLETON = ConfigurableBeanFactory.SCOPE_SINGLETON;
 String SCOPE_PROTOTYPE = ConfigurableBeanFactory.SCOPE_PROTOTYPE;

// Bean角色
 int ROLE_APPLICATION = 0;  //用户自己定义的 Bean
 int ROLE_SUPPORT = 1;  //来源于配置文件的 Bean
 int ROLE_INFRASTRUCTURE = 2;//Spring 内部的 Bean

//配置 /获取父BeanDefinition的名称   XML中的 <bean parent="">
 void setParentName(@Nullable String parentName);
 @Nullable
 String getParentName();

//配置/获取 Bean 的 Class 全路径  XML 中的 <bean class="">
 void setBeanClassName(@Nullable String beanClassName);
 @Nullable
 String getBeanClassName();

//配置/获取  Bean 的作用域  XML中的 <bean scope=""> 配置。
 void setScope(@Nullable String scope);
 @Nullable
 String getScope();

//配置 / 获取 Bean 是否懒加载（默认都是立马加载）
// XML 中的 <bean lazy-init="">
 void setLazyInit(boolean lazyInit);
 boolean isLazyInit();

//配置/获取 Bean 的依赖对象  XML中的 <bean depends-on="">
 void setDependsOn(@Nullable String... dependsOn);
 @Nullable
 String[] getDependsOn();

//配置/获取 Bean 是否是自动装配的候选者  XML中的 <bean autowire-candidate="">
 void setAutowireCandidate(boolean autowireCandidate);
 boolean isAutowireCandidate();

//如果找到了多个可注入bean，那么则选择被Primary标记的bean/获取当
//前 Bean 是否为首选的 Bean  XML中的 <bean primary="">
 void setPrimary(boolean primary);
 boolean isPrimary();

// 配置/获取 FactoryBean 的名字  XML中的<bean factory-bean="">
 void setFactoryBeanName(@Nullable String factoryBeanName);
 @Nullable
 String getFactoryBeanName();

//配置/获取 FactoryMethod 的名字，可以是某个实例的方法（和factoryBean配合使用）
//也可以是静态方法。 XML 中的<bean factory-method=""> 
 void setFactoryMethodName(@Nullable String factoryMethodName);
 @Nullable
 String getFactoryMethodName();

//返回该 Bean 构造方法的参数值
 ConstructorArgumentValues getConstructorArgumentValues();

//判断 getConstructorArgumentValues 是否是空对象。
 default boolean hasConstructorArgumentValues() {
  return !getConstructorArgumentValues().isEmpty();
 }

//获取普通属性的集合
 MutablePropertyValues getPropertyValues();

//判断 getPropertyValues 是否为空对象
 default boolean hasPropertyValues() {
  return !getPropertyValues().isEmpty();
 }

// 配置/获取 Bean 的初始化方法 XML中的<bean init-method="">
 void setInitMethodName(@Nullable String initMethodName);
 @Nullable
 String getInitMethodName();

// 配置/获取 Bean 的销毁方法  XML中的<bean destroy-method="">
 void setDestroyMethodName(@Nullable String destroyMethodName);
 @Nullable
 String getDestroyMethodName();

//配置/获取 Bean的角色
 void setRole(int role);
 int getRole();

//配置/获取 Bean 的描述
 void setDescription(@Nullable String description);
 @Nullable
 String getDescription();

//用来解析一个Bean对应的类型上的各种信息，比如泛型
 ResolvableType getResolvableType();

//是否为单例
 boolean isSingleton();

// 是否为原型
 boolean isPrototype();

//是否抽象  XML 中的<bean abstract="true">
 boolean isAbstract();

//返回定义 Bean 的资源描述
 @Nullable
 String getResourceDescription();

// 如果当前 BeanDefinition 是一个代理对象，那么该方法可以用来返回原始的 BeanDefinition
 @Nullable
 BeanDefinition getOriginatingBeanDefinition();
}

BeanDefinition 实现类

BeanDefinition 是一个接口，它有多个实现类，这些实现类分别描述不同类型的 Bean。大致分为两种：

• 抽象实现：AbstractBeanDefinition
• 子接口：AnnotatedBeanDefinition

再来看一张继承关系图：

删除了一些无关的继承关系，最终形成了上面那副图。

抽象实现：AbstractBeanDefinition

AbstractBeanDefinition 是一个抽象类，BeanDefinition 中只是定义了一系列的 get/set 方法，并没有提供对应的属性，在 AbstractBeanDefinition 中将所有的属性定义出来了。该抽象类下有个三个子类：GenericBeanDefinition、RootBeanDefinition、ChildBeanDefinition。我们先来看 AbstractBeanDefinition本身的一些方法与属性。

public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
		implements BeanDefinition, Cloneable {

	//默认作用域名称的常量：等效于单例
	public static final String SCOPE_DEFAULT = "";

    //自动装配的一些常量
	// autowireMode  = 0，默认值，未激活Autowiring。
    // bean 标签的 autowire 属性值为 no
    // 1、在xml中需要手动指定依赖注入对象 配置 property标签或者 constructor-arg标签
    // 2、使用 @Autowired 注解，autowireMode 的值也是 0
	public static final int AUTOWIRE_NO = AutowireCapableBeanFactory.AUTOWIRE_NO;
	//autowireMode  = 1，根据set方法的的名称作为Bean名称进行依赖查找(去掉set，并尝试将首字母变为小写)，并将对象设置到该set方法的参数上
    // bean 标签的 autowire 属性值配置为 byName
    public static final int AUTOWIRE_BY_NAME = AutowireCapableBeanFactory.AUTOWIRE_BY_NAME;
    //autowireMode  = 2，根据set方法参数的类型作为Bean类型进行依赖查找，并将对象设置到该set方法的参数上
    // bean 标签的 autowire 属性值配置为 byType
    public static final int AUTOWIRE_BY_TYPE = AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE;
    //autowireMode  = 3，构造器注入
    // bean 标签的 autowire 属性值配置为 constructor
	public static final int AUTOWIRE_CONSTRUCTOR = AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR;
	//表明通过Bean的class的内部来自动装配 Spring3.0被弃用。
    // bean 标签的 autowire 属性值配置为 autodetect
	@Deprecated
	public static final int AUTOWIRE_AUTODETECT = AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT;

	//检查依赖是否合法，在本类中，默认不进行依赖检查
	//不进行检查
	public static final int DEPENDENCY_CHECK_NONE = 0;
	//对对象引用进行依赖性检查
	public static final int DEPENDENCY_CHECK_OBJECTS = 1;
	//对“简单”属性进行依赖性检查
	public static final int DEPENDENCY_CHECK_SIMPLE = 2;
	//对所有属性进行依赖检查
	public static final int DEPENDENCY_CHECK_ALL = 3;

	//若Bean未指定销毁方法，容器应该尝试推断Bean的销毁方法的名字，
	//目前，推断的销毁方法的名字一般为close或是shutdown
	public static final String INFER_METHOD = "(inferred)";

	//Bean的class对象或是类的全限定名
	@Nullable
	private volatile Object beanClass;

	//默认的scope是单例,对应bean属性scope
	//@Scope
	@Nullable
	private String scope = SCOPE_DEFAULT;

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

	//是否懒加载，对应bean属性lazy-init,默认不是懒加载
	//@Lazy
	@Nullable
	private Boolean lazyInit;

	//自动注入模式，对应bean属性autowire,默认不进行自动装配
	private int autowireMode = AUTOWIRE_NO;

	//是否进行依赖检查,默认不进行依赖检查
	private int dependencyCheck = DEPENDENCY_CHECK_NONE;

	//用来表示一个bean的实例化是否依靠另一个bean的实例化，先加载dependsOn的bean，
	//对应bean属性depend-on
	//@DependsOn
	@Nullable
	private String[] dependsOn;

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

	/**
	 * 自动装配时出现多个bean候选者时，将作为首选者，对应bean属性primary，默认不是首选的
	 * @Primary
	 */
	private boolean primary = false;
	/**
	 * 用于记录Qualifier，对应子元素qualifier <bean><qualifier></qualifier></bean>
	 * 如果容器中有多个相同类型的 bean,这时我们就可以使用qualifier属性来设置加载指定Bean名称的bean
	 * @Qualifier
	 */
	private final Map<String, AutowireCandidateQualifier> qualifiers = new LinkedHashMap<>();

  //java8的函数式接口，创建bean实例的方式之一
	@Nullable
	private Supplier<?> instanceSupplier;

	//是否允许访问非public方法和属性, 默认是true
	private boolean nonPublicAccessAllowed = true;

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

	//工厂类名,对应bean属性factory-bean
	@Nullable
	private String factoryBeanName;

	//工厂方法名,对应bean属性factory-method
	@Nullable
	private String factoryMethodName;

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

	//Bean属性的名称以及对应的值，这里不会存放构造函数相关的参数值，只会存放通过setter注入的依赖
	@Nullable
	private MutablePropertyValues propertyValues;

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

	//初始化方法，对应bean属性init-method
	@Nullable
	private String initMethodName;

	//销毁方法，对应bean属性destroy-method
	@Nullable
	private String destroyMethodName;

	//是否执行init-method,默认为true
	private boolean enforceInitMethod = true;

	//是否执行destroy-method,默认为true
	private boolean enforceDestroyMethod = true;

	//是否是用户定义的而不是应用程序本身定义的，创建AOP时候为true
	private boolean synthetic = false;

	//Bean的角色，为用户自定义Bean
	private int role = BeanDefinition.ROLE_APPLICATION;

	//Bean的描述信息
	@Nullable
	private String description;

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

RootBeanDefinition

这是一个最常用的实现类，Spirng 去创建 Bean 时是基于RootBeanDefinition去创建的！RootBeanDefinition继承了AbstractBeanDefinition，在AbstractBeanDefinition的基础上扩展了一些之外的功能,并且RootBeanDefinition是没有父BeanDefinition的。

public class RootBeanDefinition extends AbstractBeanDefinition {

	// BeanDefinitionHolder 存储 Bean 的名称、别名、BeanDefinition
	@Nullable
	private BeanDefinitionHolder decoratedDefinition;

	// AnnotatedElement 是java反射包的接口，通过它可以查看 Bean 的注解信息
	@Nullable
	private AnnotatedElement qualifiedElement;

	// 决定了什么时候 BeanDefinition 需要重新合并
	volatile boolean stale;

	// 允许缓存
	boolean allowCaching = true;

	// 工厂方法是否唯一
	boolean isFactoryMethodUnique = false;

	//封装了 java.lang.reflect.Type，提供了泛型相关的操作
	@Nullable
	volatile ResolvableType targetType;

	//用于缓存给定bean定义中确定的类
	// 表示 RootBeanDefinition 存储哪个类的信息
	@Nullable
	volatile Class<?> resolvedTargetType;

	//如果bean是FactoryBean，则用于缓存
	@Nullable
	volatile Boolean isFactoryBean;

	//用于缓存泛型类型工厂方法的返回类型
	@Nullable
	volatile ResolvableType factoryMethodReturnType;

	//用于缓存唯一的工厂方法
	@Nullable
	volatile Method factoryMethodToIntrospect;

	//下面四个构造函数字段的公共锁
	final Object constructorArgumentLock = new Object();
	// 用用于缓存已解析的构造函数或工厂方法
	@Nullable
	Executable resolvedConstructorOrFactoryMethod;
	//将构造函数参数标记为已解析
	boolean constructorArgumentsResolved = false;
	//用于缓存完全解析的构造函数参数
	@Nullable
	Object[] resolvedConstructorArguments;
	//用于缓存部分准备好的构造函数参数
	@Nullable
	Object[] preparedConstructorArguments;

	//下面两个后处理字段的通用锁
	final Object postProcessingLock = new Object();

	//这表明已经应用了MergedBeanDefinitionPostProcessor
	boolean postProcessed = false;

	//表明一个实例化前的后处理器已经启动
	@Nullable
	volatile Boolean beforeInstantiationResolved;

	//实际缓存的类型是 Constructor、Field、Method 类型
	@Nullable
	private Set<Member> externallyManagedConfigMembers;

	// InitializingBean中 的 init 回调函数名 afterPropertiesSet 会在这里记录，以便进行生命周期回调
	@Nullable
	private Set<String> externallyManagedInitMethods;

	// DisposableBean 的 destroy 回调函数名 destroy 会在这里记录，以便进生命周期回调
	@Nullable
	private Set<String> externallyManagedDestroyMethods;

    //===========贴一个方法
	// 很明显，RootBeanDefiniiton是没有父BeanDefinition
	@Override
	public String getParentName() {
		return null;
	}
 // 并且还不能进行set
	@Override
	public void setParentName(@Nullable String parentName) {
		if (parentName != null) {
			throw new IllegalArgumentException("Root bean cannot be changed into a child bean with parent reference");
		}
	}
}

实践

复用开篇就用到的 User类，不过在其中添加toString方法。

public static void main(String[] args) {
          //容器
		DefaultListableBeanFactory context = new DefaultListableBeanFactory();
		//属性的集合  在其父类 AbstractBeanDefinition 已经提到过了
		MutablePropertyValues mpvs = new MutablePropertyValues();
		mpvs.add("id",4L);
		mpvs.add("name","gongj");
		//BeanDefinition
		RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(User.class,null,mpvs);
		//注册到Spring容器中
		context.registerBeanDefinition("user",rootBeanDefinition);
		User user = (User)context.getBean("user");
		System.out.println(user);
	}

结果：User{id=4, name='gongj'}

ChildBeanDefinition

该类继承自 AbstractBeanDefinition。其相当于一个子类，不可以单独存在，必须依赖一个父 BeanDetintion，构造 ChildBeanDefinition 时，通过构造方法传入父 BeanDetintion 的名称或通过 setParentName 设置父名称。它可以从父类继承方法参数、属性值，并可以重写父类的方法，同时也可以增加新的属性或者方法。

从 Spring 2.5 开始，以编程方式注册 Bean 定义的首选方法是 GenericBeanDefinition，GenericBeanDefinition 可以有效替代 ChildBeanDefinition 的绝大分部使用场合。

实践

新建一个 Person 类，Person 类在 User 类的基础上增加一个 address属性。

public class Person {

	private Long id;
	private String name;
	private String address;

	public Long getId() {
		return id;
	}

	public void setId(Long id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getAddress() {
		return address;
	}

	public void setAddress(String address) {
		this.address = address;
	}

	@Override
	public String toString() {
		return "Person{" +
				"id=" + id +
				", name='" + name + '\'' +
				", address='" + address + '\'' +
				'}';
	}
}

启动

public static void main(String[] args) {
		//容器
		DefaultListableBeanFactory context = new DefaultListableBeanFactory();
		//普通属性的集合  在其父类 AbstractBeanDefinition 已经提到过了
		MutablePropertyValues mpvs = new MutablePropertyValues();
		mpvs.add("id",4L);
		mpvs.add("name","gongj");
		//BeanDefinition
		RootBeanDefinition rootBeanDefinition = new RootBeanDefinition(User.class,null,mpvs);
		//注册到Spring容器中
		context.registerBeanDefinition("user",rootBeanDefinition);

		// ChildBeanDefinition 开始
		MutablePropertyValues childValues = new MutablePropertyValues();
		childValues.add("address","上海市");
		//通过构造方法传入父 BeanDetintion 的名称
		ChildBeanDefinition childBeanDefinition  = new ChildBeanDefinition("user", Person.class,null,childValues);
		//注册
		context.registerBeanDefinition("person", childBeanDefinition);

		User user = context.getBean(User.class);
		Person person = context.getBean(Person.class);
		System.out.println("user = " + user);
		System.out.println("person = " + person);
	}

结果：
user = User{id=4, name='gongj'}
person = Person{id=4, name='gongj', address='上海市'}

GenericBeanDefinition

GenericBeanDefinition 是从 Spring2.5 以后新加入的 bean 文件配置属性定义类，是一站式服务类。GenericBeanDefinition 可以动态设置父 Bean，同时兼具 RootBeanDefinition 和 ChildBeanDefinition 的功能。

GenericBeanDefinition 的实现比较简单，在 AbstractBeanDefinition 的基础上只增加了parentName的功能，其余的实现都在父类 AbstractBeanDefinition 里。
注：若你是xml配置，会解析所有属性并统一封装至 GenericBeanDefinition 类型的实例中，之后再逐渐解析的。

实践

public static void main(String[] args) {
	//容器
	DefaultListableBeanFactory ctx = new DefaultListableBeanFactory();
	//普通属性的集合  在其父类 AbstractBeanDefinition 已经提到过了
	MutablePropertyValues mpvs = new MutablePropertyValues();
	mpvs.add("id",4L);
	mpvs.add("name","gongj");
	GenericBeanDefinition parentGenericBeanDefinition = new GenericBeanDefinition();
	parentGenericBeanDefinition.setBeanClass(User.class);
	parentGenericBeanDefinition.setPropertyValues(mpvs);
	//注册到Spring容器中
	ctx.registerBeanDefinition("user",parentGenericBeanDefinition);

	GenericBeanDefinition childGenericBeanDefinition = new GenericBeanDefinition();
	//设置父BeanDefinition的名称
	childGenericBeanDefinition.setParentName("user");
	childGenericBeanDefinition.setBeanClass(Person.class);
	childGenericBeanDefinition.getPropertyValues().add("address", "上海市");
	//注册到Spring容器中
	ctx.registerBeanDefinition("person", childGenericBeanDefinition);
	User user = ctx.getBean(User.class);
	Person person = ctx.getBean(Person.class);
	System.out.println("user = " + user);
	System.out.println("person = " + person);
}
结果：
user = User{id=4, name='gongj'}
person = Person{id=4, name='gongj', address='上海市'}

子接口：AnnotatedBeanDefinition

//关于其bean类-无需加载该类。
public interface AnnotatedBeanDefinition extends BeanDefinition {
    //获取此bean定义注解的元数据
	AnnotationMetadata getMetadata();

//获取此bean定义的工厂方法的元数据,如果没有，则为null
	@Nullable
	MethodMetadata getFactoryMethodMetadata();
}

该接口可以返回两个元数据的类：

• AnnotationMetadata：主要对 Bean 的注解信息进行操作，如：获取当前 Bean 标注的所有注解、判断是否包含指定注解。

public interface AnnotationMetadata extends ClassMetadata, AnnotatedTypeMetadata {

	//获取所有注解完全限定类名
	default Set<String> getAnnotationTypes() {
		return getAnnotations().stream()
				.filter(MergedAnnotation::isDirectlyPresent)
				.map(annotation -> annotation.getType().getName())
				.collect(Collectors.toCollection(LinkedHashSet::new));
	}

	//获得annottationName对应的元注解的类全限定名
	default Set<String> getMetaAnnotationTypes(String annotationName) {
		MergedAnnotation<?> annotation = getAnnotations().get(annotationName, MergedAnnotation::isDirectlyPresent);
		if (!annotation.isPresent()) {
			return Collections.emptySet();
		}
		return MergedAnnotations.from(annotation.getType(), SearchStrategy.INHERITED_ANNOTATIONS).stream()
				.map(mergedAnnotation -> mergedAnnotation.getType().getName())
				.collect(Collectors.toCollection(LinkedHashSet::new));
	}

	//是否包含指定注解 
	default boolean hasAnnotation(String annotationName) {
		return getAnnotations().isDirectlyPresent(annotationName);
	}

	//确定是否含有某个元注解
	default boolean hasMetaAnnotation(String metaAnnotationName) {
		return getAnnotations().get(metaAnnotationName,
				MergedAnnotation::isMetaPresent).isPresent();
	}

	//类里面只要有一个方法标注有指定注解，就返回true
	default boolean hasAnnotatedMethods(String annotationName) {
		return !getAnnotatedMethods(annotationName).isEmpty();
	}
      // 返回所有的标注有指定注解的方法元信息
	Set<MethodMetadata> getAnnotatedMethods(String annotationName);

	//工厂方法来使用标准反射为给定的类创建一个新的AnnotationMetadata实例
	static AnnotationMetadata introspect(Class<?> type) {
		return StandardAnnotationMetadata.from(type);
	}
}

• MethodMetadata：方法的元数据类。提供获取方法名称、此方法所属类的全类名、是否是抽象方法、判断是否是静态方法、判断是否是final方法等。

public interface MethodMetadata extends AnnotatedTypeMetadata {

	//返回方法的名字
	String getMethodName();

	//返回该方法所属的类的全限定名
	String getDeclaringClassName();

	//返回该方法返回类型的全限定名
	String getReturnTypeName();

	//方法是否是有效的抽象方法:即在类上标记为抽象的或声明为规则的，
	//接口中的非默认方法。
	boolean isAbstract();

	//方法是否声明为'static'。
	boolean isStatic();

	//方法是否标记为'final'。
	boolean isFinal();

	//方法是否可重写:即没有标记为static、final或private。
	boolean isOverridable();

}

该接口下有三大子类： ScannedGenericBeanDefinition、ConfigurationClassBeanDefinition、AnnotatedGenericBeanDefinition

ScannedGenericBeanDefinition

实现了 AnnotatedBeanDefinition 也继承了 GenericBeanDefinition。这个 BeanDefinition 用来描述标注@Component、@Service、@Controller等注解标记的类会解析为ScannedGenericBeanDefinition。

它的源码很简单，就是多了一个属性：metadata 用来存储扫描进来的Bean的一些注解信息。

public class ScannedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition {

	private final AnnotationMetadata metadata;

    /**
	 * 鉴于MetadataReader描述,为类创建一个新的ScannedGenericBeanDefinition
	 */
	public ScannedGenericBeanDefinition(MetadataReader metadataReader) {
		Assert.notNull(metadataReader, "MetadataReader must not be null");
		this.metadata = metadataReader.getAnnotationMetadata();
		setBeanClassName(this.metadata.getClassName());
	}


	@Override
	public final AnnotationMetadata getMetadata() {
		return this.metadata;
	}

	@Override
	@Nullable
	public MethodMetadata getFactoryMethodMetadata() {
		return null;
	}
}

验证

@Component、@Service、@Controller等注解标记的类是否会解析为 ScannedGenericBeanDefinition

新建 AppConfig 类

@ComponentScan("com.gongj")
public class AppConfig {

}

然后再创建HelloController 类

@Controller
public class HelloController {
}

启动

public static void main(String[] args) {
	AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
	BeanDefinition helloController = context.getBeanFactory().getBeanDefinition("helloController");
}

AnnotatedGenericBeanDefinition

该类继承自 GenericBeanDefinition ，并实现了AnnotatedBeanDefinition 接口。这个 BeanDefinition 用来描述标注使用了@Configuration 注解标记配置类会解析为 AnnotatedGenericBeanDefinition。

public class AnnotatedGenericBeanDefinition extends GenericBeanDefinition implements AnnotatedBeanDefinition {

	// 注解元数据
	private final AnnotationMetadata metadata;

	@Nullable
	private MethodMetadata factoryMethodMetadata;


	/**
	 * 为给定的bean类创建一个新的AnnotatedGenericBeanDefinition
	 * @param beanClass the loaded bean class:加载的bean类
	 */
	public AnnotatedGenericBeanDefinition(Class<?> beanClass) {
		setBeanClass(beanClass);
		// 当前类上有哪些注解
		this.metadata = AnnotationMetadata.introspect(beanClass);
	}

	/**
	 * 
	 * 为给定的注释元数据创建一个新AnnotatedGenericBeanDefinition,传入AnnotationMetadata
	 */
	public AnnotatedGenericBeanDefinition(AnnotationMetadata metadata) {
		Assert.notNull(metadata, "AnnotationMetadata must not be null");
		if (metadata instanceof StandardAnnotationMetadata) {
			setBeanClass(((StandardAnnotationMetadata) metadata).getIntrospectedClass());
		}
		else {
			setBeanClassName(metadata.getClassName());
		}
		this.metadata = metadata;
	}

	/**
	 * 
	 * 基于一个带注解的类和该类上的工厂方法。，为给定的注释元数据创建一个新的AnnotatedGenericBeanDefinition，
	 */
	public AnnotatedGenericBeanDefinition(AnnotationMetadata metadata, MethodMetadata factoryMethodMetadata) {
		this(metadata);
		Assert.notNull(factoryMethodMetadata, "MethodMetadata must not be null");
		setFactoryMethodName(factoryMethodMetadata.getMethodName());
		this.factoryMethodMetadata = factoryMethodMetadata;
	}


	@Override
	public final AnnotationMetadata getMetadata() {
		return this.metadata;
	}

	@Override
	@Nullable
	public final MethodMetadata getFactoryMethodMetadata() {
		return this.factoryMethodMetadata;
	}

}

验证

新建 MyConfig 类

@Configuration
public class MyConfig {

}

启动

public static void main(String[] args) {
		AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
		BeanDefinition myConfig = context.getBeanFactory().getBeanDefinition("myConfig");
	}

如果使用 AppConfig作为扫描包，MyConfig 的实际类型是 ScannedGenericBeanDefinition，当然这个与启动有关，后面的博文再说。

AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
		BeanDefinition myConfig = context.getBeanFactory().getBeanDefinition("myConfig");

ConfigurationClassBeanDefinition

它是ConfigurationClassBeanDefinitionReader的一个私有的静态内部类：这个类负责将@Bean注解的方法转换为对应的ConfigurationClassBeanDefinition 类，源码就不过多解释了，和之前几个BeanDefinition差不多。

其功能特点如下：

• 1、如果 @Bean 注解没有指定 Bean 的名字，默认会用方法的名字作为Bean的名称。

• 2、标注 @Configuration、@Component、@Service注解的类会成为一个工厂类，而标注 @Bean 注解的方法会成为工厂方法，通过工厂方法实例化 Bean。

  验证

  在MyConfig 类中新增方法：

@Bean("mz")
	public User myUserBean(){
		return new User();
	}

启动

public static void main(String[] args) {
	AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(MyConfig.class);
	BeanDefinition mz = context.getBeanFactory().getBeanDefinition("mz");
	User myUserBean = (User)context.getBean("mz");
	System.out.println("mz =" + mz);
	System.out.println("myUserBean = " + myUserBean);
}

spring初始化时，会用GenericBeanDefinition或是ConfigurationClassBeanDefinition（用@Bean注解注释的类）存储用户自定义的Bean，在初始化Bean时，又会将其转换为RootBeanDefinition。

参考文献：
松哥：Spring 源码第四弹！深入理解 BeanDefinition

大佬：Spring IoC容器中核心定义之------BeanDefinition深入分析（RootBeanDefinition、ChildBeanDefinition）

大佬：Spring（四）核心容器 - BeanDefinition 解析

大佬：Spring元数据Metadata的使用