1、Factory原理分析

  • spring的@Autowired注解为什么是先根据类型找而不先根据ID找？
    • 因为它会去单例池中寻找，而单例池是一个map，map的key不可重复，必须先确保类型一致然后再通过ID区分。
  • spring容器启动之前首先会扫描所有的组件，并且把它们的定义信息都保存在一个beandefinition中。并不是扫描到一个类就创建一个对象，因为原型对象每次创建都需要重新创建，所以这样会很复杂。
  • 什么是beanFactory

    • beanfactory的四个主要属性，存放bean定义信息的map，单例池，所有的后置处理器，缓存池，只要存放factorybean
  • 什么是factorybean
    • 实现了factorybean接口，实现它的getobject（）方法，当我们将它注入容器，给我们生成的是getobject（）所返回的bean。
    • factorybean在添加到单例池时仍然是它本身，只有当getbean的时候，就会去判断它有没有实现facatorybean接口，如果实现了，就会调用它的getobject（）方法，然后放入到缓存map中，以后每一次获取这个bean都会从缓存中获取，而且getbean都会先检查缓存中有没有这个bean。

2、beanfactory的6大集合

1、bean定义map，存放bean的定义信息和bean的name，即每个组件都有一个对应的beandefinition，这个对象的属性中描述了这个bean是否是单例，全类名，是否懒加载，等众多属性。而我们的beanfactory是一个工厂模式，我们只需要将我们需要的配置信息告诉它它就会使用它的组件来完成我们需要的bean的生产，前期是需要得到我们bean的详细信息，所以beandefinitionmap是我们创建bean的根据，beanfactory的creatbean方法需要用到它们。

2、beandefinitionnames则是beandefinitionmap中所有的key的一个list，比如在preInstantiateSingletons（）方法中首先就会拿到对应的beannams去获取对应的bean的详细定义信息来完成我们的初始化。

3、aliasmap则是存放别名所对应的bena的定义信息映射

4、singletonObjects则是单例池，存放创建出来的单例的bean。

5、beanpostprocessor也是beanfactory的组件，在创建过程中需要用到很多自己的后置处理器来干预bean的生命周期。

6、cachemap，缓存map。

3、postprocessor

后置处理器，干预bean的生命周期。只有当一个bean存在才会执行

对应的我们也可以拿到beanfactory在创建完成后，实现beanfactorypostprocessor，这个后置处理器是处理beanfactory的，在beanfactory创建完成之后会执行它的方法，我们可以实现这个接口，来操作beanfactory。

比如我们可以拿到beanfactory的所有东西，通过操作beanfactory的属性来干预所有bean的声明周期，因为所有的bean都是通过beanfactory来创建的， 我们可以修改它的定义信息，我们可以对单例池做一些操作等等。

此时beanfactory只不过才创建出来，里面什么都没有。

4、abstractApplicationContext的 refresh（）方法，容器启动过程

  1.     @Override
  2.     public void refresh() throws BeansException, IllegalStateException {
  3.         synchronized (this.startupShutdownMonitor) {
  4.             // Prepare this context for refreshing.
  6.       // 准备刷新容器
  7.             prepareRefresh();
  9.             // Tell the subclass to refresh the internal bean factory.
  11.       // 告诉子类即将刷新
  12.             ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
  14.             // Prepare the bean factory for use in this context.
  16.               // 初始化工厂前的准备
  17.             prepareBeanFactory(beanFactory);
  19.             try {
  20.                 // Allows post-processing of the bean factory in context subclasses.
  22.         // 准备beanFactory的后处理器
  23.                 postProcessBeanFactory(beanFactory);
  25.                 // Invoke factory processors registered as beans in the context.
  27.         // 调用beanfactory的后处理器
  28.                 invokeBeanFactoryPostProcessors(beanFactory);
  30.                 // Register bean processors that intercept bean creation.
  32.         // 注册所有的后置处理器
  33.                 registerBeanPostProcessors(beanFactory);
  35.                 // Initialize message source for this context.
  37.         // 初始化一些消息源
  38.                 initMessageSource();
  40.                 // Initialize event multicaster for this context.
  42.         // 初始化一些事件派发
  43.                 initApplicationEventMulticaster();
  45.                 // Initialize other special beans in specific context subclasses.
  47.         // 留给子类重写的方法
  48.                 onRefresh();
  50.                 // Check for listener beans and register them.
  52.         // 注册监听器，基于事件驱动
  53.                 registerListeners();
  55.                 // Instantiate all remaining (non-lazy-init) singletons.
  57.         // 注册所有的非懒加载单实例的bean，也就是我们需要研究的bean的声明周期。
  58.                 finishBeanFactoryInitialization(beanFactory);
  60.         // 完成刷新
  61.                 // Last step: publish corresponding event.
  62.                 finishRefresh（）;
  63.             }
  65.       finally中会清除所有的单例bean的元数据，因为此时bean已经创建完成，不再需要定义信息了。

bean的声明周期整个流程

  1. finishBeanFactoryInitialization   在这个方法中完成bean的创建。
  1. beanFactory.preInstantiateSingletons();  创建单实例bean
  1. public void preInstantiateSingletons() throws BeansException {
  2.    if (logger.isTraceEnabled()) {
  3.       logger.trace("Pre-instantiating singletons in " + this);
  4.    }
  6.    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
  7.    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
  8.    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);  // 拿到所有的bean的名字
  1. // Trigger initialization of all non-lazy singleton beans...
  2. for (String beanName : beanNames) {   //得到bean的名字后进行遍历
  3.    RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  4.    if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {  // 判断条件 非抽象，单实例，非懒加载。才进行创建
  5.       if (isFactoryBean(beanName)) {  // 判断是不是FactoryBean
  6.          Object bean = getBean(FACTORY_BEAN_PREFIX + beanName); // 如果是 先拿到factorybean这个组件本身的对象
  7.          if (bean instanceof FactoryBean) {   
  8.             FactoryBean<?> factory = (FactoryBean<?>) bean;
  9.             boolean isEagerInit;
  10.             if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  11.                isEagerInit = AccessController.doPrivileged(
  12.                      (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
  13.                      getAccessControlContext());
  14.             }
  15.             else {
  16.                isEagerInit = (factory instanceof SmartFactoryBean &&
  17.                      ((SmartFactoryBean<?>) factory).isEagerInit());
  18.             }
  19.             if (isEagerInit) {
  20.                getBean(beanName);
  21.             }
  22.          }
  23.       }
  24.       else {
  25.          getBean(beanName);  // 不是 调用getbean；
  26.       }
  27.    }
  28. }
  1. getbean调用doGetBean（）；
    1. Object sharedInstance = getSingleton(beanName); // 检查缓存中是否有已经注册的bean，比如实现了beandefinition接口的，实现了factorybean的对象如果被别的bean所依赖，此时也会回调它的getclass方法判断是不是被另一个bean所依赖的，如果是就调用getobjct方法创建并放入缓存中，这一步也是为了解决循环依赖。