• 近期将进行后台系统升级,如有访问不畅,请稍后再试!
  • 极客文库-知识库上线!
  • 极客文库小编@勤劳的小蚂蚁,为您推荐每日资讯,欢迎关注!
  • 每日更新优质编程文章!
  • 更多功能模块开发中。。。

彻底搞懂依赖注入(一)Bean实例创建过程

上一章介绍了 Bean 的加载过程(IOC 初始化过程),加载完成后,紧接着就要用到它的依赖注入(IOC 依赖注入)。
那什么是依赖注入呢?
所谓依赖注入,就是由 IOC 容器在运行期间,动态地将某种依赖关系注入到对象之中。再完成 IOC 容器初始化之后,也就是所谓的 Bean 加载完成后,我们需要对这些 Bean 进行调用和获取,这个过程就叫依赖注入。
那什么时候会触发依赖注入呢?
  1. 通过 getBean()方法获取 Bean 对象。
  2. 给 Bean 配置了懒加载,ApplicationContext 启动完成后调用 getBean()来实例化对象。
现在计算机性能已经足够,不是特殊要求下尽量别做懒加载,这样的话可以减少 web 运行时的调用时间开销。
好了,介绍完这些就开始我们的 DI 之旅。

1. BeanFactory

通过 Spring 获取 Bean 的最根本的接口。
  1. // 如果 myJndiObject 时 FactoryBean, 则 &myJndiObject 将返回工厂而不是返回实例。
  2. String FACTORY_BEAN_PREFIX ="&";
  3. // 获取 bean 实例
  4. Object getBean(String name)throwsBeansException;
  5. // 判断一个 bean 是否时单例
  6. boolean isSingleton(String name)throwsNoSuchBeanDefinitionException;
  7. // 判断一个 bean 是否是原型
  8. boolean isPrototype(String name)throwsNoSuchBeanDefinitionException;
  9. // 检查 bean 的 name 和 type 是否匹配
  10. boolean isTypeMatch(String name,Class targetType)throwsNoSuchBeanDefinitionException;
  11. // 获取 bean 类型
  12. Class<?> getType(String name)throwsNoSuchBeanDefinitionException;
  13. // 获取 bean 别名
  14. String[] getAliases(String name);
getBean()方法有很多重载方法,上面只总结了一个。这个方法是 DI 的入口方法,接下来会从这个方法开始往下研究。

2. AbstractBeanFactory

从名字也能看出,这是 BeanFactory 的抽象实现类。
  1. publicObject getBean(String name)throwsBeansException{
  2.    return doGetBean(name,null,null,false);
  3. }
