Spring Bean 生命周期

简介: Spring Bean 生命周期

Bean的生成过程


生成BeanDefinition


1,首先,通过ResourcePatternResolver获得指定路径下所有的.class文件(Spring 源码中将此文件包装成了Resource对象)


2,遍历每个Resource对象


3,利用MetadateReaderFactory解析Resource对象得到MetadataReader。


4,利用MetadateReader进行excludeFilters和includeFilters,以及条件注解@Conditional的筛选(条件注解并不能理解:某个类上是否存在@Conditional注解,如果存在则调用注解中指定的条件match方法进行匹配,匹配成功则进行筛选,匹配失败则pass掉)


5,筛选通过后,基于MetadataReader生成ScannerGenericBeanDefinition


6,再基于metadataReader判断是不是对应的类是不是接口或是抽象类


7,如果筛选通过,那么就表示扫描到了bean,将ScannerGenericBeanDefinition加入结果集。


合并BeanDefinition


通过扫描得到BeanDefinition之后,就可以根据BeanDefinition创建Bean对象,但是在spring中支持父类BeanDefinition,和Java父子类类似,但是完全不是一回事。


父子BeanDefinition使用:


<bean id ="parent" class="com.qijian.service.Parent" scope="prototype"/>
<bean id="child" class="com.qijian.service.Chid" parent="parent"/>


这么定义下,child就是原型bean,因为child的父类BeanDefinition是parent,所以会继承parent上所定义的scope属性。而在更据child来生成Bean对象之前,需要进行BeanDefinition的合并,得到完整的child的BeanDefinition。


类的加载


BeanDefinition合并之后,就可以去创建Bean对象,而创建Bean就必须实例化对象,而实例化就必须先加载当前BeanDefinition所对应的class,在AbstractAutowireCapableBeanFactory类的createBean()方法中,一开始就会调用:Class<?> resolvedClass = resolveBeanClass(mbd, beanName);去加载类。


实例化前


当前BeanDefinition对应的类加载成功后,就可以实例化对象,但是Spring在实例化对象之前,spring提供了一个扩展点,允许用户来控制是否在某个或某些Bean实例化之前做一些起始动作。


扩展点是:InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()。

@Component
public class ZhouyuBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
  @Override
  public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
throws BeansException {
    if ("userService".equals(beanName)) {
      System.out.println("实例化前");
    }
    return null;
  }
}


如上代码会导致,在userService这个Bean实例化前,会进行打印

注意:postProcessBeforeInstantiation()是有返回值的,如果这么实现:


@Component
public class ZhouyuBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
  @Override
  public Object postProcessBeforeInstantiation(Class<?> beanClass, String beanName)
throws BeansException {
    if ("userService".equals(beanName)) {
      System.out.println("实例化前");
      return new UserService();
    }
    return null;
  }
}


userService这个Bean,在实例化前会直接返回一个由我们所定义的UserService对象。如果是这样,表示不需要Spring来实例化了,并且后续的Spring依赖注入也不会进行了,会跳过一些步骤,直接执行初始化后这一步。


实例化


实例化的主要作用:更据BeanDefinition创建一个对象。


Supplier创建对象


首先判断BeanDefinition中是否设置了Supplier,如果设置了则调用Supplier的get()得到对象。 得直接使用BeanDefinition对象来设置Supplier,比如:


AbstractBeanDefinition beanDefinition =
BeanDefinitionBuilder.genericBeanDefinition().getBeanDefinition();
beanDefinition.setInstanceSupplier(new Supplier<Object>() {
  @Override
  public Object get() {
    return new UserService();
  }
});
context.registerBeanDefinition("userService", beanDefinition);


注:***supplier也是是用来创建对象的,但是*不同于传统的创建对象语法:new


public class MySupplier {
  private int age;
  MySupplier(){
    System.out.println(age);
  }
  public static void main(String[] args) {
    //创建Supplier容器,声明为TestSupplier类型,此时并不会调用对象的构造方法,即不会创建对象
    Supplier<TestSupplier> sup= MySupplier::new;
    System.out.println("--------");
    //调用get()方法,此时会调用对象的构造方法,即获得到真正对象
    sup.get();
    //每次get都会调用构造方法,即获取的对象不同
    sup.get();
  }
}


工厂方法创建对象


如果没有设置Supplier,则检查BeanDefinition中是否设置了factoryMethod,也就是工厂方法,有两种方式可以设置factoryMethod:


方式一:


Service类:


