BeanDefinition概念

BeanDefinition是Spring框架中定义Bean的配置元信息接口, 包含:

  • Bean类名
  • Bean行为配置元素, 如作用域, 自动绑定的模式, 生命周期回调等
  • 其他Bean引用, 又可称作合作者(Collaborators)或者依赖(Dependencies)
  • 配置设置, 比如Bean属性(Properties)

image.png

BeanDefinition构建

  • 通过BeanDefinitionBuilder

  • 通过AbstractBeanDefinition以及派生类 ```java public class BeanDefinitionCreationDemo {

    public static void main(String[] args) {

    1.   // 1. 通过BeanDefinitionBuilder构建
    2.   BeanDefinitionBuilder beanDefinitionBuilder = BeanDefinitionBuilder.genericBeanDefinition(User.class);
    3.   // 设置属性
    4.   beanDefinitionBuilder.addPropertyValue("age", 18);
    5.   beanDefinitionBuilder.addPropertyValue("name", "erha");
    6.   // 获取实例, 其中beanDefinition并非终态, 还可以自定义修改
    7.   BeanDefinition beanDefinition = beanDefinitionBuilder.getBeanDefinition();
    9.   // 2. 通过AbstractBeanDefinition构建
    10.   GenericBeanDefinition genericBeanDefinition = new GenericBeanDefinition();
    11.   genericBeanDefinition.setBeanClass(User.class);
    12.   // 设置属性
    13.   MutablePropertyValues propertyValues = new MutablePropertyValues();

    // propertyValues.addPropertyValue(“age”,18); // propertyValues.addPropertyValue(“name”,”erha”);

    1.   propertyValues.add("age", 17).add("name", "sansha");
    2.   genericBeanDefinition.setPropertyValues(propertyValues);

    }

}

  2. <a name="AuFW3"></a>
  3. ## 命名SpringBean
  4. 每个Bean拥有一个或多个标识符(identifiers), 这些标识符在Bean所在的容器必须是唯一的.<br />通常, 一个Bean仅有一个标识符, 如果需要额外的, 可用别名来扩充.
  6. - 基于xml配置时, 可用id/name属性来规定Bean的标识符. 命名官方推荐驼峰
  7. - 如果未指定, 容器为Bean自动生成一个唯一的名称(BeanNameGenerator)
  9. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/281275/1616937478707-8565ea10-fd07-4bda-aace-bda240e0012f.png#align=left&display=inline&height=147&margin=%5Bobject%20Object%5D&name=image.png&originHeight=147&originWidth=581&size=7067&status=done&style=none&width=581)
  11. **Bean的别名**
  13. - 复用现有的BeanDefinition
  14. - 更具有场景化的命名方法
  15. ```xml
  16. <?xml version="1.0" encoding="UTF-8"?>
  17. <beans
  18.         xmlns="http://www.springframework.org/schema/beans"
  19.         xmlns:context="http://www.springframework.org/schema/context"
  20.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  21.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  22.         https://www.springframework.org/schema/beans/spring-beans.xsd
  23.         http://www.springframework.org/schema/context
  24.         https://www.springframework.org/schema/context/spring-context.xsd">
  26.     <import resource="classpath:/META-INF/dependency-lookup-context.xml"/>
  28.     <!--建立别名-->
  29.     <alias name="user" alias="zhangsan-user"/>
  30. </beans>
  1. public class BeanAliasDemo {
  3.     public static void main(String[] args) {
  4.         // 配置XML配置文件, 启动Spring应用上下文
  5.         BeanFactory beanFactory = new ClassPathXmlApplicationContext(
  6.                 "classpath:META-INF/bean-definition-context.xml");
  7.         User aliaUser = beanFactory.getBean("zhangsan-user", User.class);
  8.         User user = beanFactory.getBean("user", User.class);
  9.         System.out.println(user == aliaUser);//true
  10.     }
  12. }

注册SpringBean

