• 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html
  • 极客专栏正式上线!欢迎访问 https://www.jikewenku.com/topic.html

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

技术杂谈 勤劳的小蚂蚁 3个月前 (01-13) 116次浏览 已收录 0个评论 扫描二维码

上一章介绍了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