前言

之前写过一篇IOC的文章,只是简单的介绍和使用,今天结合IOC的核心源码分析一下

之前的文章:<http://blog.chenqi.im/?p=672

所谓的IOC就是控制反转,其实就是创建对象和对对象的管理交给Spring的IOC容器来管理了,

就是不用我们自己手动的闯创建对象了,使用IOC的好处事解耦。

IOC的容器有两个BeanFactory和ApplicationContext ,这两个都是接口,ApplicationContext 是高级容器继承了BeanFactory这个低级容器。

ApplicationContext :只要一读取配置文件,默认情况下就会创建对象。

BeanFactory:什么使用什么时候创建对象。

ApplicationContext 高级在哪里:他比 BeanFactory 多了更多的功能。他继承了多个接口。例如资源的获取,支持多种消息(例如 JSP tag 的支持),对 BeanFactory 多了工具级别的支持,国际化等。

这俩容器都是管理Bean对象的,实例化一个bean的方式:根据类名,构造方法,factoryBean,静态工厂方法创建。

实例化之后怎么注入属性(DI 依赖注入)?无参构造,set方法,自动注入

IOC的执行流程(容器创建过程)

@Test
public void sel() throws SQLException {
    ApplicationContext ac = new ClassPathXmlApplicationContext(" bean.xml ");
    IAccountService service = (IAccountService) ac.getBean("accountService");
    service.select();
}

上面的代码是IOC的简单使用,直接跟源码:new ClassPathXmlApplicationContext(" bean.xml ");

public ClassPathXmlApplicationContext(
      String[] configLocations, boolean refresh, @Nullable ApplicationContext parent)
      throws BeansException {
   super(parent);
   setConfigLocations(configLocations);
   if (refresh) {
      refresh();
   }
}

setConfigLocations(configLocations);这行代码是读取传入的XML获取bean

refresh();是IOC的核心,是初始化容器的核心代码

@Override
public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         initMessageSource();

         // Initialize event multicaster for this context.
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         onRefresh();

         // Check for listener beans and register them.
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
        // ......
      }

      finally {
       // ......
      }
   }
}

refresh()代码就干了这么些事,简单说下功能

1、prepareRefresh()

容器刷新前的准备,设置上下文状态,获取属性,验证必要的属性等

2、obtainFreshBeanFactory()

获取新的beanFactory,销毁原有beanFactory、为每个bean生成BeanDefinition

3、prepareBeanFactory(beanFactory);

配置标准的beanFactory,设置ClassLoader,设置SpEL表达式解析器,添加忽略注入的接口,添加bean,添加bean后置处理器等

4、postProcessBeanFactory(beanFactory);

模板方法,此时,所有的beanDefinition已经加载,但是还没有实例化。
允许在子类中对beanFactory进行扩展处理。比如添加ware相关接口自动装配设置,添加后置处理器等,是子类扩展prepareBeanFactory(beanFactory)的方法

5、invokeBeanFactoryPostProcessors(beanFactory)

实例化并调用所有注册的beanFactory后置处理器(实现接口BeanFactoryPostProcessor的bean,在beanFactory标准初始化之后执行)。
例如:
PropertyPlaceholderConfigurer(处理占位符)

6、registerBeanPostProcessors(beanFactory)

实例化和注册beanFactory中扩展了BeanPostProcessor的bean。
例如:
AutowiredAnnotationBeanPostProcessor(处理被@Autowired注解修饰的bean并注入)
RequiredAnnotationBeanPostProcessor(处理被@Required注解修饰的方法)
CommonAnnotationBeanPostProcessor(处理@PreDestroy@PostConstruct@Resource等多个注解的作用)等。

7、initMessageSource();

初始化国际化工具类MessageSource

8、initApplicationEventMulticaster();

初始化事件广播器

9、onRefresh();

模板方法,在容器刷新的时候可以自定义逻辑,不同的Spring容器做不同的事情。

10、registerListeners();

注册监听器,广播early application events

11、finishBeanFactoryInitialization(beanFactory);

实例化所有剩余的(非懒加载)单例
比如invokeBeanFactoryPostProcessors方法中根据各种注解解析出来的类,在这个时候都会被初始化。
实例化的过程各种BeanPostProcessor开始起作用。

12、finishRefresh();

refresh做完之后需要做的其他事情。
清除上下文资源缓存(如扫描中的ASM元数据)
初始化上下文的生命周期处理器,并刷新(找出Spring容器中实现了Lifecycle接口的bean并执行start()方法)。
发布ContextRefreshedEvent事件告知对应的ApplicationListener进行响应的操作

以上方法 obtainFreshBeanFactory()是核心,因为这个方法是把Bean放到 Bean Definition(定义)中,获取其他地方获取Bean 也是从这里面拿的

Spring IoC 的初始化过程,简单来说

  1. 低级容器 加载配置文件,并解析成 BeanDefinition 到低级容器中。
  2. 加载成功后,高级容器启动高级功能,例如接口回调,监听器,自动实例化单例,发布事件等等功能。

容器初始化完成后,就要获取Bean了

跟这行代码ac.getBean("accountService");