image.png

  1. @Import(AnnotationBeanDefinitionDemo.Config.class)  // 3. 通过 @Import进行导入
  2. public class AnnotationBeanDefinitionDemo {
  4.     public static void main(String[] args) {
  5.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  7.         // 1. 通过 @Bean方式定义, 注意, 注解尽管多种方式, 但是不会重复注册, API会多次注册
  8.         applicationContext.register(Config.class);
  9.         applicationContext.refresh();
  11.         registerUserBeanDefinition(applicationContext,"erHuUser");
  12.         registerUserBeanDefinition(applicationContext);
  14.         Map<String, Config> configMap = applicationContext.getBeansOfType(Config.class);
  15.         Map<String, User> userMap = applicationContext.getBeansOfType(User.class);
  16.         System.out.println(
  17.                 configMap);// {annotationBeanDefinitionDemo.Config=top.xinzhang0618.spring.bean.AnnotationBeanDefinitionDemo$Config@2c039ac6}
  18.         System.out.println(userMap);// {user=User{id=1, name='一旦'}, erHuUser=User{id=2, name='二虎'}, top.xinzhang0618.ioc.overview.domain.User#0=User{id=2, name='二虎'}}
  20.         applicationContext.close();
  21.     }
  23.     @Component //2. 通过 @Component方式
  24.     public static class Config {
  26.         // 1. 通过 @Bean方式定义
  27.         @Bean(name = {"user", "yiDanUser"})
  28.         public User user() {
  29.             User user = new User();
  30.             user.setId(1L);
  31.             user.setName("一旦");
  32.             return user;
  33.         }
  34.     }
  36.     /**
  37.      * 通过API注册Bean
  38.      */
  39.     public static void registerUserBeanDefinition(BeanDefinitionRegistry registry, String beanName) {
  40.         BeanDefinitionBuilder beanDefinitionBuilder = genericBeanDefinition(User.class);
  41.         beanDefinitionBuilder.addPropertyValue("id", 2L).addPropertyValue("name", "二虎");
  42.         if (StringUtils.hasText(beanName)) {
  43.             // 命名Bean的注册方式
  44.             registry.registerBeanDefinition(beanName, beanDefinitionBuilder.getBeanDefinition());
  45.         } else {
  46.             // 非命名Bean的注册方式
  47.             BeanDefinitionReaderUtils.registerWithGeneratedName(beanDefinitionBuilder.getBeanDefinition(), registry);
  48.         }
  49.     }
  51.     public static void registerUserBeanDefinition(BeanDefinitionRegistry registry) {
  52.         registerUserBeanDefinition(registry, null);
  53.     }
  54. }

实例化SpringBean

  1. 常规方式
  • 通过构造器(配置元信息: XML. Java注解和API)
  • 通过静态工厂方法
  • 通过Bean工厂方法
  • 通过FactoryBean

以下代码通过XML配置的方式演示了三种情况

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans
  3.         xmlns="http://www.springframework.org/schema/beans"
  4.         xmlns:context="http://www.springframework.org/schema/context"
  5.         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  6.         xsi:schemaLocation="http://www.springframework.org/schema/beans
  7.         https://www.springframework.org/schema/beans/spring-beans.xsd
  8.         http://www.springframework.org/schema/context
  9.         https://www.springframework.org/schema/context/spring-context.xsd">
  11.     <!--静态方法实例化Bean-->
  12.     <bean id="user-by-static-method" class="top.xinzhang0618.ioc.overview.domain.User"
  13.             factory-method="createUser"/>
  15.     <!--实例方法实例化Bean-->
  16.     <bean id="user-by-instance-method" factory-bean="userFactory" factory-method="createUser"/>
  18.     <!--通过FactoryBean实例化Bean-->
  19.     <bean id="user-by-factory-bean" class="top.xinzhang0618.spring.bean.factory.UserFactoryBean"/>
  20.     <bean id="userFactory" class="top.xinzhang0618.spring.bean.factory.DefaultUserFactory"/>
  21. </beans>
  1. public class User {
  3.     private Long id;
  4.     private String name;
  5. ...
  7.     /**
  8.      * 通过静态方法构建user
  9.      * @return
  10.      */
  11.     public static User createUser() {
  12.         User user = new User();
  13.         user.setId(1L);
  14.         user.setName("lisi");
  15.         return user;
  16.     }
  17. }
  18. ------------------
  19.     public interface UserFactory {
  21.     default User createUser() {
  22.         return User.createUser();
  23.     }
  24. }
  25. ----------------------
  26.     public class DefaultUserFactory implements UserFactory {
  28. }
  29. -----------------------
  30.     public class UserFactoryBean implements FactoryBean {
  32.     @Override
  33.     public Object getObject() throws Exception {
  34.         return User.createUser();
  35.     }
  37.     @Override
  38.     public Class<?> getObjectType() {
  39.         return User.class;
  40.     }
  41. }
  1.     public static void main(String[] args) {
  2.         BeanFactory beanFactory = new ClassPathXmlApplicationContext(
  3.                 "classpath:/META-INF/bean-instantiation-context.xml");
  4.         User user = beanFactory.getBean("user-by-static-method", User.class);
  5.         User userByInstanceMethod = beanFactory.getBean("user-by-instance-method", User.class);
  6.         User userByFactoryBean = beanFactory.getBean("user-by-factory-bean", User.class);
  7.         System.out.println(user);
  8.         System.out.println(userByInstanceMethod);
  9.         System.out.println(userByFactoryBean);
  10.         System.out.println(user == userByInstanceMethod);//false
  11.         System.out.println(userByInstanceMethod == userByFactoryBean);//false
  12.     }
  1. 特殊方式
  • 通过ServiceLoaderFactoryBean
  • 通过AutowireCapableBeanFactory#createBean(java.lang.Class, int, boolean)
  • 通过BeanDefinitionRegistry#registerBeanDefinition(String, BeanDefinition)

