Spring系列之BeanDefinition

最新推荐文章于 2024-01-07 14:49:18 发布

小小小金鱼

最新推荐文章于 2024-01-07 14:49:18 发布

阅读量748

点赞数

分类专栏： spring 文章标签： java spring

本文链接：https://blog.csdn.net/zhao6406879/article/details/112785320

版权

spring 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

什么是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

小小小金鱼

关注

0
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Spring系列之BeanDefinition

什么是BeanDefinition官网解释直接看Spring的官网，在 Bean Overview处有关于BeanDefinition的介绍，具体如下图：翻译下大体意思为：springioc容器管理一个或多个bean。这些bean是使用提供给容器的配置元数据创建的。在容器本身中，这些bean定义表示为BeanDefinition对象，其中包含以下元数据：1、包限定类名：通常是所定义bean的实际实现类。2、Bean行为配置元素，它说明Bean在容器中的行为（范围、生命周期回调等）。3、对be
复制链接

扫一扫