doGetBean()方法也是该类中的方法。
  1. // 依赖注入 从这里开始发生
  2. private<T> T doGetBean(
  3.        finalString name,finalClass<T> requiredType,finalObject[] args,boolean typeCheckOnly)
  4.        throwsBeansException{

  5.    // 根据指定名字获取被管理 Bean 的名称
  6.    // 如果是别名, 则转换为真正的 bean 名
  7.    finalString beanName = transformedBeanName(name);
  8.    Object bean;

  9.    // Eagerly check singleton cache for manually registered singletons.
  10.    // 先从缓存中取单例 bean
  11.    Object sharedInstance = getSingleton(beanName);
  12.    if(sharedInstance !=null&& args ==null){
  13.        if(logger.isDebugEnabled()){
  14.            // 如果有,则直接返回该 bean
  15.            if(isSingletonCurrentlyInCreation(beanName)){
  16.                logger.debug("Returning eagerly cached instance of singleton bean '"+ beanName +
  17.                        "' that is not fully initialized yet - a consequence of a circular reference");
  18.            }
  19.            else{
  20.                logger.debug("Returning cached instance of singleton bean '"+ beanName +"'");
  21.            }
  22.        }
  23.        //获取 bean 的实例对象
  24.        bean = getObjectForBeanInstance(sharedInstance, name, beanName,null);
  25.    }

  26.    else{
  27.        // Fail if we're already creating this bean instance:
  28.        // We're assumably within a circular reference.
  29.        // 如果不是单例对象, 而且 缓存中有原型模式 bean, 就抛异常
  30.        if(isPrototypeCurrentlyInCreation(beanName)){
  31.            thrownewBeanCurrentlyInCreationException(beanName);
  32.        }

  33.        // 检查 BeanDefinition 是否再当前的 factory 中, 如果不在则委托父类容器取查找
  34.        // Check if bean definition exists in this factory.
  35.        BeanFactory parentBeanFactory = getParentBeanFactory();
  36.        if(parentBeanFactory !=null&&!containsBeanDefinition(beanName)){
  37.            // Not found -> check parent.
  38.            String nameToLookup = originalBeanName(name);
  39.            if(args !=null){
  40.                // Delegation to parent with explicit args.
  41.                // 委托父类容器取找(名字+参数)
  42.                return(T) parentBeanFactory.getBean(nameToLookup, args);
  43.            }
  44.            else{
  45.                // 委托父类容器取找(名称+类型)
  46.                // No args -> delegate to standard getBean method.
  47.                return parentBeanFactory.getBean(nameToLookup, requiredType);
  48.            }
  49.        }

  50.        if(!typeCheckOnly){
  51.            // 标记 bean 被创建
  52.            markBeanAsCreated(beanName);
  53.        }

  54.        // 根据 bean 名称获取 父类的 beanDefinition, 合并继承公共属性
  55.        finalRootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  56.        checkMergedBeanDefinition(mbd, beanName, args);

  57.        // Guarantee initialization of beans that the current bean depends on.
  58.        // 获取当前 bean 所有依赖 Bean 的集合
  59.        String[] dependsOn = mbd.getDependsOn();
  60.        if(dependsOn !=null){
  61.            for(String dependsOnBean : dependsOn){
  62.                // 递归调用, 获取当前 Bean 的依赖 Bean
  63.                getBean(dependsOnBean);
  64.                // 把依赖 Bean 注册给当前的 Bean
  65.                registerDependentBean(dependsOnBean, beanName);
  66.            }
  67.        }

  68.        // Create bean instance.
  69.        // 创建 bean 实例
  70.        if(mbd.isSingleton()){
  71.            // 创建 bean 实例对象, 并且注册给所依赖的对象
  72.            sharedInstance = getSingleton(beanName,newObjectFactory(){
  73.                publicObject getObject()throwsBeansException{
  74.                    try{
  75.                        // 创建一个指定 bean 实例对象
  76.                        return createBean(beanName, mbd, args);
  77.                    }
  78.                    catch(BeansException ex){
  79.                        // Explicitly remove instance from singleton cache: It might have been put there
  80.                        // eagerly by the creation process, to allow for circular reference resolution.
  81.                        // Also remove any beans that received a temporary reference to the bean.
  82.                        // 清除该单例
  83.                        destroySingleton(beanName);
  84.                        throw ex;
  85.                    }
  86.                }
  87.            });
  88.            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  89.        }

  90.        elseif(mbd.isPrototype()){
  91.            // It's a prototype -> create a new instance.
  92.            Object prototypeInstance =null;
  93.            try{
  94.                beforePrototypeCreation(beanName);
  95.                prototypeInstance = createBean(beanName, mbd, args);
  96.            }
  97.            finally{
  98.                afterPrototypeCreation(beanName);
  99.            }
  100.            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  101.        }

  102.        // 如果创建的 bean 不是单例也不是原型, 则根据声明周期选择实例化 bean 的方法
  103.        // 如 request session 等不同范围的实例
  104.        else{
  105.            String scopeName = mbd.getScope();
  106.            finalScope scope =this.scopes.get(scopeName);
  107.            // 如果 scope 是空, 则抛异常
  108.            if(scope ==null){
  109.                thrownewIllegalStateException("No Scope registered for scope '"+ scopeName +"'");
  110.            }
  111.            // 否则
  112.            try{
  113.                // 获取一个指定了 scope 的 bean 实例
  114.                Object scopedInstance = scope.get(beanName,newObjectFactory(){
  115.                    publicObject getObject()throwsBeansException{
  116.                        beforePrototypeCreation(beanName);
  117.                        try{
  118.                            return createBean(beanName, mbd, args);
  119.                        }
  120.                        finally{
  121.                            afterPrototypeCreation(beanName);
  122.                        }
  123.                    }
  124.                });
  125.                bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  126.            }
  127.            catch(IllegalStateException ex){
  128.                thrownewBeanCreationException(beanName,
  129.                        "Scope '"+ scopeName +"' is not active for the current thread; "+
  130.                        "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",
  131.                        ex);
  132.            }
  133.        }
  134.    }

  135.    // Check if required type matches the type of the actual bean instance.
  136.    // 检查是否需要类型检测
  137.    if(requiredType !=null&& bean !=null&&!requiredType.isAssignableFrom(bean.getClass())){
  138.        thrownewBeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  139.    }
  140.    return(T) bean;
  141. }
