什么是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会合并BeanDefinition
void setParentName(@Nullable String parentName);
@Nullable
String getParentName();
//设置bean的class名称
void setBeanClassName(@Nullable String beanClassName);
@Nullable
String getBeanClassName();
//设置bean的作用域，常见的singleton/prototype
void setScope(@Nullable String scope);
@Nullable
String getScope();
//设置是否延迟加载--延迟加载true时容器初始化时不会加载此bean，使用bean时才会加载
void setLazyInit(boolean lazyInit);
boolean isLazyInit();
//设置依赖bean，bean加载时会判断时候有依赖别的bean，会先创建依赖的bean
void setDependsOn(@Nullable String... dependsOn);
@Nullable
String[] getDependsOn();
//自动装配的候选的对象
void setAutowireCandidate(boolean autowireCandidate);
//是否是自动装配的候选对象
boolean isAutowireCandidate();
//设置主要的注入的对象
void setPrimary(boolean primary);
//获取是否主要的注入对象
boolean isPrimary();
//设置工厂Bean的名称
void setFactoryBeanName(@Nullable String factoryBeanName);
@Nullable
String getFactoryBeanName();
//设置工厂方法的名称
void setFactoryMethodName(@Nullable String factoryMethodName);
@Nullable
String getFactoryMethodName();
//获取构造器的参数的值
ConstructorArgumentValues getConstructorArgumentValues();
//是否构造器参数有值
default boolean hasConstructorArgumentValues() {
return !getConstructorArgumentValues().isEmpty();
}
//获取属性
MutablePropertyValues getPropertyValues();
default boolean hasPropertyValues() {
return !getPropertyValues().isEmpty();
}
//设置初始化方法
void setInitMethodName(@Nullable String initMethodName);
@Nullable
String getInitMethodName();
//设置销毁方法
void setDestroyMethodName(@Nullable String destroyMethodName);
@Nullable
String getDestroyMethodName();
//设置bean描述
void setDescription(@Nullable String description);
@Nullable
String getDescription();
//判断是否是单例
boolean isSingleton();
//判断是否是原型
boolean isPrototype();
//判断是否是抽象
boolean isAbstract();
//返回原始的BeanDefinition
@Nullable
BeanDefinition getOriginatingBeanDefinition();
}
BeanClassName、Scope、isLazyInit、Description演示
@Component
@Scope("singleton")
@Description("这是一个bean的描述注解")
public class MyBean{
}
@Component
public class MyBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
@Override
public 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 {
@Override
public 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);
}
@Override
public 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，获取不到就会去创建bean
getBean(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 {
@Bean
public PrimaryBean primaryBeanA(){
return new PrimaryBean();
}
@Bean
public 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
@Primary
public PrimaryBean primaryBeanA(){
return new PrimaryBean();
}
@Bean
public 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 {
@Bean
public 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
扫一扫
509
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
