Spring IOC源码分析(3)

扫码关注公众号:Java 技术驿站

发送:vip
将链接复制到本浏览器,永久解锁本站全部文章

【公众号:Java 技术驿站】 【加作者微信交流技术,拉技术群】

1.IOC容器的依赖注入

Spring中,依赖注入是在用户第一次向IOC容器索要Bean时触发的(通过getBean方法)。

20191017100320\_1.png

在BeanFactory中我们看到getBean(String…)函数,它的具体实现在AbstractBeanFactory中:

    public Object getBean(String name) throws BeansException {
            return doGetBean(name, null, null, false);
    }

可以看到具体的注入过程转移到doGetBean(String…)中,在这个方法中,它首先从缓存中取,如果单件模式的bean已经被创建,则这种bean请求不需要重复的创建,调用

    bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

跟踪进入getObjectForBeanInstance(…,null),可以知道因为最后的RootBeanDefinition参数是null,所以执行的是:

    if (mbd == null) {
        object = getCachedObjectForFactoryBean(beanName);
    }

而getCachedObjectForFactoryBean(beanName)中实现,其实现很简单,就是在缓存的bean map中查找bean返回。

继续回到doGetBean(String…)方法中:

             //取当前bean的所有依赖bean,这样就会触发getBean的递归调用,直至取到一个没有任何依赖的bean为止
      String[] dependsOn = mbd.getDependsOn();
      if (dependsOn != null) {
          for (String dependsOnBean : dependsOn) {
              getBean(dependsOnBean);
                        //注册依赖的bean实例,具体实现过程在DefaultSingletonBeanRegistry中实现,其实就是将依赖的bean添加到依赖的hashmap中
              registerDependentBean(dependsOnBean, beanName);
          }
      }
      //通过调用createBean来,创建单例bean的实例
      if (mbd.isSingleton()) {
          sharedInstance = getSingleton(beanName, new ObjectFactory() {
             public Object getObject() throws BeansException {
               try {
                return createBean(beanName, mbd, args);
               }
               catch (BeansException ex) {
              destroySingleton(beanName);
              throw ex;
               }
                  }
              });
              bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
      }
      //同样调用createBean创建prototype的bean实例
      else if (mbd.isPrototype()) {
          // It's a prototype -> create a new instance.
          Object prototypeInstance = null;
          try {
              beforePrototypeCreation(beanName);
              prototypeInstance = createBean(beanName, mbd, args);
          }
          finally {
              afterPrototypeCreation(beanName);
          }
            bean=getObjectForBeanInstance(prototypeInstance,name, beanName, mbd);
    }

继续看createBean(…),可以看到在AbstractBeanFactory中它只是个抽象类,具体的实现交给其子类(又见模板模式),进入子类AbstractAutowireCapableBeanFactory中看createBean的具体实现:

    Object beanInstance = doCreateBean(beanName, mbd, args);

其具体的实现转到doCreateBean(String…),这里我们看到与依赖注入关系比较密切的方法有createBeanInstance和populateBean。

    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
    }

在createBeanInstance中生成了Bean所包含的Java对象,这个对象的生成有很多不同的方式,可以通过工厂方法生成,也可以通过容器的autowire特性生成,生成的方式由相关联的BeanDefinition来指定,进入createBeanInstance方法,有:

    return instantiateUsingFactoryMethod(beanName, mbd, args);
    return instantiateBean(beanName, mbd);

上面是其中的两个实例化方法,上面的是在BeanDefinition的FactoryMethod存在的情况下,使用工厂方法对bean进行实例化。下面一个是使用默认的构造函数对bean进行实例化。我们进入instantiateBean(beanName,mbd),可以看到有:

    return getInstantiationStrategy().instantiate(mbd, beanName, parent);

因为getInstantiationStrategy()返回的默认的实例化策略,而默认的实例化策略是CglibSubclassingInstantiationStrategy,也即用cglib来对bean进行实例化。CGLIB是一个常用的字节码生成器的类库,它提供了一系列的API来提供Java的字节码生成和转换功能。

我们再次回到doCreateBean()中的populateBean方法,看看在实例化Bean对象生成的基础上,spring怎样把这些bean对象的依赖关系设置好,完成整个依赖注入过程。在populateBean中,先是取得在BeanDefinition中设置的property值,这些property来自对BeanDefinition的解析,接着便开始进行依赖注入过程:

    //开始进行依赖注入过程,先处理autowire的注入
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                MutablePropertyValues newPvs = new MutablePropertyValues(pvs);

                //根据bean的名字进行autowire过程
                if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                    autowireByName(beanName, mbd, bw, newPvs);
                }

                //根据类型type进行autowire的过程
                if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                    autowireByType(beanName, mbd, bw, newPvs);
                }

                pvs = newPvs;
    }

最后在通过applyPropertyValues对属性进行注入:

    applyPropertyValues(beanName, mbd, bw, pvs);

接着我们到applyPropertyValues中去看具体的对属性进行解析然后注入的过程,在其中会调用BeanDefinitionValueResolver对BeanDefinition进行解析,

    BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);

接着为解析值创建一个拷贝,拷贝的数据将会被注入到bean中,它会先对PropertyValue判断,如果其没有经过转换则会调用resolveValueIfNecessary进行解析,然后注入到property中。下面到BeanDefinitionValueResolver中去看一下解析过程的实现,在函数resolveValueIfNecessary中包含了所有对注入类型的处理,以RuntimeBeanReference(其是在对BeanDefinition进行解析时生成的数据对象)为例:

    if (value instanceof RuntimeBeanReference) {
        RuntimeBeanReference ref = (RuntimeBeanReference) value;
        return resolveReference(argName, ref);
    }
    //当注入类型为RuntimeBeanReference时,进入resolveReference(…):
    private Object resolveReference(Object argName, RuntimeBeanReference ref) {
            try {
                //从RuntimeBeanReference取得reference的名字
                String refName = ref.getBeanName();
                refName = String.valueOf(evaluate(refName));
                //如果ref是在双亲的IOC容器中,那就到双亲IOC容器中去取
                if (ref.isToParent()) {
                    if (this.beanFactory.getParentBeanFactory() == null) {
                        //抛出异常BeanCreationException
                                                 ……
                    }
                    return this.beanFactory.getParentBeanFactory().
                                         getBean(refName);
                }
                else {
                                        //在当前IOC容器中去取bean
                    Object bean = this.beanFactory.getBean(refName);
                                    this.beanFactory.registerDependentBean(refName, this.beanName);
                    return bean;
                }
    }

在上面的实现中,无论是到双亲的IOC容器中去取,还是在当前IOC容器中取,都会触发一个getBean的过程,这就触发了相应的依赖注入的发生。

这就完成了resolve的过程,为依赖注入准备好了条件。但真正的把Bean对象设置到它所依赖的另一个Bean的属性中去的地方是在BeanWrapper的setPropertyValues中(在分析populateBean的时候有提到),其中处理的属性是各种各样的。setPropertyValues的具体实现是在BeanWrapper的子类BeanWrapperImpl中:

在doCreateBean中执行完populateBean,完成Bean的生成和依赖注入以后,开始对Bean进行初始化,这个初始化过程包含了对后置处理器的postProcessBeforeInitializtion回调,具体实现在initializeBean方法中:

    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }

    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }
    catch (Throwable ex) {
        //抛出异常BeanCreationException
    }

    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;

来源:[]()

赞(0) 打赏
版权归原创作者所有,任何形式的转载请联系博主:daming_90:Java 技术驿站 » Spring IOC源码分析(3)

评论 抢沙发

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

微信扫一扫打赏