总结以下它都做了什么事情:
1、根据传来的 bean的 name(有可能是别名)来获取真正的 bean名称: beanName
2、根据 beanName获取单例实例,如果有直接获取到 bean实例并返回,DI 完成。
3、如果根据 beanName没有获得到单例实例:
3.1 判断是不是原型实例,如果是,则抛出创建失败异常,如果不是,下一步。
3.2 检查 BeanDefinition 是否在当前的容器中,如果不在那可能在父类容器中,所以委托父类容器查找,如果还没有,则再上一级容器…递归查找。
3.3 检查这个实例是否是为了类型检查而获取,而不是用来使用,如果是,标记这个 bean 已经被创建,如果不是,下一步。
3.4 根据 beanName获取 父类的BeanDefinition,并检查该对象类类型,比如不能是抽象类等。
3.5 根据 beanName获取所有该 bean依赖的 Bean集合,如果该集合有值,则遍历 DI(递归调用 getBean())该 bean集合里的 bean,并把 bean 注册给当前的 bean(维护了一个 map来存放关系)。
3.6 如果 3.4 中获取的 BeanDefinition是单例,则根据该单例对象和 beanName和 args创建一个实例对象;否则,判断 BeanDefinition是否是原型,如果是则根据 beanName,该对象, args创建一个实例;否则拿到 3.4 获取的 BeanDefinition对象的生命周期 Scope,然后根据 scope来创建实例对象,参数 (beanName,bd,args)
  1. 3.7检查是否需要类型检测

  2. 3.8返回`3.1-3.7 `生成的实例。
然后我们再看看 createBean()方法的实现。
  1.    protectedabstractObject createBean(String beanName,RootBeanDefinition mbd,Object[] args)
  2.            throwsBeanCreationException;

3. AbstractAutowireCapableBeanFactory.java

  1. // 创建 bean 实例
  2. @Override
  3. protectedObject createBean(finalString beanName,finalRootBeanDefinition mbd,finalObject[] args)
  4.        throwsBeanCreationException{

  5.    if(logger.isDebugEnabled()){
  6.        logger.debug("Creating instance of bean '"+ beanName +"'");
  7.    }
  8.    // Make sure bean class is actually resolved at this point.
  9.    // 解析和确定 bean 可以实例化
  10.    resolveBeanClass(mbd, beanName);

  11.    // Prepare method overrides.
  12.    // 准备方法覆盖
  13.    try{
  14.        mbd.prepareMethodOverrides();
  15.    }
  16.    catch(BeanDefinitionValidationException ex){
  17.        thrownewBeanDefinitionStoreException(mbd.getResourceDescription(),
  18.                beanName,"Validation of method overrides failed", ex);
  19.    }

  20.    try{
  21.        // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
  22.        // 给 Bean 处理器 一个机会, 返回一个目标 bean 实例
  23.        Object bean = resolveBeforeInstantiation(beanName, mbd);
  24.        if(bean !=null){
  25.            return bean;
  26.        }
  27.    }
  28.    catch(Throwable ex){
  29.        thrownewBeanCreationException(mbd.getResourceDescription(), beanName,
  30.                "BeanPostProcessor before instantiation of bean failed", ex);
  31.    }

  32.    Object beanInstance = doCreateBean(beanName, mbd, args);
  33.    if(logger.isDebugEnabled()){
  34.        logger.debug("Finished creating instance of bean '"+ beanName +"'");
  35.    }
  36.    return beanInstance;
  37. }
