Spring系列之BeanDefinition

什么是BeanDefinition

官网解释

直接看Spring的官网，在 Bean Overview处有关于BeanDefinition的介绍，具体如下图：

翻译下大体意思为：springioc容器管理一个或多个bean。这些bean是使用提供给容器的配置元数据创建的。
在容器本身中，这些bean定义表示为BeanDefinition对象，其中包含以下元数据：
1、包限定类名：通常是所定义bean的实际实现类。
2、Bean行为配置元素，它说明Bean在容器中的行为（范围、生命周期回调等）。
3、对bean执行其工作所需的其他bean的引用。这些引用也称为协作者或依赖项。
4、要在新创建的对象 - 中设置的其他配置设置，例如池的大小限制或要在管理连接池的bean中使用的连接数。

总结下：BeanDefinition的就是对Bean的信息进行描述，然后Spring会根据这个来创建对应的Bean。

思考

为何不直接用Class对象创建bean，而是用BeanDefinition来创建？
因为创建bean的过程中不止用到Class对象，还有其他很多属性，如bean的作用域、是否延迟加载、依赖其他Bean的名称等等。

BeanDefinition源码解读

直接上BeanDefinition 类源码

public interface BeanDefinition extends AttributeAccessor, BeanMetadataElement {//设置父BeanDefinition名称，创建bean之前存在父BeanDefinition会合并BeanDefinitionvoid setParentName(@Nullable String parentName);@NullableString getParentName();//设置bean的class名称void setBeanClassName(@Nullable String beanClassName);@NullableString getBeanClassName();//设置bean的作用域，常见的singleton/prototypevoid setScope(@Nullable String scope);@NullableString getScope();//设置是否延迟加载--延迟加载true时容器初始化时不会加载此bean，使用bean时才会加载void setLazyInit(boolean lazyInit);boolean isLazyInit();//设置依赖bean，bean加载时会判断时候有依赖别的bean，会先创建依赖的beanvoid setDependsOn(@Nullable String... dependsOn);@NullableString[] getDependsOn();//自动装配的候选的对象void setAutowireCandidate(boolean autowireCandidate);//是否是自动装配的候选对象boolean isAutowireCandidate();//设置主要的注入的对象void setPrimary(boolean primary);//获取是否主要的注入对象boolean isPrimary();//设置工厂Bean的名称void setFactoryBeanName(@Nullable String factoryBeanName);@NullableString getFactoryBeanName();//设置工厂方法的名称void setFactoryMethodName(@Nullable String factoryMethodName);@NullableString getFactoryMethodName();//获取构造器的参数的值ConstructorArgumentValues getConstructorArgumentValues();//是否构造器参数有值default boolean hasConstructorArgumentValues() {return !getConstructorArgumentValues().isEmpty();}//获取属性MutablePropertyValues getPropertyValues();default boolean hasPropertyValues() {return !getPropertyValues().isEmpty();}//设置初始化方法void setInitMethodName(@Nullable String initMethodName);@NullableString getInitMethodName();//设置销毁方法void setDestroyMethodName(@Nullable String destroyMethodName);@NullableString getDestroyMethodName();//设置bean描述void setDescription(@Nullable String description);@NullableString getDescription();//判断是否是单例boolean isSingleton();//判断是否是原型boolean isPrototype();//判断是否是抽象boolean isAbstract();//返回原始的BeanDefinition@NullableBeanDefinition getOriginatingBeanDefinition();
}

BeanClassName、Scope、isLazyInit、Description演示

@Component
@Scope("singleton")
@Description("这是一个bean的描述注解")
public class MyBean{
}

@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {BeanDefinition beanDefinition = beanFactory.getBeanDefinition("myBean");System.out.println("BeanClassName:" + beanDefinition.getBeanClassName());System.out.println("Scope:" + beanDefinition.getScope());System.out.println("isSingleton:" + beanDefinition.isSingleton());System.out.println("isLazyInit:" + beanDefinition.isLazyInit());System.out.println("Description:" + beanDefinition.getDescription());}
}

@Component
@ComponentScan
public class SpringApplicationContext {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringApplicationContext.class);context.close();}
}

接口实现BeanFactoryPostProcessor接口可获取BeanDefinition
运行结果如下：

表示我们可以获取BeanDefinition的基本信息（BeanFactoryPostProcessor的实现类可以获取修改BeanDefinition，但不可新增删除BeanDefinition）

parentName演示

parentName表示基础ParentBean和ChildBean，属性相同

public class ChildBean {private String name;private String age;public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}
}

public class ParentBean{private String name;private String age;public String getName() {return name;}public void setName(String name) {this.name = name;}public String getAge() {return age;}public void setAge(String age) {this.age = age;}
}

通过BeanDefinitionRegistryPostProcessor的实现类新增BeanDefinition

@Component
public class MyBeanDefinitionRegistryPostProcessor implements BeanDefinitionRegistryPostProcessor {@Overridepublic void postProcessBeanDefinitionRegistry(BeanDefinitionRegistry registry) throws BeansException {GenericBeanDefinition parentBeanDefinition = new GenericBeanDefinition();parentBeanDefinition.setBeanClass(ParentBean.class);//设置ParentBean类的name为parent、age为100属性Map<String, String> map = new HashMap<>();map.put("name", "parent");map.put("age", "100");parentBeanDefinition.setPropertyValues(new MutablePropertyValues(map));//parentBean注册到BeanDefinitionRegistry中registry.registerBeanDefinition("parentBean",parentBeanDefinition);GenericBeanDefinition childBeanDefinition = new GenericBeanDefinition();//设置父BeanDefinition的名称为parentBean//注意此处ChildBean没有设置任何属性childBeanDefinition.setParentName("parentBean");childBeanDefinition.setBeanClass(ChildBean.class);//childBean注册到BeanDefinitionRegistry中registry.registerBeanDefinition("childBean",childBeanDefinition);}@Overridepublic void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {}
}

最后看启动类和执行结果

@Component
@ComponentScan
public class SpringApplicationContext {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringApplicationContext.class);ChildBean childBean = context.getBean(ChildBean.class);System.out.println(childBean.getName());System.out.println(childBean.getAge());context.close();}
}