public class UserService {
  public static UserService createUserService() {
    System.out.println("执行createUserService()");
    UserService userService = new UserService();
    return userService;
  }
  public void test() {
    System.out.println("test");
  }
}


<bean id="userService" class="com.qijian.service.UserService" factory‐method="createUserService" />


方式二:


Service类:


public class CommonService {
  public UserService createUserService() {
    return new UserService();
  }
}
<bean id="commonService" class="com..qijian.CommonService"/>
<bean id="userService1" factory‐bean="commonService" factory‐method="createUserService"/>


Spring发现当前BeanDefinition方法设置了工厂方法后,就会区分这两种方式,然后调用工厂方法得 到对象。 值得注意的是,我们通过@Bean所定义的BeanDefinition,是存在factoryMethod和factoryBean 的,也就是和上面的方式二非常类似,@Bean所注解的方法就是factoryMethod,AppConfig对象 就是factoryBean。如果@Bean所所注解的方法是static的,那么对应的就是方式一。


推断构造方法


推断完构造方法后,就会使用构造方法来进行实例化。


在推断构造方法逻辑中除开会去选择构造方法以及查找入参对象意外,会还判断是否在对应的类中是否存在使用**@Lookup注解**了方法。如果存在则把该方法封装为LookupOverride对象并添加到BeanDefinition中。


在实例化时,如果判断出来当前BeanDefinition中没有LookupOverride,那就直接用构造方法反射得到一个实例对象。如果存在LookupOverride对象,也就是类中存在@Lookup注解了的方法,那就会生成一个代理对象。


BeanDefinition的后置处理



Bean对象实例化之后,接下来就是给对象的属性赋值了。在真正给属性赋值之前,spring又提供了一个扩展点。MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(),可以对此时的 BeanDefinition进行加工


@Component
public class ZhouyuMergedBeanDefinitionPostProcessor implements MergedBeanDefinitionPostProcessor {
@Override
public void postProcessMergedBeanDefinition(RootBeanDefinition beanDefinition, Class<?> beanType, String beanName) {
if ("userService".equals(beanName)) {
beanDefinition.getPropertyValues().add("orderService", new OrderService());
    }
  }
}


在Spring源码中,AutowiredAnnotationBeanPostProcessor就是一个 MergedBeanDefinitionPostProcessor,它的postProcessMergedBeanDefinition()中会去查找注 入点,并缓存在AutowiredAnnotationBeanPostProcessor对象的一个Map中 (injectionMetadataCache)。


实例化后


在处理完BeanDefinition后,Spring又设计了一个扩展点: InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation(),


@Component
public class ZhouyuInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public boolean postProcessAfterInstantiation(Object bean, String beanName) throws BeansException {
  if ("userService".equals(beanName)) {
    UserService userService = (UserService) bean;
    userService.test();
  }
  return true;
 }
}


上述代码就是对userService所实例化出来的对象进行处理。


自动注入


就会处理@Autowired、@Resource、@Value等注解,也是通过**InstantiationAwareBeanPostProcessor.postProcessProperties()**扩展点来实现的


处理属性


处理属性时,会处理@Autowired、@Resource、@Value等注解,也是通过 **InstantiationAwareBeanPostProcessor.postProcessProperties()**扩展点来实现的,比如我们 甚至可以实现一个自己的自动注入功能


@Component
public class ZhouyuInstantiationAwareBeanPostProcessor implements InstantiationAwareBeanPostProcessor {
@Override
public PropertyValues postProcessProperties(PropertyValues pvs, Object bean, String beanName) throws BeansException {
  if ("userService".equals(beanName)) {
    for (Field field : bean.getClass().getFields()) {
     if (field.isAnnotationPresent(ZhouyuInject.class)) {
      field.setAccessible(true);
      try {
       field.set(bean, "123");
      } catch (IllegalAccessException e) {
      e.printStackTrace();
     }
   }
 }
}
    return pvs;
  }
}

执行Aware


完成了属性赋值之后,Spring会执行一些回调,包括:


  1. BeanNameAware:回传beanName给bean对象。
  2. BeanClassLoaderAware:回传classLoader给bean对象。
  3. BeanFactoryAware:回传beanFactory给对象。


初始化前


初始化前,也是Spring提供的一个扩展点:BeanPostProcessor.postProcessBeforeInitialization()

@Component
public class ZhouyuBeanPostProcessor implements BeanPostProcessor {
@Override
public Object postProcessBeforeInitialization(Object bean, String beanName) throws  BeansException {
    if ("userService".equals(beanName)) {
        System.out.println("初始化前");
    }
    return bean;
  }
}