总结以下它都做了什么:
  1. 确定 beanName和 RootBeanDefinition可以被实例化。
  2. 执行方法覆盖
  3. 看 BeanPostProcessors能否再解析之前获取到 bean,如果能则直接返回,否则下一步。
  4. 调用 doCreateBean()方法,获取 bean实例.
doCreateBean()方法也是该类中的。
  1. // 真正创建 bean 实例
  2. protectedObject doCreateBean(finalString beanName,finalRootBeanDefinition mbd,finalObject[] args){
  3.    // Instantiat|e the bean.
  4.    // 封装 bean
  5.    BeanWrapper instanceWrapper =null;
  6.    if(mbd.isSingleton()){
  7.        // 如果是单例模式的 bean,从容器中获取同名 bean
  8.        instanceWrapper =this.factoryBeanInstanceCache.remove(beanName);
  9.    }
  10.    // 如果没有同名 bean, 则创建 bean 实例
  11.    if(instanceWrapper ==null){
  12.        instanceWrapper = createBeanInstance(beanName, mbd, args);
  13.    }
  14.    // 如果有同名 bean, 则获取到封装实例
  15.    finalObject bean =(instanceWrapper !=null? instanceWrapper.getWrappedInstance():null);
  16.    // 获取实例化对象类型
  17.    Class beanType =(instanceWrapper !=null? instanceWrapper.getWrappedClass():null);

  18.    // Allow post-processors to modify the merged bean definition.
  19.    // 调用后置处理器
  20.    synchronized(mbd.postProcessingLock){
  21.        if(!mbd.postProcessed){
  22.            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
  23.            mbd.postProcessed =true;
  24.        }
  25.    }

  26.    // Eagerly cache singletons to be able to resolve circular references
  27.    // even when triggered by lifecycle interfaces like BeanFactoryAware.
  28.    boolean earlySingletonExposure =(mbd.isSingleton()&&this.allowCircularReferences &&
  29.            isSingletonCurrentlyInCreation(beanName));
  30.    if(earlySingletonExposure){
  31.        if(logger.isDebugEnabled()){
  32.            logger.debug("Eagerly caching bean '"+ beanName +
  33.                    "' to allow for resolving potential circular references");
  34.        }
  35.        addSingletonFactory(beanName,newObjectFactory(){
  36.            publicObject getObject()throwsBeansException{
  37.                return getEarlyBeanReference(beanName, mbd, bean);
  38.            }
  39.        });
  40.    }

  41.    // Initialize the bean instance.
  42.    // bean 对象初始化, 依赖注入开始,exposedObject 就是完成后的 bean
  43.    Object exposedObject = bean;
  44.    try{
  45.        // 将 bean 实例封装, 并且 bean 定义中配置的属性值赋值给实例对象
  46.        populateBean(beanName, mbd, instanceWrapper);
  47.        // 初始化 bean 对象
  48.        exposedObject = initializeBean(beanName, exposedObject, mbd);
  49.    }
  50.    catch(Throwable ex){
  51.        if(ex instanceofBeanCreationException&& beanName.equals(((BeanCreationException) ex).getBeanName())){
  52.            throw(BeanCreationException) ex;
  53.        }
  54.        else{
  55.            thrownewBeanCreationException(mbd.getResourceDescription(), beanName,"Initialization of bean failed", ex);
  56.        }
  57.    }

  58.    // 如果指定名称 bean 已经注册单例模式
  59.    if(earlySingletonExposure){
  60.        Object earlySingletonReference = getSingleton(beanName,false);
  61.        if(earlySingletonReference !=null){
  62.            if(exposedObject == bean){
  63.                // 如果两个对象相等, bean 初始化完成
  64.                exposedObject = earlySingletonReference;
  65.            }
  66.            // 如果不相等, 则找出当前 bean 的依赖 bean
  67.            elseif(!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)){
  68.                String[] dependentBeans = getDependentBeans(beanName);
  69.                Set<String> actualDependentBeans =newLinkedHashSet<String>(dependentBeans.length);
  70.                for(String dependentBean : dependentBeans){
  71.                    // 检查依赖 bean (是否继承接口,是否是父子关系。。)
  72.                    if(!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)){
  73.                        actualDependentBeans.add(dependentBean);
  74.                    }
  75.                }
  76.                if(!actualDependentBeans.isEmpty()){
  77.                    thrownewBeanCurrentlyInCreationException(beanName,
  78.                            "Bean with name '"+ beanName +"' has been injected into other beans ["+
  79.                            StringUtils.collectionToCommaDelimitedString(actualDependentBeans)+
  80.                            "] in its raw version as part of a circular reference, but has eventually been "+
  81.                            "wrapped. This means that said other beans do not use the final version of the "+
  82.                            "bean. This is often the result of over-eager type matching - consider using "+
  83.                            "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
  84.                }
  85.            }
  86.        }
  87.    }

  88.    // Register bean as disposable.
  89.    // 注册完成依赖注入的 bean
  90.    try{
  91.        registerDisposableBeanIfNecessary(beanName, bean, mbd);
  92.    }
  93.    catch(BeanDefinitionValidationException ex){
  94.        thrownewBeanCreationException(mbd.getResourceDescription(), beanName,"Invalid destruction signature", ex);
  95.    }

  96.    return exposedObject;
  97. }