输出结果为name：parent，age：100，可知setParentName见效，创建bean之前合并了父BeanDefinition。
源码见AbstractBeanFactory.doGetBean()
–>getMergedLocalBeanDefinition()

DependsOn演示

A类注解@DependsOn（B类）表示A的依赖于B类，故在创建A类的bean对象前会先创建B类的bean对象。
上代码演示，举例发布和订阅对象，发布对象依赖于订阅对象，如果发布对象先创建会导致信息丢失。

@Component
@DependsOn("subscribeBean")
@Description("这是一个发布消息的bean")
public class PublishBean {public PublishBean() {System.out.println("PublishBean实例化");}
}

@Component
@Description("这是一个订阅消息的bean")
public class SubscribeBean {public SubscribeBean() {System.out.println("SubscribeBean实例化");}
}

最后看启动类

@Component
@ComponentScan
public class SpringApplicationContext {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringApplicationContext.class);context.close();}
}

运行结果：
从运行结果可知，先SubscribeBean先创建，PublishBean后，且运行多次结果相同。可能较真的同学觉得运气好，就是按照这个顺序创建的，我们看下DependsOn最核心的源码。

//获取BeanDefinition的DependsOn依赖
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {for (String dep : dependsOn) {//校验已注册if (isDependent(beanName, dep)) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");}//将依赖的bean写入内存中，表示已注册，用于上面isDependent判断registerDependentBean(dep, beanName);try {//获取bean，获取不到就会去创建beangetBean(dep);}catch (NoSuchBeanDefinitionException ex) {throw new BeanCreationException(mbd.getResourceDescription(), beanName,"'" + beanName + "' depends on missing bean '" + dep + "'", ex);}}
}

源码可知，创建bean之前会循环创建所有依赖的bean。

Primary演示

setPrimary：设置主要的注入的对象，意思当从容器中byType取bean对象时，容器中有两个或多个类型的bean，这时容器就不知道取哪个bean出来，便会报错。解决这个问题，可在某个bean上加@Primary注解，表示为主要的注入对象，此时会便会返回此对象。

错误演示：

public class PrimaryBean {
}

@Configuration
@Component
public class Config {@Beanpublic PrimaryBean primaryBeanA(){return new PrimaryBean();}@Beanpublic PrimaryBean primaryBeanB(){return new PrimaryBean();}
}

@Component
@ComponentScan
public class SpringApplicationContext {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(SpringApplicationContext.class);System.out.println(context.getBean(PrimaryBean.class));context.close();}
}

我们在Config类中声明两个PrimaryBean类型的bean，在启动类中取类型为PrimaryBean的bean，看运行结果：

看出此时抛NoUniqueBeanDefinitionException，大概意思发现了2个符合的bean，不知道返回哪个。

我们在Config类中的primaryBeanA方法上加@Primary注解

@Configuration
@Component
public class Config {@Bean@Primarypublic PrimaryBean primaryBeanA(){return new PrimaryBean();}@Beanpublic PrimaryBean primaryBeanB(){return new PrimaryBean();}
}

再次运行启动类，看运行结果：

可以看出，加上@Primary注解解决此问题，可以拿到bean对象。

BeanDefinition分类

搞清楚BeanDefinition的分类，需要看结构图，直接上图。

图上可以看出，相关的BeanDefinition实现类挺多的，我们挑重要的几个说明下。
首先看GenericBeanDefinition、RootBeanDefinition和ChildBeanDefinition。
从Spring 2.5开始，以编程方式注册Bean定义的首选方式是GenericBeanDefinition类，该类允许通过GenericBeanDefinition的setParentName方法动态定义父依赖项，示例见ParentName方法说明处。对于大多数用例，这有效地代替了RootBeanDefinition和ChildBeanDefinition类。也就是这个两个类是Spring早期的产物，现在完全可以用GenericBeanDefinition类替换。

继续看AnnotatedGenericBeanDefinition、ScannedGenericBeanDefinition、ConfigurationClassBeanDefinition类。

代码演示类型区别：

public class AService {
}

@Component
public class BService {
}

@Configuration
@ComponentScan
public class Config {@Beanpublic AService aService(){return new AService();}
}

public class SpringApplicationContext {public static void main(String[] args) {AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(Config.class);System.out.println("aService :" + context.getBeanDefinition("aService").getClass().getSimpleName());System.out.println("BService :" + context.getBeanDefinition("BService").getClass().getSimpleName());System.out.println("config :" + context.getBeanDefinition("config").getClass().getSimpleName());context.close();}
}

AService类通过@Configuration类下的@Bean方法创建
BService类直接注解@Component，启动扫描时创建
Config 类为@Configuration
执行结果入下：

总结：
@Configuration注解的被解析成AnnotatedGenericBeanDefinition
@Bean的注解被解析成ConfigurationClassBeanDefinition
@ComponentScan扫描的Bean被解析成ScannedGenericBeanDefinition