protected <T> T doGetBean(String name, Class<T> requiredType, final Object[] args, boolean typeCheckOnly) throws BeansException {
    final String beanName = this.transformedBeanName(name);
    Object sharedInstance = this.getSingleton(beanName);
    Object bean;
    if (sharedInstance != null && args == null) {
        if (this.logger.isDebugEnabled()) {
            if (this.isSingletonCurrentlyInCreation(beanName)) {
                this.logger.debug("Returning eagerly cached instance of singleton bean '" + beanName + "' that is not fully initialized yet - a consequence of a circular reference");
            } else {
                this.logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }

        bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, (RootBeanDefinition)null);
    } else {
        if (this.isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }

        BeanFactory parentBeanFactory = this.getParentBeanFactory();
        if (parentBeanFactory != null && !this.containsBeanDefinition(beanName)) {
            String nameToLookup = this.originalBeanName(name);
            if (args != null) {
                return parentBeanFactory.getBean(nameToLookup, args);
            }

            return parentBeanFactory.getBean(nameToLookup, requiredType);
        }

        if (!typeCheckOnly) {
            this.markBeanAsCreated(beanName);
        }

        try {
            final RootBeanDefinition mbd = this.getMergedLocalBeanDefinition(beanName);
            this.checkMergedBeanDefinition(mbd, beanName, args);
            String[] dependsOn = mbd.getDependsOn();
            String[] var11;
            if (dependsOn != null) {
                var11 = dependsOn;
                int var12 = dependsOn.length;

                for(int var13 = 0; var13 < var12; ++var13) {
                    String dep = var11[var13];
                    if (this.isDependent(beanName, dep)) {
                        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                    }

                    this.registerDependentBean(dep, beanName);
                    this.getBean(dep);
                }
            }

            if (mbd.isSingleton()) {
                sharedInstance = this.getSingleton(beanName, new ObjectFactory<Object>() {
                    public Object getObject() throws BeansException {
                        try {
                            return AbstractBeanFactory.this.createBean(beanName, mbd, args);
                        } catch (BeansException var2) {
                            AbstractBeanFactory.this.destroySingleton(beanName);
                            throw var2;
                        }
                    }
                });
                bean = this.getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            } else if (mbd.isPrototype()) {
                var11 = null;

                Object prototypeInstance;
                try {
                    this.beforePrototypeCreation(beanName);
                    prototypeInstance = this.createBean(beanName, mbd, args);
                } finally {
                    this.afterPrototypeCreation(beanName);
                }

                bean = this.getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            } else {
                String scopeName = mbd.getScope();
                Scope scope = (Scope)this.scopes.get(scopeName);
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
                }

                try {
                    Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {
                        public Object getObject() throws BeansException {
                            AbstractBeanFactory.this.beforePrototypeCreation(beanName);

                            Object var1;
                            try {
                                var1 = AbstractBeanFactory.this.createBean(beanName, mbd, args);
                            } finally {
                                AbstractBeanFactory.this.afterPrototypeCreation(beanName);
                            }

                            return var1;
                        }
                    });
                    bean = this.getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                } catch (IllegalStateException var21) {
                    throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active for the current thread; consider defining a scoped proxy for this bean if you intend to refer to it from a singleton", var21);
                }
            }
        } catch (BeansException var23) {
            this.cleanupAfterBeanCreationFailure(beanName);
            throw var23;
        }
    }

简单说下上面的源码干了哪些事

  1. 调用getBean() 会触发Bean的实例化。
  2. 先从缓存读取,有的话返回实例
  3. 没有的话看当前bean是单例还是多例,单例的话,创建完后并缓存
  4. 多例直接创建
  5. 创建bean的底层是反射技术

Bean创建时序图:

ean创建时序图

Bean的生命周期

Bean的生命周期

Spring如果解决Bean循环依赖问题

循环依赖,其实就是循环引用,就是两个或者两个以上的 bean 互相引用对方,最终形成一个闭环,如 A 依赖 B,B 依赖 C,C 依赖 A。

  • 首先 A 完成初始化第一步并将自己提前曝光出来(通过 ObjectFactory 将自己提前曝光),在初始化的时候,发现自己依赖对象 B,此时就会去尝试 get(B),这个时候发现 B 还没有被创建出来
  • 然后 B 就走创建流程,在 B 初始化的时候,同样发现自己依赖 C,C 也没有被创建出来
  • 这个时候 C 又开始初始化进程,但是在初始化的过程中发现自己依赖 A,于是尝试 get(A),这个时候由于 A 已经添加至缓存中(一般都是添加至三级缓存 singletonFactories ),通过 ObjectFactory 提前曝光,所以可以通过 ObjectFactory#getObject() 方法来拿到 A 对象,C 拿到 A 对象后顺利完成初始化,然后将自己添加到一级缓存中
  • 回到 B ,B 也可以拿到 C 对象,完成初始化,A 可以顺利拿到 B 完成初始化。到这里整个链路就已经完成了初始化过程了

关于IOC 这篇文章写的不错:
http://www.iocoder.cn/Fight/Interview-poorly-asked-Spring-IOC-process-1/

Last modification:November 2nd, 2019 at 02:46 pm