同样,总结以下它干的事情:
  1. 根据 beanName获取 beanWrapper对象。如果 beanWrapper对象是空,则调用 createBeanInstance()方法创建 bean实例。否则,下一步
  2. 通过 beanWrapper对象获取 bean 实例和 class类型。
  3. 允许 postProcessors 调整组合 BeanDefinition
  4. 如果 RootBeanDefinition是单例并且允许循环引用并且 beanName正在进行单例创建,将 beanName添加到单例工厂。
  5. 调用 populateBean()方法给 bean 的属性值赋值,然后初始化 bean 对象并返回创建的 bean 实例,如果抛异常,则下一步。
  6. 如果该 beanName对象已经注册单例模式,则从单例中获取,并判断获取到的 bean 实例( B)与 BeanWrapper中的 bean 实例( A)是同一个实例,如果是,则返回 A或者 B,如果不是,则递归找出它的依赖 bean
  7. 返回 1-6产生的 bean实例。
我们首次获取 bean 实例的时候,bean 工厂是肯定没有的,所以我们首次获取到的 BeanWrapper 应该是空对象,但是它调用了 createBeanInstance()方法后,可以看到 spring 是很确定它能拿到对象,那么我们看看这个方法的实现。它仍然是这个类中的方法。
  1. protectedBeanWrapper createBeanInstance(String beanName,RootBeanDefinition mbd,Object[] args){
  2.    // Make sure bean class is actually resolved at this point.
  3.    // 确保 bean 可实例化(不能是抽象类等)
  4.    Class beanClass = resolveBeanClass(mbd, beanName);

  5.    // 如果这个 bean 不是 public 修饰符或者不被允许公共访问, 抛出异常
  6.    if(beanClass !=null&&!Modifier.isPublic(beanClass.getModifiers())&&!mbd.isNonPublicAccessAllowed()){
  7.        thrownewBeanCreationException(mbd.getResourceDescription(), beanName,
  8.                "Bean class isn't public, and non-public access not allowed: "+ beanClass.getName());
  9.    }

  10.    if(mbd.getFactoryMethodName()!=null)  {
  11.        // 通过工厂方法实例化
  12.        return instantiateUsingFactoryMethod(beanName, mbd, args);
  13.    }

  14.    // Shortcut when re-creating the same bean...
  15.    // 是否有构造器
  16.    if(mbd.resolvedConstructorOrFactoryMethod !=null&& args ==null){
  17.        if(mbd.constructorArgumentsResolved){
  18.            return autowireConstructor(beanName, mbd,null,null);
  19.        }
  20.        else{
  21.            return instantiateBean(beanName, mbd);
  22.        }
  23.    }

  24.    // Need to determine the constructor...
  25.    // 需要确认构造器
  26.    Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
  27.    if(ctors !=null||
  28.            mbd.getResolvedAutowireMode()==RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
  29.            mbd.hasConstructorArgumentValues()||!ObjectUtils.isEmpty(args))  {
  30.        // 自动装配,调用匹配的构造方法进行实例化
  31.        return autowireConstructor(beanName, mbd, ctors, args);
  32.    }

  33.    // No special handling: simply use no-arg constructor.
  34.    // 使用默认无参构造
  35.    return instantiateBean(beanName, mbd);
  36. }
