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();