利用初始化前,可以对进行了依赖注入的Bean进行处理。


初始化


1,查看当前Bean对象是否实现了InitializingBean接口,如果实现了就调用其afterPropertiesSet() 方法

2,执行BeanDefinition中指定的初始化方法


初始化


1,查看当前Bean对象是否实现了InitializingBean接口,如果实现了就调用其afterPropertiesSet() 方法


2,执行BeanDefinition中指定的初始化方法


初始化后


这是Bean创建生命周期中的最后一个步骤,也是Spring提供的一个扩展点: BeanPostProcessor.postProcessAfterInitialization()


@Component
public class ZhouyuBeanPostProcessor implements BeanPostProcessor {
  @Override
  public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
    if ("userService".equals(beanName)) {
      System.out.println("初始化后");
    }
    return bean;
  }
}


可以在这个步骤中,对Bean最终进行处理,Spring中的AOP就是基于初始化后实现的,初始化后返 回的对象才是最终的Bean对象。


Bean的销毁过程


时机:Bean销毁是发生在Spring容器关闭过程中的


Spring 容器关闭时:


AnnotationConfigApplicationContext context = new
AnnotationConfigApplicationContext(AppConfig.class);
UserService userService = (UserService) context.getBean("userService");
userService.test();
// 容器关闭
context.close();
相关文章
|
1月前
|
XML Java 测试技术
Spring IOC—基于注解配置和管理Bean 万字详解(通俗易懂)
Spring 第三节 IOC——基于注解配置和管理Bean 万字详解!
135 26
|
3月前
|
XML 安全 Java
|
3月前
|
存储 Java Spring
【Spring】获取Bean对象需要哪些注解
@Conntroller,@Service,@Repository,@Component,@Configuration,关于Bean对象的五个常用注解
|
3月前
|
存储 Java 应用服务中间件
【Spring】IoC和DI,控制反转,Bean对象的获取方式
IoC,DI,控制反转容器,Bean的基本常识,类注解@Controller,获取Bean对象的常用三种方式
|
3月前
|
XML Java 数据格式
Spring容器Bean之XML配置方式
通过对以上内容的掌握,开发人员可以灵活地使用Spring的XML配置方式来管理应用程序的Bean,提高代码的模块化和可维护性。
89 6
|
3月前
|
XML Java 数据格式
🌱 深入Spring的心脏:Bean配置的艺术与实践 🌟
本文深入探讨了Spring框架中Bean配置的奥秘,从基本概念到XML配置文件的使用,再到静态工厂方式实例化Bean的详细步骤,通过实际代码示例帮助读者更好地理解和应用Spring的Bean配置。希望对你的Spring开发之旅有所助益。
223 4
|
4月前
|
缓存 Java Spring
实战指南:四种调整 Spring Bean 初始化顺序的方案
本文探讨了如何调整 Spring Boot 中 Bean 的初始化顺序,以满足业务需求。文章通过四种方案进行了详细分析: 1. **方案一 (@Order)**:通过 `@Order` 注解设置 Bean 的初始化顺序,但发现 `@PostConstruct` 会影响顺序。 2. **方案二 (SmartInitializingSingleton)**:在所有单例 Bean 初始化后执行额外的初始化工作,但无法精确控制特定 Bean 的顺序。 3. **方案三 (@DependsOn)**:通过 `@DependsOn` 注解指定 Bean 之间的依赖关系,成功实现顺序控制,但耦合性较高。
198 4
实战指南:四种调整 Spring Bean 初始化顺序的方案
|
3月前
|
安全 Java 开发者
Spring容器中的bean是线程安全的吗?
Spring容器中的bean默认为单例模式,多线程环境下若操作共享成员变量,易引发线程安全问题。Spring未对单例bean做线程安全处理,需开发者自行解决。通常,Spring bean(如Controller、Service、Dao)无状态变化,故多为线程安全。若涉及线程安全问题,可通过编码或设置bean作用域为prototype解决。
57 1
|
5月前
|
XML Java 数据格式
Spring从入门到入土(bean的一些子标签及注解的使用)
本文详细介绍了Spring框架中Bean的创建和使用,包括使用XML配置文件中的标签和注解来创建和管理Bean,以及如何通过构造器、Setter方法和属性注入来配置Bean。
116 9
Spring从入门到入土(bean的一些子标签及注解的使用)
|
6月前
|
XML Java 数据格式
Spring IOC—基于XML配置Bean的更多内容和细节(通俗易懂)
Spring 第二节内容补充 关于Bean配置的更多内容和细节 万字详解!
384 18