这个类用来创建 Bean实例,然后返回 BeanWrapper对象。注释写的很详细了。其中有个 instantiateBean()方法,当没有参数和构造方法的时候,就会调用该方法来实例化 bean。
  1. // 使用默认无参构造方法实例化 bean
  2. protectedBeanWrapper instantiateBean(finalString beanName,finalRootBeanDefinition mbd){
  3.    try{
  4.        Object beanInstance;
  5.        finalBeanFactory parent =this;
  6.        // 获取 JDK 安全管理
  7.        if(System.getSecurityManager()!=null){
  8.            // 根据实例化策略实例化对象
  9.            beanInstance =AccessController.doPrivileged(newPrivilegedAction<Object>(){

  10.                publicObject run(){
  11.                    return getInstantiationStrategy().instantiate(mbd, beanName, parent);
  12.                }
  13.            }, getAccessControlContext());
  14.        }
  15.        else{
  16.            beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
  17.        }
  18.        // 对实例化对象进行封装
  19.        BeanWrapper bw =newBeanWrapperImpl(beanInstance);
  20.        initBeanWrapper(bw);
  21.        return bw;
  22.    }
  23.    catch(Throwable ex){
  24.        thrownewBeanCreationException(mbd.getResourceDescription(), beanName,"Instantiation of bean failed", ex);
  25.    }
  26. }
这个方法是使用默认无参构造方法实例化 bean 的,它的核心代码是 getInstantiationStrategy().instantiate(mbd,beanName,parent);,因为它,我们可以得到一个 bean 实例对象,然后封装成 BeanWrapper并返回。

4. SimpleInstantiationStrategy.java

用于 BeanFactory 的简单对象实例化策略。不支持方法注入,尽管它提供了子类的 hook 来覆盖以添加方法注入支持,例如通过重写方法。
  1. // 使用初始化策略 实例化 bean
  2. publicObject instantiate(
  3.        RootBeanDefinition beanDefinition,String beanName,BeanFactory owner){

  4.    // Don't override the class with CGLIB if no overrides.
  5.    // 如果 beanDefinition 中没有方法覆盖, 就用 jdk,否则用 cglib
  6.    if(beanDefinition.getMethodOverrides().isEmpty()){
  7.        // 获取对象的构造方法和工厂方法
  8.        Constructor constructorToUse =(Constructor) beanDefinition.resolvedConstructorOrFactoryMethod;

  9.        if(constructorToUse ==null){
  10.            // 如果 没有构造方法和工厂方法, 使用 JDK 反射, 判断实例化的 bean 是不是接口
  11.            finalClass clazz = beanDefinition.getBeanClass();
  12.            if(clazz.isInterface()){
  13.                thrownewBeanInstantiationException(clazz,"Specified class is an interface");
  14.            }
  15.            try{
  16.                if(System.getSecurityManager()!=null){
  17.                    // 使用反射获取 bean 构造方法
  18.                    constructorToUse =AccessController.doPrivileged(newPrivilegedExceptionAction<Constructor>(){
  19.                        publicConstructor run()throwsException{
  20.                            return clazz.getDeclaredConstructor((Class[])null);
  21.                        }
  22.                    });
  23.                }else{
  24.                    constructorToUse =  clazz.getDeclaredConstructor((Class[])null);
  25.                }
  26.                beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
  27.            }
  28.            catch(Exception ex){
  29.                thrownewBeanInstantiationException(clazz,"No default constructor found", ex);
  30.            }
  31.        }
  32.        // 使用 beanUtils 实例化   构造方法.newInstance(arg) 来实例化
  33.        returnBeanUtils.instantiateClass(constructorToUse);
  34.    }
  35.    else{
  36.        //如果 有覆盖或者重写, 则用 CGLIB 来实例化对象
  37.        // Must generate CGLIB subclass.
  38.        return instantiateWithMethodInjection(beanDefinition, beanName, owner);
  39.    }
  40. }