初始化SpringBean

执行顺序如下:

  1. @PostConstruct标注方法
  2. 实现InitializingBean接口的afterPropertiesSet()方法
  3. 自定义初始化方法
    • XML配置:
    • Java注解: @Bean(initMethod=”init”)
    • Java API: AbstractBeanDefinition#setInitMethosName(String)

示例代码如下: 

  1. @Configuration
  2. public class BeanInitializationDemo {
  4.     public static void main(String[] args) {
  5.         AnnotationConfigApplicationContext applicationContext = new AnnotationConfigApplicationContext();
  6.         applicationContext.register(BeanInitializationDemo.class);
  7.         applicationContext.refresh();
  8.         // 非延迟初始化 在Spring应用启动上下文完成后, 被初始化
  9.         System.out.println("Spring应用上下文已启动...");
  11.         UserFactory userFactory = applicationContext.getBean(UserFactory.class);
  12.         System.out.println(userFactory);
  13.         applicationContext.close();
  14.     }
  16.     @Bean(initMethod = "initUserFactory", destroyMethod = "doDestroy")
  17. //    @Lazy
  18.     public UserFactory userFactory() {
  19.         return new DefaultUserFactory();
  20.     }
  21. }
  1. public class DefaultUserFactory implements UserFactory , InitializingBean, DisposableBean {
  3.     // 1. 基于 @PostConstruct 注解实现
  4.     @PostConstruct
  5.     public void init(){
  6.         System.out.println("userFactory的@PostConstruct初始化");
  7.     }
  9.     public void initUserFactory(){
  10.         System.out.println("@Bean自定义初始化方法");
  11.     }
  13.     @Override
  14.     public void afterPropertiesSet() throws Exception {
  15.         System.out.println("InitializingBean#afterPropertiesSet初始化方法");
  16.     }
  18.     @PreDestroy
  19.     public void preDestroy(){
  20.         System.out.println("userFactory的@PreDestroy销毁方法");
  21.     }
  23.     @Override
  24.     public void destroy() throws Exception {
  25.         System.out.println("DisposableBean#destroy销毁方法");
  26.     }
  28.     public void doDestroy(){
  29.         System.out.println("@Bean自定义销毁方法");
  30.     }
  31. }
  1. userFactory的@PostConstruct初始化
  2. InitializingBean#afterPropertiesSet初始化方法
  3. @Bean自定义初始化方法
  4. Spring应用上下文已启动...
  5. top.xinzhang0618.spring.bean.factory.DefaultUserFactory@19dc67c2
  6. userFactory的@PreDestroy销毁方法
  7. DisposableBean#destroy销毁方法
  8. @Bean自定义销毁方法

注: spring的启动初始化是单线程的

延迟初始化Bean

常用来解决循环依赖问题

  1. XML配置:
  2. java注解: @Lazy(true)

非延迟初始化: 先初始化Bean后再启动Spring上下文
延迟初始化: 先启动Spring上下文, 首次调用方法或者字段时, 才进行初始化

销毁SpringBean

执行顺序如下:

  1. @PreDestroy标注方法
  2. 实现DisposableBean接口的destory()方法
  3. 自定义销毁方法
    1. XML配置:
    2. Java注解: @Bean(destroy=”destroy”)
    3. Java API : AbstractBeanDefiniton#setDestroyMethosName(String)

回收SpringBean

Bean垃圾回收(GC)

  1. 关闭Spring容器应用上下文
  2. 执行GC
  3. SpringBean覆盖的finalize()方法被回调