总结它的步骤:
  1. 如果 BeanDefinition 的覆盖方法不为空,则交给 CGLIB 来实例化对象,否则获取构造方法和工厂方法,下一步。
  2. 如果没有构造方法和工厂方法,则使用 JDK 反射,判断实例化的 bean 是不是接口,如果是,抛出异常,如果不是,则使用反射来获取 bean 的构造方法,最后,用 构造器.newInstance()的方法( BeanUtils.instantiateClass()方法底层实现)来实例化并返回。
那 cglib 是如何实例化呢,我们来看下 instantiateWithMethodInjection(beanDefinition,beanName,owner);方法源码:
  1. @Override
  2. protectedObject instantiateWithMethodInjection(
  3.        RootBeanDefinition beanDefinition,String beanName,BeanFactory owner){

  4.    // Must generate CGLIB subclass.
  5.    returnnewCglibSubclassCreator(beanDefinition, owner).instantiate(null,null);
  6. }
然后再跟进 CglibSubclassCreator(beanDefinition,owner).instantiate(null,null);方法:
  1. // 使用 cglib 来进行 bean 实例化
  2. publicObject instantiate(Constructor ctor,Object[] args){
  3.    // cglib
  4.    Enhancer enhancer =newEnhancer();
  5.    // bean 本身作为基类
  6.    enhancer.setSuperclass(this.beanDefinition.getBeanClass());
  7.    enhancer.setCallbackFilter(newCallbackFilterImpl());
  8.    enhancer.setCallbacks(newCallback[]{
  9.            NoOp.INSTANCE,
  10.            newLookupOverrideMethodInterceptor(),
  11.            newReplaceOverrideMethodInterceptor()
  12.    });

  13.    // 生成实例对象
  14.    return(ctor ==null)?
  15.            enhancer.create():
  16.            enhancer.create(ctor.getParameterTypes(), args);
  17. }
从上面代码可以看到,这就是 CGLIB 动态代理中创建代理的过程代码,不熟悉的可以往前翻 彻底搞懂动态代理章节的内容。
好了,到了这里,Spring 就完成了 bean 实例的创建,但是此时就能拿着这个实例去使用吗,显然是不可以,因为属性还没有被赋入,下一章再继续介绍如何将属性依赖关系注入到 Bean 实例对象

丨极客文库, 版权所有丨如未注明 , 均为原创丨
本网站采用知识共享署名-非商业性使用-相同方式共享 3.0 中国大陆许可协议进行授权
转载请注明原文链接:彻底搞懂依赖注入(一)Bean 实例创建过程
喜欢 (0)
[247507792@qq.com]
分享 (0)
勤劳的小蚂蚁
关于作者:
温馨提示:本文来源于网络,转载文章皆标明了出处,如果您发现侵权文章,请及时向站长反馈删除。

欢迎 注册账号 登录 发表评论!

  • 精品技术教程
  • 编程资源分享
  • 问答交流社区
  • 极客文库知识库

客服QQ


QQ:2248886839


工作时间:09:00-23:00