风动草
风动草

Spring源码解析之DI篇

什么是DI？

DI（Dependency Injection）依赖注入：当对象内包含对其他对象的引用时，Spring会帮我们创建或定义这些依赖对象，而无需知道依赖对象的位置甚至具体实现类，实现更有效的解耦。

既然已经知道什么是依赖注入，那么按照探究问题的准则，首先我们会想：依赖注入是什么时候开始的？又是怎么注入的？同时简单考虑下如果是自己会大概怎么去实现（不考虑细节）。比如我们知道IOC容器中保存了Bean对象，那么一个对象的属性依赖对象能不能直接从容器中拿然后赋值？根据容器中保存的beanName去拿？或者如果容器中没有，是不是要另外创建然后引用赋值过来？这样的话，是不是得先判断这个属性是不是Bean对象？还有如果新创建的对象中又有属性依赖其他对象怎么办？递归？等等。

不要觉得自己好像啥也想不出来或者肯定不对不敢随意猜，带着疑问去探究才会得到实际的印证，加深对本质的了解，而且你会更容易看的下去源码，所谓念念不忘，必有回响。

准备工作

接下来，我们先做一些准备工作，主要还是为了“眼熟”，提前熟悉一些解析源码时需要用到的知识点。

第一步：注入时机

也就是依赖注入是什么时候开始的？前一篇我们解析了Spring的IOC初始化流程，我们知道主要的流程在refresh()方法里面实现的，而解析加载注册主要发生在方法内的obtainFreshBeanFactory()中实现的，之后的代码中我们注意到finishBeanFactoryInitialization(beanFactory)这个方法，这个方法就是初始化所有剩余的单例Bean，点进去最后发现调用的是DefaultListableBeanFactory类中的preInstantiateSingletons()方法，我们看下源码，

    @Override
    public void preInstantiateSingletons() throws BeansException {
        if (this.logger.isDebugEnabled()) {
            this.logger.debug("Pre-instantiating singletons in " + this);
        }
        List beanNames = new ArrayList<>(this.beanDefinitionNames);
        for (String beanName : beanNames) {
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            //Bean满足非抽象类，单例，lazy-init属性为false
            if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                if (isFactoryBean(beanName)) {
                    final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX + beanName);
                    //是否预实例化
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                        isEagerInit = AccessController.doPrivileged((PrivilegedAction) () ->
                                ((SmartFactoryBean) factory).isEagerInit(),
                                getAccessControlContext());
                    }
                    else {
                        isEagerInit = (factory instanceof SmartFactoryBean &&
                                ((SmartFactoryBean) factory).isEagerInit());
                    }
                    if (isEagerInit) {
                        //调用getBean方法，触发容器对Bean实例化和依赖注入过程
                        getBean(beanName);
                    }
                }
                else {
                    getBean(beanName);
                }
            }
        }
        for (String beanName : beanNames) {
            Object singletonInstance = getSingleton(beanName);
            if (singletonInstance instanceof SmartInitializingSingleton) {
                final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
                if (System.getSecurityManager() != null) {
                    AccessController.doPrivileged((PrivilegedAction) () -> {
                        smartSingleton.afterSingletonsInstantiated();
                        return null;
                    }, getAccessControlContext());
                }
                else {
                    smartSingleton.afterSingletonsInstantiated();
                }
            }
        }
    }
 
 
这个方法是对配置lazy-init属性等于fasle的单例Bean的预实例化，我们看到到最后都调用了getBean()方法，它就是对Bean实例化和依赖注入过程，而具体更深入的探究我们后面会慢慢展开。
 
 
所以综上所述，我们知道了在IOC的初始化中其实包含了依赖注入的过程，同时通过对getBean()的延伸，进一步得到了第一个问题的答案，依赖注入的时机：
 
 
     
  
  •  非延迟加载的Bean： IOC初始化中对进行预实例化（也是调用getBean()方法）。
    •  
  
  •  延迟加载的Bean： 第一次调用getBean()方法时。
    •  
 
 
 
第二步：注入策略
 
 
Spring中注入策略有两种：
 
 
     
  
  •  有参构造方法注入： 带有参数的构造函数来完成实例化或者带参数的static工厂方法，因为需要对参数进行解析转换，所以过程复杂。
    •  
  
  •  无参构造方法注入： 默认实例化方法，例如使用setter方法注入，通过无参数构造函数或无参数的static工厂方法，过程简单。
    •  
 
 
 
第三步：自动装配方式
 
 
Spring官网中已经有详细的介绍，关于自动装配的方式有四种：
 
 
     
  
  •  no：默认没有自动装配，必须由ref配置Bean的引用。
    •  
  
  •  byName：根据属性名称在IOC容器中查找Bean，然后通过setter方法来注入属性（前提是必须有）。
    •  
  
  •  byType：根据属性类型在IOC容器中查找Bean，只存在一个才会注入，多个会引发异常，没有则不注入。
    •  
  
  •  constructor：根据构造函数的参数类型在IOC容器中查找Bean，没有则引发异常。
    •  
 
 
 
但是自动装配也有一些局限性和缺点，比如不能装配简单属性、不如显示装配准确、多个Bean会引发异常等，这些都在官方文档中有更详细的介绍。
 
 
第四步：关键类和属性
 
 
     
  
  •  
    缓存的属性：后面我们解析源码的时候会经常看到一些存储Bean的不同的数据结构，Map或Set，我们先熟悉下它们的用处：
     
   
       
    
    • Map singletonObjects：保存beanName和Bean实例之间的关系。
      •  
    
    • Map> singletonFactories：保存beanName和Bean工厂之间的关系。
      •  
    
    • Map earlySingletonObjects：保存beanName和Bean实例之间的关系，和singletonObjects不同的是，一个单例Bean还未创建完成前就被存放进去，且能通过getBean()方法拿到，主要目的是用于检查循环依赖。
      •  
    
    • Set registeredSingletons：保存当前所有已注册的Bean的beanName。
      •  
    
    • Set singletonsCurrentlyInCreation：保存当前正在创建中的Bean的beanName。
      •  
   
     
    •  
  
  •  
    FactoryBean：看到这个类，我们很容易想到BeanFactory，其实他两没有关系，IOC中我们已经了解BeanFactory是一个工厂的顶层接口，定义了IOC容器的基本行为，获取bean及bean的各种属性。而FactoryBean是一个工厂Bean接口，目的是用来隐藏复杂Bean的实例化细节，子类通过定制来实现实例化的逻辑，用来产生其他Bean实例。看下它的源码结构
     
   
     
    
     
     
      
     
     
    
     
    
    
      image-20210708213402792 
    
     
   
     
    其中getObject()方法会返回创建的Bean实例；getObjectType()返回创建的Bean类型；isSingleton()返回创建的Bean实例的作用域是否是单例，如果返回true，该Bean实例就会放到单例的缓存池中。
     
    •  
  
  • BeanWrapper：类似BeanDefinition一样，都对Bean的一种封装，但是它对Bean执行了一些操作，例如设置和检索属性。源码中实际使用的是它的实现类BeanWrapperImpl。
    •  
 
 
 
依赖注入流程
 
 
前面我们已经做了一些简单的了解，这也是为接下来解析源码过程而做的铺垫。开始前，我们先回忆下刚开头我们自己提的一些疑问（具体可以到上面再看下），接下来我们会带着这些疑问去探究。
 
 
 
 
 从无到有，那么我们还是要从入口开始，前面我们知道了依赖注入的入口就是从调用getBean()方法开始，看着很眼熟，再想想之前IOC中讲的BeanFactory顶级工厂不就是做这个事的吗，回顾它的源码发现，果然是它。 
 
 
  
 
   
  
   
 
  
 
  

    image-20210708213402792 
  
 
 
 
 
我们知道它是一个顶层接口，实现肯定是在它的子类中。顺着准备工作中介绍的DefaultListableBeanFactory类中的preInstantiateSingletons()方法中调用的getBean()方法，点进去我们发现实际调用的是AbstractBeanFactory的getBean()方法。
 
 
万事开头难，既然现在入口已经找到了，接下来的事就“简单”了。
 
 
首先点进去看源码，
 
 
    @Override
    public Object getBean(String name) throws BeansException {
        return doGetBean(name, null, null, false);
    }

    protected  T doGetBean(final String name, @Nullable final Class requiredType,
            @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
        //转换为真正的beanName
        final String beanName = transformedBeanName(name);
        Object bean;
        // 先从缓存中获取Bean
        Object sharedInstance = getSingleton(beanName);
        if (sharedInstance != null && args == null) {
            if (logger.isDebugEnabled()) {
                //是否是正在创建的单例Bean
                if (isSingletonCurrentlyInCreation(beanName)) {
                    logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
                            "' that is not fully initialized yet - a consequence of a circular reference");
                }
                else {
                    logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
                }
            }
            //获取真正需要的Bean
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        }
        else {
            //是否是正在创建的原型Bean
            if (isPrototypeCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(beanName);
            }
            //获取父容器
            BeanFactory parentBeanFactory = getParentBeanFactory();
            //父级容器不存在，且容器中不存在beanName的Bean
            if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
                //获取原始beanName
                String nameToLookup = originalBeanName(name);
                if (parentBeanFactory instanceof AbstractBeanFactory) {
                      // 递归调用
                    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                            nameToLookup, requiredType, args, typeCheckOnly);
                }
                else if (args != null) {
                    //到父容器中查找符合beanName和参数的Bean
                    return (T) parentBeanFactory.getBean(nameToLookup, args);
                }
                else {
                    //到父容器中查找符合beanName和类型的Bean
                    return parentBeanFactory.getBean(nameToLookup, requiredType);
                }
            }
            //Bean是否需要类型验证
            if (!typeCheckOnly) {
                markBeanAsCreated(beanName);
            }
            try {
                //RootBeanDefinition转换，合并父类的属性
                final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
                checkMergedBeanDefinition(mbd, beanName, args);
                //获取Bean所有依赖Bean的beanName
                String[] dependsOn = mbd.getDependsOn();
                if (dependsOn != null) {
                    for (String dep : dependsOn) {
                        if (isDependent(beanName, dep)) {
                            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
                        }
                        //注册缓存依赖的beanName
                        registerDependentBean(dep, beanName);
                        //递归调用
                        getBean(dep);
                    }
                }
                //创建单例Bean对象
                if (mbd.isSingleton()) {
                    sharedInstance = getSingleton(beanName, () -> {
                        try {
                            //创建Bean实例
                            return createBean(beanName, mbd, args);
                        }
                        catch (BeansException ex) {
                            //清除Bean实例
                            destroySingleton(beanName);
                            throw ex;
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }
                //创建原型Bean对象
                else if (mbd.isPrototype()) {
                    Object prototypeInstance = null;
                    try {
                        //创建前回调，默认实现将beanName注册为当前正在创建的原型Bean
                        beforePrototypeCreation(beanName);
                        prototypeInstance = createBean(beanName, mbd, args);
                    }
                    finally {
                        //创建后回调，默认实现移除刚注册的原型Bean的beanName
                        afterPrototypeCreation(beanName);
                    }
                    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
                }
                //创建的非单例、非原型的Bean
                else {
                    String scopeName = mbd.getScope();
                    final 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, () -> {
                            beforePrototypeCreation(beanName);
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            finally {
                                afterPrototypeCreation(beanName);
                            }
                        });
                        bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
                    }
                    catch (IllegalStateException ex) {
                        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",
                                ex);
                    }
                }
            }
            catch (BeansException ex) {
                cleanupAfterBeanCreationFailure(beanName);
                throw ex;
            }
        }
        //类型转换
        if (requiredType != null && !requiredType.isInstance(bean)) {
            try {
                T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
                if (convertedBean == null) {
                    throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
                }
                return convertedBean;
            }
            catch (TypeMismatchException ex) {
                if (logger.isDebugEnabled()) {
                    logger.debug("Failed to convert bean '" + name + "' to required type '" +
                            ClassUtils.getQualifiedName(requiredType) + "'", ex);
                }
                throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
        }
        return (T) bean;
    }

 
 
从源码中看到，具体的实现都是在doGetBean()方法中，这里实现了从IOC容器中获取Bean以及触发依赖注入。乍一看，代码相当长，做了很多的处理和实现（是不是很晕），但不要慌，我们细水长流，一步一步往下看。通过上面代码注释我们大概知道了实现的逻辑以及大概的流程，下面我们梳理罗列下：
 
 
1.转换真正的beanName
 
 
为什么传入的beanName不能直接使用呢？因为这里传入的可能是别名（Alias），也可能是FactoryBean的beanName，所以需要转换，点进去可以看到怎么处理的，处理比较简单，这里就不贴源码了，简单说下，感兴趣的话可以点进去看看。
 
 
     
  
  • 首先如果是FactoryBean的话，去除特定&的修饰符，比如把&name变成name；
    •  
  
  • 拿到别名指向的最终beanName，比如别名A->别名B，别名B->别名C，最后返回的就是C。
    •  
 
 
 
2.从缓存中获取Bean
 
 
我们知道Spring的单例只会被创建一次，然后放在IOC容器中，之前我们是不是想过Bean能不能先从容器中拿？看来Spring确实做了这样的处理，这里缓存获取其实分成了两步：
 
 
     
  
  •  
    第一步：首先会调用getSingleton()方法，尝试从当前容器的缓存中去加载，如果能拿到，我们会直接执行第5步，也就是调用getObjectForBeanInstance()方法获取真正需要的Bean，这个方法的实现后面会详细解析；我们先看getSingleton()的源码实现，
     
      @Override
  @Nullable
  public Object getSingleton(String beanName) {
      return getSingleton(beanName, true);
  }

  @Nullable
  protected Object getSingleton(String beanName, boolean allowEarlyReference) {
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
          synchronized (this.singletonObjects) {
              singletonObject = this.earlySingletonObjects.get(beanName);
              if (singletonObject == null && allowEarlyReference) {
                  ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                  if (singletonFactory != null) {
                      singletonObject = singletonFactory.getObject();
                      this.earlySingletonObjects.put(beanName, singletonObject);
                      this.singletonFactories.remove(beanName);
                  }
              }
          }
      }
      return singletonObject;
  }

     
    首先会从singletonObjects中查找beanName对应的Bean对象，有就直接返回，没有的话同时当前beanName对应的Bean对象不是正在创建的单例，则从earlySingletonObjects中查找，如果还没有则再去singletonFactories中找对应的ObjectFactory，通过其getObject()方法获取Bean对象，同时将beanName和Bean对象缓存到earlySingletonObjects，并从singletonFactories移除beanName和ObjectFactory的对应关系。前面准备工作的关键属性中我们已经知道了这几个属性所代表的含义，但是可能有一些疑问，ObjectFactory有什么用？
     
    ObjectFactory：从名字能猜到是一个对象工厂接口，通过它可以返回对象的实例，实际也是这样；是不是感觉类似于FactoryBean，都是通过getObject()返回对象实例，但是ObjectFactory基于SPI机制（服务发现机制），它的实现类作为 API 提供给其他 bean（通过注入）。它们其实相当于BeanFactory的封装，实现类的getObject()最后调用的还是BeanFactory的getBean()方法去实例化对象。
     
    和beanName的关系是什么时候保存的？
     
    缓存的时间：Spring中为了避免循环依赖，在创建Bean的时候不等Bean创建完成就讲ObjectFactory提前存放到缓存中去，后面的Bean创建是需要依赖这个Bean，就能直接使用ObjectFactory。（循环依赖的处理在依赖注入中很常见，下一篇会单独解析）
     
    同时我们看到这里通过synchronized关键字来保证证线程安全（想想之前IOC的初始化，不难发现，Spring对于Bean的频繁创建的一些相关信息缓存都通过synchronized来保证线程安全，确保容器内数据的一致性，后面我们也能经常看到）
     
    •  
  
  •  
    第二步：第一步缓存没有拿到Bean的话，就会再从当前容器的存在的父容器的缓存中去加载，看下源码，
     
      // 判断循环依赖
  if (isPrototypeCurrentlyInCreation(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
  }
  BeanFactory parentBeanFactory = getParentBeanFactory();
  if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
      //转换beanName
      String nameToLookup = originalBeanName(name);
      if (parentBeanFactory instanceof AbstractBeanFactory) {
          return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                  nameToLookup, requiredType, args, typeCheckOnly);
      }
      else if (args != null) {
          //根据名称和显式的参数查找
          return (T) parentBeanFactory.getBean(nameToLookup, args);
      }
      else {
          //根据名称和类型查找
          return parentBeanFactory.getBean(nameToLookup, requiredType);
      }
  }

     
    •  
 
 
 
我们看到会根据两种方式去查找：beanName和参数、beanName和类型，其实就是递归调用getBean()方法。不过查找前，需要判断如果当前beanName对应的Bean是正在创建的原型Bean，则会抛出循环依赖异常。
 
 
3.对依赖的Bean先进行初始化
 
 
先转换获得RootBeanDefinition，同时合并父类的属性；然后判断当前Bean内是否有依赖的Bean，如果有则如下遍历处理：
 
 
    String[] dependsOn = mbd.getDependsOn();
    if (dependsOn != null) {
        for (String dep : dependsOn) {
            if (isDependent(beanName, dep)) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
            }
            registerDependentBean(dep, beanName);
            getBean(dep);
        }
    }

    public void registerDependentBean(String beanName, String dependentBeanName) {
        //beanName转换
        String canonicalName = canonicalName(beanName);
        Set dependentBeans = this.dependentBeanMap.get(canonicalName);
        if (dependentBeans != null && dependentBeans.contains(dependentBeanName)) {
            return;
        }
         // 保证证线程安全，缓存到dependentBeanMap
        synchronized (this.dependentBeanMap) {
            dependentBeans = this.dependentBeanMap.get(canonicalName);
            if (dependentBeans == null) {
                dependentBeans = new LinkedHashSet<>(8);
                this.dependentBeanMap.put(canonicalName, dependentBeans);
            }
            dependentBeans.add(dependentBeanName);
        }
        // 保证证线程安全，缓存到dependenciesForBeanMap
        synchronized (this.dependenciesForBeanMap) {
            Set dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
            if (dependenciesForBean == null) {
                dependenciesForBean = new LinkedHashSet<>(8);
                this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
            }
            dependenciesForBean.add(canonicalName);
        }
    }

 
 
     
  
  • Bean和依赖的Bean互相缓存beanName：注册依赖的beanName到缓存Map> dependentBeanMap（beanName-->依赖Bean的beanName的集合）中去，同时也将当前beanName注册到缓存Map> dependenciesForBeanMap（beanName --> 被依赖Bean的beanName）中去。
    •  
  
  • 创建初始化：递归调用getBean()先创建依赖的Bean并初始化。
    •  
 
 
 
4.根据不同Scope的Bean进行实例化(重点)
 
 
我们知道Spring有存在不同的作用域，默认是单例而已；这里需要根据Scope来选择不同的实例化策略，比如prototype、request、session、application等。他们都是通过调用createBean()方法来完成创建Bean对象实例的，它是Bean注入的重点，后面主要也是围绕这个方法来深入解析。
 
 
解析createBean()源码之前，细心的小伙伴可能发现，除了单例Bean之外，prototype以及其他作用域的实例化，在调用createBean()的前后，分别回调了beforePrototypeCreation()、afterPrototypeCreation()方法，那它们是做什么的呢？回想一下我们之前从缓存中尝试加载Bean的时候是不是判断过isSingletonCurrentlyInCreation()、isPrototypeCurrentlyInCreation()这两个方法，前面是判断单例的，后面是原型的，而原型判断的来源就是这两个回调方法，我们再看下它们的源码，
 
 
    protected void beforePrototypeCreation(String beanName) {
        Object curVal = this.prototypesCurrentlyInCreation.get();
        if (curVal == null) {
            this.prototypesCurrentlyInCreation.set(beanName);
        }
        else if (curVal instanceof String) {
            Set beanNameSet = new HashSet<>(2);
            beanNameSet.add((String) curVal);
            beanNameSet.add(beanName);
            this.prototypesCurrentlyInCreation.set(beanNameSet);
        }
        else {
            Set beanNameSet = (Set) curVal;
            beanNameSet.add(beanName);
        }
    }

    protected void afterPrototypeCreation(String beanName) {
        Object curVal = this.prototypesCurrentlyInCreation.get();
        if (curVal instanceof String) {
            this.prototypesCurrentlyInCreation.remove();
        }
        else if (curVal instanceof Set) {
            Set beanNameSet = (Set) curVal;
            beanNameSet.remove(beanName);
            if (beanNameSet.isEmpty()) {
                this.prototypesCurrentlyInCreation.remove();
            }
        }
    }

 
 
实现很容易理解，就是创建前把创建的Bean的beanName放到prototypesCurrentlyInCreation缓存中，创建完成后再去缓存中删除。但这里的实现代码你是不是有点感觉不太的地方？之前我们讲过Spring对于Bean的频繁创建的缓存都通过synchronized来保证线程安全，确保容器内数据的一致性，这里没有加锁，难道不会产生线程安全的问题吗？！没错，这里肯定也要保住线程安全，查看prototypesCurrentlyInCreation的属性，我们才发现原来它是ThreadLocal啊，它是线程局部变量，为每个线程提供变量的独立副本；与synchronized加锁的方式不同，它是使用空间换时间的方式，通过隔离其他线程来保障数据安全。
 
 
讲完这个小前奏，那我们开始解析createBean()的源码了。
 
 
    @Override
    protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
            throws BeanCreationException {
        if (logger.isDebugEnabled()) {
            logger.debug("Creating instance of bean '" + beanName + "'");
        }
        RootBeanDefinition mbdToUse = mbd;
         // 解析Class
        Class resolvedClass = resolveBeanClass(mbd, beanName);
        if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
            mbdToUse = new RootBeanDefinition(mbd);
            mbdToUse.setBeanClass(resolvedClass);
        }
        try {
             // 标记Bean中的方法是否重载
            mbdToUse.prepareMethodOverrides();
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                    beanName, "Validation of method overrides failed", ex);
        }
        try {
            //解析Bean配置的实例化前后处理器
            Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
            if (bean != null) {
                return bean;
            }
        }
        catch (Throwable ex) {
            throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                    "BeanPostProcessor before instantiation of bean failed", ex);
        }
        try {
            //创建Bean
            Object beanInstance = doCreateBean(beanName, mbdToUse, args);
            if (logger.isDebugEnabled()) {
                logger.debug("Finished creating instance of bean '" + beanName + "'");
            }
            return beanInstance;
        }
        catch (BeanCreationException ex) {
            throw ex;
        }
        catch (ImplicitlyAppearedSingletonException ex) {
            throw ex;
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
        }
    }

 
 
通过上面代码，能看到创建Bean前做了一些准备：
 
 
     
  
  1. resolveBeanClass()：根据Bean的Class属性和beanName解析Class，没有则通过类加载器将beanName名称解析为类引用存放到BeanDefinition中用于后续使用；
    2.  
  
  2. prepareMethodOverrides()：判断Bean中的方法是否重载，如果不重载就将MethodOverride的overloaded属性标记为false，以避免参数类型检查的开销，主要后面在AOP代理中会用到；
    3.  
  
  3. resolveBeforeInstantiation()：这其实是一个短路判断，如果Bean配置了前后处理器，并且调用applyBeanPostProcessorsBeforeInstantiation()返回的对象不为空（实质是调用InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()方法返回经过处理的代理Bean），则会调用applyBeanPostProcessorsAfterInitialization方法直接完成初始化，不需要进行常规的Bean创建流程。
    4.  
 
 
 
而我们需要关注的具体实现其实是在doCreateBean()方法中，
 
 
    protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
            throws BeanCreationException {
        BeanWrapper instanceWrapper = null;
        if (mbd.isSingleton()) {
            instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
        }
        if (instanceWrapper == null) {
             // 创建Bean对象
            instanceWrapper = createBeanInstance(beanName, mbd, args);
        }
        final Object bean = instanceWrapper.getWrappedInstance();
        Class beanType = instanceWrapper.getWrappedClass();
        if (beanType != NullBean.class) {
            mbd.resolvedTargetType = beanType;
        }
        synchronized (mbd.postProcessingLock) {
            if (!mbd.postProcessed) {
                try {
                      // 调用后置处理器，合并Bean的定义
                    applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                            "Post-processing of merged bean definition failed", ex);
                }
                mbd.postProcessed = true;
            }
        }
        boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                isSingletonCurrentlyInCreation(beanName));
        if (earlySingletonExposure) {
            if (logger.isDebugEnabled()) {
                logger.debug("Eagerly caching bean '" + beanName +
                        "' to allow for resolving potential circular references");
            }
            //提前缓存Bean
            addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
        }
        Object exposedObject = bean;
        try {
            //属性注入
            populateBean(beanName, mbd, instanceWrapper);
            //初始化Bean对象
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
        catch (Throwable ex) {
            if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
                throw (BeanCreationException) ex;
            }
            else {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
            }
        }
        if (earlySingletonExposure) {
            // 在缓存中加载Bean
            Object earlySingletonReference = getSingleton(beanName, false);
            if (earlySingletonReference != null) {
                // 已注册的Bean等于正在实例化的Bean，则初始化完成
                if (exposedObject == bean) {
                    exposedObject = earlySingletonReference;
                }
                else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                      // 检查当前Bean依赖的其他Bean如果还未被创建，则抛出循环依赖异常
                    String[] dependentBeans = getDependentBeans(beanName);
                    Set actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
                    for (String dependentBean : dependentBeans) {
                        if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                            actualDependentBeans.add(dependentBean);
                        }
                    }
                    if (!actualDependentBeans.isEmpty()) {
                        throw new BeanCurrentlyInCreationException(beanName,
                                "Bean with name '" + beanName + "' has been injected into other beans [" +
                                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                                "] in its raw version as part of a circular reference, but has eventually been " +
                                "wrapped. This means that said other beans do not use the final version of the " +
                                "bean. This is often the result of over-eager type matching - consider using " +
                                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
                    }
                }
            }
        }
        try {
             // 注册Bean
            registerDisposableBeanIfNecessary(beanName, bean, mbd);
        }
        catch (BeanDefinitionValidationException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
        }
        return exposedObject;
    }


 
 
通过这段源码，我们也比较清晰的看到了以下几个实现流程：
 
 
4.1.实例化Bean
 
 
首先，调用了createBeanInstance()方法，并且从返回值看到返回的是Bean创建后封装成的BeanWrapper对象，
 
 
    protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
        //解析Class
        Class beanClass = resolveBeanClass(mbd, beanName);
        if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                    "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
        }
        Supplier instanceSupplier = mbd.getInstanceSupplier();
        if (instanceSupplier != null) {
             //自定义Supplier实例化
            return obtainFromSupplier(instanceSupplier, beanName);
        }
        if (mbd.getFactoryMethodName() != null)  {
            //工厂方法实例化
            return instantiateUsingFactoryMethod(beanName, mbd, args);
        }
        boolean resolved = false;
        boolean autowireNecessary = false;
        if (args == null) {
            synchronized (mbd.constructorArgumentLock) {
                if (mbd.resolvedConstructorOrFactoryMethod != null) {
                    resolved = true;
                    autowireNecessary = mbd.constructorArgumentsResolved;
                }
            }
        }
        if (resolved) {
            if (autowireNecessary) {
                //有参构造方法实例化
                return autowireConstructor(beanName, mbd, null, null);
            }
            else {
                //无参构造方法实例化
                return instantiateBean(beanName, mbd);
            }
        }
        Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
        if (ctors != null ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
                mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {
            //有参构造方法实例化
            return autowireConstructor(beanName, mbd, ctors, args);
        }
        //无参构造方法实例化
        return instantiateBean(beanName, mbd);
    }

 
 
从源码看到，这里Spring提供了四种Bean对象的实例化策略：
 
 
     
  
  •  
    自定义Supplier实例化：如果你点进去看Supplier源码可能有点蒙，仅仅通过get()去获取一个Bean对象，也没有定义的实现类。
     
    @FunctionalInterface
public interface Supplier {

    /**
     * Gets a result.
     *
     * @return a result
     */
    T get();
}

     
    其实很简单，我用AnnotationConfigApplicaitonContext为例写个简单的Demo，就清楚了。
     
    public Class Demo{
    public static void main(String args[]){
      AnnotationConfigApplicaitonContext ac = new AnnotationConfigApplicaitonContext();
      ac.registerBean(User.class, new Supplier(){
          @Override
          public Person get() {
              return new Person("哈哈");
          }
      });
          Person p = ac.getBean(Person.class);
  }
}
public Person{
    
    private String name;
    
    public Person(String name){
         this.name = name;
    }

}


     
    •  
  
  •  
    工厂方法实例化：先贴一下源码，
     
      protected BeanWrapper instantiateUsingFactoryMethod(
          String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
      return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
  }

  public BeanWrapper instantiateUsingFactoryMethod(
          final String beanName, final RootBeanDefinition mbd, @Nullable final Object[] explicitArgs) {
      BeanWrapperImpl bw = new BeanWrapperImpl();
      this.beanFactory.initBeanWrapper(bw);
      Object factoryBean;
      Class factoryClass;
      boolean isStatic;
      String factoryBeanName = mbd.getFactoryBeanName();
      if (factoryBeanName != null) {
          if (factoryBeanName.equals(beanName)) {
              throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                      "factory-bean reference points back to the same bean definition");
          }
          factoryBean = this.beanFactory.getBean(factoryBeanName);
          if (mbd.isSingleton() && this.beanFactory.containsSingleton(beanName)) {
              throw new ImplicitlyAppearedSingletonException();
          }
          factoryClass = factoryBean.getClass();
          isStatic = false;
      }
      else {
          if (!mbd.hasBeanClass()) {
              throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                      "bean definition declares neither a bean class nor a factory-bean reference");
          }
          factoryBean = null;
          factoryClass = mbd.getBeanClass();
          isStatic = true;
      }
      Method factoryMethodToUse = null;
      ArgumentsHolder argsHolderToUse = null;
      Object[] argsToUse = null;
      if (explicitArgs != null) {
          argsToUse = explicitArgs;
      }
      else {
          Object[] argsToResolve = null;
          synchronized (mbd.constructorArgumentLock) {
              factoryMethodToUse = (Method) mbd.resolvedConstructorOrFactoryMethod;
              if (factoryMethodToUse != null && mbd.constructorArgumentsResolved) {
                  // Found a cached factory method...
                  argsToUse = mbd.resolvedConstructorArguments;
                  if (argsToUse == null) {
                      argsToResolve = mbd.preparedConstructorArguments;
                  }
              }
          }
          if (argsToResolve != null) {
              argsToUse = resolvePreparedArguments(beanName, mbd, bw, factoryMethodToUse, argsToResolve);
          }
      }
      if (factoryMethodToUse == null || argsToUse == null) {
          // Need to determine the factory method...
          // Try all methods with this name to see if they match the given arguments.
          factoryClass = ClassUtils.getUserClass(factoryClass);
          Method[] rawCandidates = getCandidateMethods(factoryClass, mbd);
          List candidateSet = new ArrayList<>();
          for (Method candidate : rawCandidates) {
              if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate)) {
                  candidateSet.add(candidate);
              }
          }
          Method[] candidates = candidateSet.toArray(new Method[candidateSet.size()]);
          AutowireUtils.sortFactoryMethods(candidates);
          ConstructorArgumentValues resolvedValues = null;
          boolean autowiring = (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
          int minTypeDiffWeight = Integer.MAX_VALUE;
          Set ambiguousFactoryMethods = null;
          int minNrOfArgs;
          if (explicitArgs != null) {
              minNrOfArgs = explicitArgs.length;
          }
          else {
              // We don't have arguments passed in programmatically, so we need to resolve the
              // arguments specified in the constructor arguments held in the bean definition.
              if (mbd.hasConstructorArgumentValues()) {
                  ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
                  resolvedValues = new ConstructorArgumentValues();
                  minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
              }
              else {
                  minNrOfArgs = 0;
              }
          }
          LinkedList causes = null;
          for (Method candidate : candidates) {
              Class[] paramTypes = candidate.getParameterTypes();
              if (paramTypes.length >= minNrOfArgs) {
                  ArgumentsHolder argsHolder;
                  if (explicitArgs != null){
                      if (paramTypes.length != explicitArgs.length) {
                          continue;
                      }
                      argsHolder = new ArgumentsHolder(explicitArgs);
                  }
                  else {
                      try {
                          String[] paramNames = null;
                          ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                          if (pnd != null) {
                              paramNames = pnd.getParameterNames(candidate);
                          }
                          argsHolder = createArgumentArray(
                                  beanName, mbd, resolvedValues, bw, paramTypes, paramNames, candidate, autowiring);
                      }
                      catch (UnsatisfiedDependencyException ex) {
                          if (this.beanFactory.logger.isTraceEnabled()) {
                              this.beanFactory.logger.trace("Ignoring factory method [" + candidate +
                                      "] of bean '" + beanName + "': " + ex);
                          }
                          // Swallow and try next overloaded factory method.
                          if (causes == null) {
                              causes = new LinkedList<>();
                          }
                          causes.add(ex);
                          continue;
                      }
                  }
                  int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                          argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
                  if (typeDiffWeight < minTypeDiffWeight) {
                      factoryMethodToUse = candidate;
                      argsHolderToUse = argsHolder;
                      argsToUse = argsHolder.arguments;
                      minTypeDiffWeight = typeDiffWeight;
                      ambiguousFactoryMethods = null;
                  }
                  else if (factoryMethodToUse != null && typeDiffWeight == minTypeDiffWeight &&
                          !mbd.isLenientConstructorResolution() &&
                          paramTypes.length == factoryMethodToUse.getParameterCount() &&
                          !Arrays.equals(paramTypes, factoryMethodToUse.getParameterTypes())) {
                      if (ambiguousFactoryMethods == null) {
                          ambiguousFactoryMethods = new LinkedHashSet<>();
                          ambiguousFactoryMethods.add(factoryMethodToUse);
                      }
                      ambiguousFactoryMethods.add(candidate);
                  }
              }
          }
          if (factoryMethodToUse == null) {
              if (causes != null) {
                  UnsatisfiedDependencyException ex = causes.removeLast();
                  for (Exception cause : causes) {
                      this.beanFactory.onSuppressedException(cause);
                  }
                  throw ex;
              }
              List argTypes = new ArrayList<>(minNrOfArgs);
              if (explicitArgs != null) {
                  for (Object arg : explicitArgs) {
                      argTypes.add(arg != null ? arg.getClass().getSimpleName() : "null");
                  }
              }
              else if (resolvedValues != null){
                  Set valueHolders = new LinkedHashSet<>(resolvedValues.getArgumentCount());
                  valueHolders.addAll(resolvedValues.getIndexedArgumentValues().values());
                  valueHolders.addAll(resolvedValues.getGenericArgumentValues());
                  for (ValueHolder value : valueHolders) {
                      String argType = (value.getType() != null ? ClassUtils.getShortName(value.getType()) :
                              (value.getValue() != null ? value.getValue().getClass().getSimpleName() : "null"));
                      argTypes.add(argType);
                  }
              }
              String argDesc = StringUtils.collectionToCommaDelimitedString(argTypes);
              throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                      "No matching factory method found: " +
                      (mbd.getFactoryBeanName() != null ?
                          "factory bean '" + mbd.getFactoryBeanName() + "'; " : "") +
                      "factory method '" + mbd.getFactoryMethodName() + "(" + argDesc + ")'. " +
                      "Check that a method with the specified name " +
                      (minNrOfArgs > 0 ? "and arguments " : "") +
                      "exists and that it is " +
                      (isStatic ? "static" : "non-static") + ".");
          }
          else if (void.class == factoryMethodToUse.getReturnType()) {
              throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                      "Invalid factory method '" + mbd.getFactoryMethodName() +
                      "': needs to have a non-void return type!");
          }
          else if (ambiguousFactoryMethods != null) {
              throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                      "Ambiguous factory method matches found in bean '" + beanName + "' " +
                      "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                      ambiguousFactoryMethods);
          }
          if (explicitArgs == null && argsHolderToUse != null) {
              argsHolderToUse.storeCache(mbd, factoryMethodToUse);
          }
      }
      try {
          Object beanInstance;
          if (System.getSecurityManager() != null) {
              final Object fb = factoryBean;
              final Method factoryMethod = factoryMethodToUse;
              final Object[] args = argsToUse;
              beanInstance = AccessController.doPrivileged((PrivilegedAction) () ->
                      beanFactory.getInstantiationStrategy().instantiate(mbd, beanName, beanFactory, fb, factoryMethod, args),
                      beanFactory.getAccessControlContext());
          }
          else {
              beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(
                      mbd, beanName, this.beanFactory, factoryBean, factoryMethodToUse, argsToUse);
          }
          bw.setBeanInstance(beanInstance);
          return bw;
      }
      catch (Throwable ex) {
          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Bean instantiation via factory method failed", ex);
      }
  }
 
    实现逻辑很复杂，其实它和下面的有参构造方法实例化是差不多的。
      
  
  •  
    有参构造方法实例化：先看源码，
     
      public BeanWrapper autowireConstructor(final String beanName, final RootBeanDefinition mbd,
          @Nullable Constructor[] chosenCtors, @Nullable final Object[] explicitArgs) {
      BeanWrapperImpl bw = new BeanWrapperImpl();
      this.beanFactory.initBeanWrapper(bw);
      Constructor constructorToUse = null;
      ArgumentsHolder argsHolderToUse = null;
      Object[] argsToUse = null;
      if (explicitArgs != null) {
          argsToUse = explicitArgs;
      }
      else {
          //先从缓存中获取构造参数
          Object[] argsToResolve = null;
          synchronized (mbd.constructorArgumentLock) {
              constructorToUse = (Constructor) mbd.resolvedConstructorOrFactoryMethod;
              if (constructorToUse != null && mbd.constructorArgumentsResolved) {
                  argsToUse = mbd.resolvedConstructorArguments;
                  if (argsToUse == null) {
                      argsToResolve = mbd.preparedConstructorArguments;
                  }
              }
          }
          if (argsToResolve != null) {
              //参数类型解析，比如test(int a,int b)方法，把传入的a、b为String类型转为int
              argsToUse = resolvePreparedArguments(beanName, mbd, bw, constructorToUse, argsToResolve);
          }
      }
      //缓存为空
      if (constructorToUse == null) {
          boolean autowiring = (chosenCtors != null ||
                  mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR);
          ConstructorArgumentValues resolvedValues = null;
          int minNrOfArgs;
          if (explicitArgs != null) {
              minNrOfArgs = explicitArgs.length;
          }
          else {
              // 解析
              ConstructorArgumentValues cargs = mbd.getConstructorArgumentValues();
              resolvedValues = new ConstructorArgumentValues();
              minNrOfArgs = resolveConstructorArguments(beanName, mbd, bw, cargs, resolvedValues);
          }
          Constructor[] candidates = chosenCtors;
          if (candidates == null) {
              Class beanClass = mbd.getBeanClass();
              try {
                  candidates = (mbd.isNonPublicAccessAllowed() ?
                          beanClass.getDeclaredConstructors() : beanClass.getConstructors());
              }
              catch (Throwable ex) {
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                          "Resolution of declared constructors on bean Class [" + beanClass.getName() +
                          "] from ClassLoader [" + beanClass.getClassLoader() + "] failed", ex);
              }
          }
          AutowireUtils.sortConstructors(candidates);
          int minTypeDiffWeight = Integer.MAX_VALUE;
          Set> ambiguousConstructors = null;
          LinkedList causes = null;
          for (Constructor candidate : candidates) {
              Class[] paramTypes = candidate.getParameterTypes();
              if (constructorToUse != null && argsToUse.length > paramTypes.length) {
                  break;
              }
              if (paramTypes.length < minNrOfArgs) {
                  continue;
              }
              ArgumentsHolder argsHolder;
              if (resolvedValues != null) {
                  try {
                      String[] paramNames = ConstructorPropertiesChecker.evaluate(candidate, paramTypes.length);
                      if (paramNames == null) {
                          ParameterNameDiscoverer pnd = this.beanFactory.getParameterNameDiscoverer();
                          if (pnd != null) {
                              paramNames = pnd.getParameterNames(candidate);
                          }
                      }
                      argsHolder = createArgumentArray(beanName, mbd, resolvedValues, bw, paramTypes, paramNames,
                              getUserDeclaredConstructor(candidate), autowiring);
                  }
                  catch (UnsatisfiedDependencyException ex) {
                      if (this.beanFactory.logger.isTraceEnabled()) {
                          this.beanFactory.logger.trace(
                                  "Ignoring constructor [" + candidate + "] of bean '" + beanName + "': " + ex);
                      }
                      if (causes == null) {
                          causes = new LinkedList<>();
                      }
                      causes.add(ex);
                      continue;
                  }
              }
              else {
                  if (paramTypes.length != explicitArgs.length) {
                      continue;
                  }
                  argsHolder = new ArgumentsHolder(explicitArgs);
              }
              int typeDiffWeight = (mbd.isLenientConstructorResolution() ?
                      argsHolder.getTypeDifferenceWeight(paramTypes) : argsHolder.getAssignabilityWeight(paramTypes));
              if (typeDiffWeight < minTypeDiffWeight) {
                  constructorToUse = candidate;
                  argsHolderToUse = argsHolder;
                  argsToUse = argsHolder.arguments;
                  minTypeDiffWeight = typeDiffWeight;
                  ambiguousConstructors = null;
              }
              else if (constructorToUse != null && typeDiffWeight == minTypeDiffWeight) {
                  if (ambiguousConstructors == null) {
                      ambiguousConstructors = new LinkedHashSet<>();
                      ambiguousConstructors.add(constructorToUse);
                  }
                  ambiguousConstructors.add(candidate);
              }
          }
          if (constructorToUse == null) {
              if (causes != null) {
                  UnsatisfiedDependencyException ex = causes.removeLast();
                  for (Exception cause : causes) {
                      this.beanFactory.onSuppressedException(cause);
                  }
                  throw ex;
              }
              throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                      "Could not resolve matching constructor " +
                      "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities)");
          }
          else if (ambiguousConstructors != null && !mbd.isLenientConstructorResolution()) {
              throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                      "Ambiguous constructor matches found in bean '" + beanName + "' " +
                      "(hint: specify index/type/name arguments for simple parameters to avoid type ambiguities): " +
                      ambiguousConstructors);
          }
          if (explicitArgs == null) {
              argsHolderToUse.storeCache(mbd, constructorToUse);
          }
      }
      try {
          final InstantiationStrategy strategy = beanFactory.getInstantiationStrategy();
          Object beanInstance;
          if (System.getSecurityManager() != null) {
              final Constructor ctorToUse = constructorToUse;
              final Object[] argumentsToUse = argsToUse;
              beanInstance = AccessController.doPrivileged((PrivilegedAction) () ->
                      strategy.instantiate(mbd, beanName, beanFactory, ctorToUse, argumentsToUse),
                      beanFactory.getAccessControlContext());
          }
          else {
              beanInstance = strategy.instantiate(mbd, beanName, this.beanFactory, constructorToUse, argsToUse);
          }
          bw.setBeanInstance(beanInstance);
          return bw;
      }
      catch (Throwable ex) {
          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                  "Bean instantiation via constructor failed", ex);
      }
  }
 
    这里代码很多，实现的逻辑也很复杂，其主要的作用就是解析参数并确定调用的构造方法；大概流程就是：先确定构造方法参数，接着根据构造参数确定构造方法，然后构造参数转换成构造方法中需要的参数类型，最后再次检查下是否有不确定的构造方法存在（方法的参数为父子关系）。这些所实现的是为了准备实例化需要的信息，最后的实例化是调用strategy.instantiate()完成的。
      
  
  •  
    无参构造方法实例化：看完有参构造方法实例化的源码，再来看无参构造方法实例化就很简单了，
     
      protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
      try {
          Object beanInstance;
          final BeanFactory parent = this;
          //获取系统的安全管理接口，JDK标准的安全管理API
          if (System.getSecurityManager() != null) {
              beanInstance = AccessController.doPrivileged((PrivilegedAction) () ->
                      getInstantiationStrategy().instantiate(mbd, beanName, parent),
                      getAccessControlContext());
          }
          else {
              beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
          }
          BeanWrapper bw = new BeanWrapperImpl(beanInstance);
          initBeanWrapper(bw);
          return bw;
      }
      catch (Throwable ex) {
          throw new BeanCreationException(
                  mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
      }
  }
 
    因为无需对构造参数进行解析及构造方法的匹配查找，所以直接调用strategy.instantiate()来实例化就可以了。
      
  
 
    综上我们能够看到，不管哪种实例化方式最后都是调用SimpleInstantiationStrategy#instantiate()（除了Supplier）完成Bean的创建，最后再封装成BeanWrapper对象返回。
     
 
    我们先看下SimpleInstantiationStrategy的源码结构，
     
 
     
  
     
   
      
   
     
  
     
  
    
    image-20210727111459878 
  
     
 
     
 
    发现instantiate()方法是个重载方法，每个方法内的处理基本大同小异，我们这里选择无参构造函数调用的instantiate()来分析源码（它的其它重载方法有兴趣可以自己去看源码），
     
 
        @Override
    public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
        //判断Bean中有没有方法被覆盖
        if (!bd.hasMethodOverrides()) {
            Constructor constructorToUse;
            synchronized (bd.constructorArgumentLock) {
                constructorToUse = (Constructor) bd.resolvedConstructorOrFactoryMethod;
                if (constructorToUse == null) {
                    //检查Bean是否是一个接口
                    final Class clazz = bd.getBeanClass();
                    if (clazz.isInterface()) {
                        throw new BeanInstantiationException(clazz, "Specified class is an interface");
                    }
                    try {
                        if (System.getSecurityManager() != null) {
                            constructorToUse = AccessController.doPrivileged(
                                    (PrivilegedExceptionAction>) () -> clazz.getDeclaredConstructor());
                        }
                        else {
                            constructorToUse =  clazz.getDeclaredConstructor();
                        }
                        bd.resolvedConstructorOrFactoryMethod = constructorToUse;
                    }
                    catch (Throwable ex) {
                        throw new BeanInstantiationException(clazz, "No default constructor found", ex);
                    }
                }
            }
            //使用反射实例化
            return BeanUtils.instantiateClass(constructorToUse);
        }
        else {
            //使用CGLIB实例化
            return instantiateWithMethodInjection(bd, beanName, owner);
        }
    }

     
 
    一步步抽丝剥茧，到这里Bean实例化的最后结局已经完全展示在我们面前了，真相永远只有一个，那就是如果Bean中有方法被覆盖就通过JDK的反射机制创建对象，反之则使用CGLIB（一个字节码生成器的类库，AOP中会去详解）来创建。
     
 
    4.2.提前缓存Bean
     
 
    创建Bean并封装成BeanWrapper之后，往下调用了addSingletonFactory()方法，
     
 
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));

    protected void addSingletonFactory(String beanName, ObjectFactory singletonFactory) {
        Assert.notNull(singletonFactory, "Singleton factory must not be null");
        synchronized (this.singletonObjects) {
            if (!this.singletonObjects.containsKey(beanName)) {
                this.singletonFactories.put(beanName, singletonFactory);
                this.earlySingletonObjects.remove(beanName);
                this.registeredSingletons.add(beanName);
            }
        }
    }

    protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean) {
        Object exposedObject = bean;
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
                    SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
                    exposedObject = ibp.getEarlyBeanReference(exposedObject, beanName);
                }
            }
        }
        return exposedObject;
    }

     
 
    不难发现Bean初始化完成前，需要对创建的Bean的beanName进行各种缓存，这样避免对象创建过程中的循环依赖，同时这里参数传入了一个创建的ObjectFatory对象，而它的使用地方，之前从缓存中获取Bean里也介绍过了，而缓存的时间就是在这里。
     
 
    4.3.属性注入
     
 
    既然Bean对象已经有了，那么接下来就是就要给它赋值，这里调用了populateBean()为Bean对象的属性进行注入，
     
 
        protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
        if (bw == null) {
            if (mbd.hasPropertyValues()) {
                throw new BeanCreationException(
                        mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
            }
            else {
                return;
            }
        }
         //实例化后处理
        boolean continueWithPropertyPopulation = true;
        if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                    InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                    if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                        continueWithPropertyPopulation = false;
                        break;
                    }
                }
            }
        }
        if (!continueWithPropertyPopulation) {
            return;
        }
        PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);
        //处理自动装配
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
                mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
            //根据名称自动注入
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
                autowireByName(beanName, mbd, bw, newPvs);
            }
            //根据类型自动注入
            if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
                autowireByType(beanName, mbd, bw, newPvs);
            }
            pvs = newPvs;
        }
        boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
        boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);
        if (hasInstAwareBpps || needsDepCheck) {
            if (pvs == null) {
                pvs = mbd.getPropertyValues();
            }
             //属性值处理
            PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            if (hasInstAwareBpps) {
                for (BeanPostProcessor bp : getBeanPostProcessors()) {
                    if (bp instanceof InstantiationAwareBeanPostProcessor) {
                        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
                        pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                        if (pvs == null) {
                            return;
                        }
                    }
                }
            }
             //依赖检查
            if (needsDepCheck) {
                checkDependencies(beanName, mbd, filteredPds, pvs);
            }
        }
        if (pvs != null) {
            //属性注入
            applyPropertyValues(beanName, mbd, bw, pvs);
        }
    }

     
 
    通过上面源码，我们知道这里做了这样的处理：
     
 
       
  
    1. 通过postProcessAfterInstantiation()对实例化的对象做一些处理，同时可以直接结束属性注入；
      2.  
  
    2. 通过Bean的名称和类型注入属性值；
      3.  
  
    3. 通过postProcessPropertyValues()对属性值进行处理；
      4.  
  
    4. 执行依赖性检查以确保已设置所有公开的属性；
      5.  
  
    5. 把获取的属性值注入到对象中。
      6.  
 
     
 
    我们先看下autowireByName()、autowireByType()方法的源码，
     
 
        protected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
        //获取需要注入的属性名（对Bean对象中非简单属性(不是简单继承的对象，如8中原始类型，字符串，URL等都是简单属性)进行处理）
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        for (String propertyName : propertyNames) {
            //判断IOC容器中是否包含beanName的Bean
            if (containsBean(propertyName)) {
                //获取Bean
                Object bean = getBean(propertyName);
                //属性赋值
                pvs.add(propertyName, bean);
                //注册缓存依赖的beanName
                registerDependentBean(propertyName, beanName);
                if (logger.isDebugEnabled()) {
                    logger.debug("Added autowiring by name from bean name '" + beanName +
                            "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
                }
            }
            else {
                if (logger.isTraceEnabled()) {
                    logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                            "' by name: no matching bean found");
                }
            }
        }
    }

    protected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {
        //获取自定义类型转换器
        TypeConverter converter = getCustomTypeConverter();
        if (converter == null) {
            converter = bw;
        }
        //存放要注入的属性名
        Set autowiredBeanNames = new LinkedHashSet<>(4);
        //获取需要注入的属性名
        String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
        for (String propertyName : propertyNames) {
            try {
                PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
                //不对Object类型的属性进行注入
                if (Object.class != pd.getPropertyType()) {
                    MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                    boolean eager = !PriorityOrdered.class.isInstance(bw.getWrappedInstance());
                    DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);
                    //获取Bean
                    Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
                    if (autowiredArgument != null) {
                        //属性赋值
                        pvs.add(propertyName, autowiredArgument);
                    }
                    for (String autowiredBeanName : autowiredBeanNames) {
                        //注册缓存依赖的beanName
                        registerDependentBean(autowiredBeanName, beanName);
                        if (logger.isDebugEnabled()) {
                            logger.debug("Autowiring by type from bean name '" + beanName + "' via property '" +
                                    propertyName + "' to bean named '" + autowiredBeanName + "'");
                        }
                    }
                    autowiredBeanNames.clear();
                }
            }
            catch (BeansException ex) {
                throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
            }
        }
    }

     
 
    通过上面对比的分析，总结它们的主要处理流程其实相差不多，都是：
     
 
       
  
    1. 调用unsatisfiedNonSimpleProperties()方法获取需要注入的属性名，主要筛除对Bean对象中的简单属性，比如基本数据类型（Integer、Boolean、Long等），字符串，URL等，通过类型注入的方式中对Object类型的属性不进行注入；
      2.  
  
    2. 遍历属性名，获取依赖的Bean对象，其中通过类型注入的方式中是调用resolveDependency()获取的，包括实现了对@Value注解、List、Array、Map、内部类、引用类型等类型的解析匹配等处理，但其本质也是调用BeanFactory#getBean()方法；
      3.  
  
    3. 注册缓存Bean和依赖的Bean的各自beanName关系。
      4.  
 
     
 
    通过上面的解析拿到属性名和对应的值之后，接下来就是调用applyPropertyValues()把PropertyValues给注入到对象中了，
     
 
        protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {
        if (pvs.isEmpty()) {
            return;
        }
        //封装属性值
        MutablePropertyValues mpvs = null;
        List original;
        if (System.getSecurityManager() != null) {
            if (bw instanceof BeanWrapperImpl) {
                //设置安全上下文，JDK安全机制
                ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());
            }
        }
        if (pvs instanceof MutablePropertyValues) {
            mpvs = (MutablePropertyValues) pvs;
            if (mpvs.isConverted()) {
                try {
                    //属性赋值
                    bw.setPropertyValues(mpvs);
                    return;
                }
                catch (BeansException ex) {
                    throw new BeanCreationException(
                            mbd.getResourceDescription(), beanName, "Error setting property values", ex);
                }
            }
            //获取原始类型值
            original = mpvs.getPropertyValueList();
        }
        else {
            original = Arrays.asList(pvs.getPropertyValues());
        }
        //自定义的类型转换
        TypeConverter converter = getCustomTypeConverter();
        if (converter == null) {
            converter = bw;
        }
        //创建属性值解析器，将属性值解析为实际值
        BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);
        List deepCopy = new ArrayList<>(original.size());
        boolean resolveNecessary = false;
        for (PropertyValue pv : original) {
            //无需转换
            if (pv.isConverted()) {
                deepCopy.add(pv);
            }
            //需要转换
            else {
                String propertyName = pv.getName();
                Object originalValue = pv.getValue();
                Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);
                Object convertedValue = resolvedValue;
                boolean convertible = bw.isWritableProperty(propertyName) &&
                        !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);
                if (convertible) {
                    convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);
                }
                if (resolvedValue == originalValue) {
                    if (convertible) {
                        //设置属性转换后的值
                        pv.setConvertedValue(convertedValue);
                    }
                    deepCopy.add(pv);
                }
                else if (convertible && originalValue instanceof TypedStringValue &&
                        !((TypedStringValue) originalValue).isDynamic() &&
                        !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {
                      //设置属性转换后的值
                    pv.setConvertedValue(convertedValue);
                    deepCopy.add(pv);
                }
                else {
                    resolveNecessary = true;
                    deepCopy.add(new PropertyValue(pv, convertedValue));
                }
            }
        }
        if (mpvs != null && !resolveNecessary) {
            mpvs.setConverted();
        }
        try {
            //属性赋值
            bw.setPropertyValues(new MutablePropertyValues(deepCopy));
        }
        catch (BeansException ex) {
            throw new BeanCreationException(
                    mbd.getResourceDescription(), beanName, "Error setting property values", ex);
        }
    }

     
 
    而上面方法的中的bw.setPropertyValues()就是整个属性注入的点睛之笔了，具体调用的是AbstractNestablePropertyAccessor#setPropertyValue()方法，在里面实现更具体的解析处理赋值过程，感兴趣可以深入了解一下。
     
 
    4.4.初始化Bean
     
 
    上面已经完成了属性的注入，那么接下来我们还需要对Bean对象进行一个初始化操作，我们知道在配置元数据的时候，会有一个init-method的属性，它的作用是在Bean实例初始化前调用配置的方法，而这里就是这个配置方法调用的入口。
     
 
        protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
        //JDK的安全机制验证权限
        if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction) () -> {
                invokeAwareMethods(beanName, bean);
                return null;
            }, getAccessControlContext());
        }
        else {
            invokeAwareMethods(beanName, bean);
        }
        Object wrappedBean = bean;
        //初始化前的Bean处理
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
        }
        //配置的init-method属性指定方法
        try {
            invokeInitMethods(beanName, wrappedBean, mbd);
        }
        catch (Throwable ex) {
            throw new BeanCreationException(
                    (mbd != null ? mbd.getResourceDescription() : null),
                    beanName, "Invocation of init method failed", ex);
        }
        //初始化后的Bean处理
        if (mbd == null || !mbd.isSynthetic()) {
            wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
        }
        return wrappedBean;
    }
 
 
    4.5.注册Bean
     
 
    经历过复杂的Bean创建及属性注入实现之后，剩下通过registerDisposableBeanIfNecessary()方法注册Bean就很简单了，主要就是把Bean注册到Map disposableBeans中去，同时在这里可以注册后置处理器来统一处理Bean的销毁方法。
     
 
        protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
        AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
        if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
            if (mbd.isSingleton()) {
                // Register a DisposableBean implementation that performs all destruction
                // work for the given bean: DestructionAwareBeanPostProcessors,
                // DisposableBean interface, custom destroy method.
                registerDisposableBean(beanName,
                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
            else {
                Scope scope = this.scopes.get(mbd.getScope());
                if (scope == null) {
                    throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
                }
                scope.registerDestructionCallback(beanName,
                        new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
            }
        }
    }

     
 
    到这里，我们就已经完成了Bean的整个实例化到注册的过程了。
     
 
    5.获取真正需要的Bean
     
 
    但到这里还没结束，我们注意到每次实例化Bean之后，都会调用getObjectForBeanInstance()方法，那它作用是什么呢？我们先看下源码，
     
 
        protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
        //Bean的名称以&开头，且不是FactoryBean则抛出异常
        if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
            throw new BeanIsNotAFactoryException(transformedBeanName(name), beanInstance.getClass());
        }
        if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
            return beanInstance;
        }
        Object object = null;
        if (mbd == null) {
            //尝试从缓存中获取Bean对象
            object = getCachedObjectForFactoryBean(beanName);
        }
        if (object == null) {
            FactoryBean factory = (FactoryBean) beanInstance;
            if (mbd == null && containsBeanDefinition(beanName)) {
                //RootBeanDefinition转换，合并父类的属性
                mbd = getMergedLocalBeanDefinition(beanName);
            }
            boolean synthetic = (mbd != null && mbd.isSynthetic());
            //通过FactoryBean获取获取Bean对象
            object = getObjectFromFactoryBean(factory, beanName, !synthetic);
        }
        return object;
    }

    protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean shouldPostProcess) {
        if (factory.isSingleton() && containsSingleton(beanName)) {
            synchronized (getSingletonMutex()) {
                //从缓存中获取Bean对象
                Object object = this.factoryBeanObjectCache.get(beanName);
                if (object == null) {
                    //创建Bean
                    object = doGetObjectFromFactoryBean(factory, beanName);
                    Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
                    if (alreadyThere != null) {
                        object = alreadyThere;
                    }
                    else {
                        if (shouldPostProcess) {
                            try {
                                   //后置处理
                                object = postProcessObjectFromFactoryBean(object, beanName);
                            }
                            catch (Throwable ex) {
                                throw new BeanCreationException(beanName,
                                        "Post-processing of FactoryBean's singleton object failed", ex);
                            }
                        }
                        //缓存Bean对象
                        this.factoryBeanObjectCache.put(beanName, object);
                    }
                }
                return object;
            }
        }
        else {
             //创建Bean
            Object object = doGetObjectFromFactoryBean(factory, beanName);
            if (shouldPostProcess) {
                try {
                      //后置处理
                    object = postProcessObjectFromFactoryBean(object, beanName);
                }
                catch (Throwable ex) {
                    throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
                }
            }
            return object;
        }
    }

     
 
    我们知道了它主要是用于检查当前的Bean是否是FactoryBean，不是直接返回，是则通过FactoryBean去创建Bean，而FactoryBean我们在准备工作中也介绍过了，上面代码中我们能看到具体的创建过程是交给doGetObjectFromFactoryBean()方法完成的，那我们看它里面到底是咋实现的，
     
 
        private Object doGetObjectFromFactoryBean(final FactoryBean factory, final String beanName) throws BeanCreationException {
        Object object;
        try {
            if (System.getSecurityManager() != null) {
                AccessControlContext acc = getAccessControlContext();
                try {
                    object = AccessController.doPrivileged((PrivilegedExceptionAction) () ->
                            factory.getObject(), acc);
                }
                catch (PrivilegedActionException pae) {
                    throw pae.getException();
                }
            }
            else {
                object = factory.getObject();
            }
        }
        catch (FactoryBeanNotInitializedException ex) {
            throw new BeanCurrentlyInCreationException(beanName, ex.toString());
        }
        catch (Throwable ex) {
            throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation", ex);
        }
         //尚未完全初始化的null值FactoryBean用NullBean代替
        if (object == null) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                throw new BeanCurrentlyInCreationException(
                        beanName, "FactoryBean which is currently in creation returned null from getObject");
            }
            object = new NullBean();
        }
        return object;
    }
 
 
    原来最后Bean的创建就是通过FactoryBean#getObject()方法完成的，而前面的解析我们也知道，其本质还是调用BeanFactory#getBean()。我们再看前面的代码，在拿到Bean实例之后并没有直接返回，而是调用postProcessObjectFromFactoryBean()方法，对从FactoryBean获得的对象进行后处理，它实际调用的是下面的代码，
     
 
        @Override
    public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException {
        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            //后置处理
            Object current = beanProcessor.postProcessAfterInitialization(result, beanName);
            if (current == null) {
                return result;
            }
            result = current;
        }
        return result;
    }

     
 
    主要是在Bean初始化之后做一些自定义的处理操作。纵观全文，发现源码中有很多对Bean的前置后置处理器，包括实例化前后处理、初始化前后处理等等，而Spring设计这样的规则的目的就是为了在实际开发中可以利用这些处理器回调自己扩展的业务逻辑，后面有机会的话会再单独拎出来讲讲。
     
 
    6.类型转换
     
 
    前面已经完成Bean的依赖注入了，到这里基本就是收尾了，主要解决的是当开始时通过getBean(String name, @Nullable Class requiredType)来获取Bean，但传入参数的类型和Bean类型不匹配的转换问题，其实就是将获取的Bean转换为requiredType指定的类型，无法转换则会抛出转换失败异常。当然Spring中已经提供了不同的转换器，但我们也可以自定义扩展需要的转换器。转换时先获取自定义转换器，如果没有，则使用默认的SimpleTypeConverter，实际转换实现是调用ConversionService的实现类GenericConversionService的convert()来完成的，感兴趣的可以自己看看哦。
     
 
    总结
     
 
    最后也梳理了整个注入流程流程的时序图，而通过解析源码，我们再次验证了Bean的实例化入口离不开BeanFactory#getBean()方法，底层通过反射或者CGLIB代理完成对象创建，属性根据名称和类型自动注入等等，而本篇文章的目录结构就是提炼精简下来的流程。
     
 
     
  
     
   
      
   
     
  
     
  
    
    image 
  
     
 
     
 
     
  
    参考资料：
     
  
       
   
    • Spring官网文档
      •  
   
    • Tom老师的Spring笔记
      •  
   
    • Spring源码深度解析书籍
      •  
  
     
 
     
 
     
 
    把一件事做到极致就是天分！
     

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(Spring源码解析之DI篇)
    
        
    
            
    
                
      
                    
    • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
      在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
      
                    
      • 
                    
    • 扫地机类清洁产品之直流无刷电机控制
                        悟空胆好小
清洁服务机器人单片机人工智能
                        
      扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
      
                    
      • 
                    
    • 那个抄袭的大张伟
                        猫小努

                        
      最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
      
                    
      • 
                    
    • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
      预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
      
                    
      • 
                    
    • 水平垂直居中的几种方法（总结）
                        LJ小番茄
CSS_玄学语言htmljavascript前端csscss3
                        
      1.使用flexbox的justify-content和align-items.parent{display:flex;justify-content:center;/*水平居中*/align-items:center;/*垂直居中*/height:100vh;/*需要指定高度*/}2.使用grid的place-items:center.parent{display:grid;place-item
      
                    
      • 
                    
    • 《大清方方案》| 第二话
                        谁佐清欢

                        
      和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
      
                    
      • 
                    
    • 每日一题——第八十四题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
      题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
      
                    
      • 
                    
    • WPF中的ComboBox控件几种数据绑定的方式
                        互联网打工人no1
wpfc#
                        
      一、用字典给ItemsSource赋值（此绑定用的地方很多，建议熟练掌握）在XMAL中：在CS文件中privatevoidBindData(){DictionarydicItem=newDictionary();dicItem.add(1,"北京");dicItem.add(2,"上海");dicItem.add(3,"广州");cmb_list.ItemsSource=dicItem;cmb_l
      
                    
      • 
                    
    • 《庄子.达生9》
                        钱江潮369

                        
      【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
      
                    
      • 
                    
    • 第四天旅游线路预览——从换乘中心到喀纳斯湖
                        陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游
                        
      第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
      
                    
      • 
                    
    • linux sdl windows.h,Windows下的SDL安装
                        奔跑吧linux内核
linuxsdlwindows.h
                        
      首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
      
                    
      • 
                    
    • Goolge earth studio 进阶4——路径修改与平滑
                        陟彼高冈yu
Googleearthstudio进阶教程旅游
                        
      如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
      
                    
      • 
                    
    • Google earth studio 简介
                        陟彼高冈yu
旅游
                        
      GoogleEarthStudio是一个基于Web的动画工具，专为创作使用GoogleEarth数据的动画和视频而设计。它利用了GoogleEarth强大的三维地图和卫星影像数据库，使用户能够轻松地创建逼真的地球动画、航拍视频和动态地图可视化。网址为https://www.google.com/earth/studio/。GoogleEarthStudio是一个基于Web的动画工具，专为创作使用G
      
                    
      • 
                    
    • python os.environ_python os.environ 读取和设置环境变量
                        weixin_39605414
pythonos.environ
                        
      >>>importos>>>os.environ.keys()['LC_NUMERIC','GOPATH','GOROOT','GOBIN','LESSOPEN','SSH_CLIENT','LOGNAME','USER','HOME','LC_PAPER','PATH','DISPLAY','LANG','TERM','SHELL','J2REDIR','LC_MONETARY','QT_QPA
      
                    
      • 
                    
    • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
                        成长时间线

                        
      7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
      
                    
      • 
                    
    • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
      随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
      
                    
      • 
                    
    • Git常用命令－修改远程仓库地址
                        猿大师
LinuxJavagitjava
                        
      查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
      
                    
      • 
                    
    • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
      ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
      
                    
      • 
                    
    • 高端密码学院笔记285
                        柚子_b4b4

                        
      高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
      
                    
      • 
                    
    • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
      不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
      
                    
      • 
                    
    • 【加密社】Solidity 中的事件机制及其应用
                        加密社
闲侃区块链智能合约区块链
                        
      加密社引言在Solidity合约开发过程中，事件（Events）是一种非常重要的机制。它们不仅能够让开发者记录智能合约的重要状态变更，还能够让外部系统（如前端应用）监听这些状态的变化。本文将详细介绍Solidity中的事件机制以及如何利用不同的手段来触发、监听和获取这些事件。事件存储的地方当我们在Solidity合约中使用emit关键字触发事件时，该事件会被记录在区块链的交易收据中。具体而言，事件
      
                    
      • 
                    
    • 想明白这个问题，你才能写下去
                        文自拾

                        
      春节放假的时候，又有一天梦见她，第二天她冒着漫天大雪，傻傻地跑来见我。她说，见见傻傻的我，天很冷，心很暖。她回去后，我写了一篇文章，题目叫——从此梦中只有你。我们没在一起的很长一段时间里，她都在我的心底，一次次出现在我的梦里。我对她说，在一起之前，是胆小且闷骚，在一起之后，我变得不要脸了。不要脸的——去爱你。那文章没写完，火车上，给她看了。我有点小失望，花了好几个小时写，她分分钟就看完，很希望她逐
      
                    
      • 
                    
    • 东南林氏之九牧林候选父系
                        祖缘树TheYtree

                        
      渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
      
                    
      • 
                    
    • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
      ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
      
                    
      • 
                    
    • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
      Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
      
                    
      • 
                    
    • 大伟说成语之唉声叹气
                        求索大伟

                        
      ＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
      
                    
      • 
                    
    • 2022现在哪个打车软件比较好用又便宜 实惠的打车软件合集
                        高省APP珊珊

                        
      这是一个信息高速传播的社会。信息可以通过手机，微信，自媒体，抖音等方式进行传播。但同时这也是一个交通四通发达的社会。高省APP，是2022年推出的平台，0投资，0风险、高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，也期待你的加入。珊珊导师，高省邀请码777777，注册送2皇冠会员，送万元推广大礼包，教你如何1年做到百万团队。高
      
                    
      • 
                    
    • libyuv之linux编译
                        jaronho
Linuxlinux运维服务器
                        
      文章目录一、下载源码二、编译源码三、注意事项1、银河麒麟系统（aarch64）（1）解决armv8-a+dotprod+i8mm指令集支持问题（2）解决armv9-a+sve2指令集支持问题一、下载源码到GitHub网站下载https://github.com/lemenkov/libyuv源码，或者用直接用git克隆到本地，如：gitclonehttps://github.com/lemenko
      
                    
      • 
                    
    • Python 实现图片裁剪（附代码） | Python工具
                        剑客阿良_ALiang

                        
      前言本文提供将图片按照自定义尺寸进行裁剪的工具方法，一如既往的实用主义。环境依赖ffmpeg环境安装，可以参考我的另一篇文章：windowsffmpeg安装部署_阿良的博客-CSDN博客本文主要使用到的不是ffmpeg，而是ffprobe也在上面这篇文章中的zip包中。ffmpy安装：pipinstallffmpy-ihttps://pypi.douban.com/simple代码不废话了，上代码
      
                    
      • 
                    
    • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
                        高省_飞智666600

                        
      很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
      
                    
      • 
                                
    • ztree设置禁用节点
                                    3213213333332132
JavaScriptztreejsonsetDisabledNodeAjax
                                    
      ztree设置禁用节点的时候注意，当使用ajax后台请求数据,必须要设置为同步获取数据，否者会获取不到节点对象，导致设置禁用没有效果。 
 
 
$(function(){            	
                showTree();
	            setDisabledNode();

});
                   
        
      
                                
      • 
                                
    • JVM patch by Taobao
                                    bookjovi
javaHotSpot
                                    
      在网上无意中看到淘宝提交的hotspot patch，共四个，有意思，记录一下。 
  
7050685：jsdbproc64.sh has a typo in the package name 
7058036：FieldsAllocationStyle=2 does not work in 32-bit VM 
7060619：C1 should respect inline and
      
                                
      • 
                                
    • 将session存储到数据库中
                                    dcj3sjt126com
sqlPHPsession
                                    
      CREATE TABLE sessions (
  id CHAR(32) NOT NULL,
  data TEXT,
  last_accessed TIMESTAMP NOT NULL,
  PRIMARY KEY (id)
); 
  
<?php
/**
 * Created by PhpStorm.
 * User: michaeldu
 * Date
      
                                
      • 
                                
    • Vector
                                    171815164
vector
                                    
      public Vector<CartProduct> delCart(Vector<CartProduct> cart, String id) {
		for (int i = 0; i < cart.size(); i++) {
			if (cart.get(i).getId().equals(id)) {
				cart.remove(i);
				
      
                                
      • 
                                
    • 各连接池配置参数比较
                                    g21121
连接池
                                    
              排版真心费劲，大家凑合看下吧，见谅~ 
      
  
Druid 
DBCP 
C3P0 
Proxool   
数据库用户名称 Username Username User     
数据库密码 Password Password Password     
驱动名
      
                                
      • 
                                
    • [简单]mybatis insert语句添加动态字段
                                    53873039oycg
mybatis
                                    
            mysql数据库,id自增,配置如下： 
      
<insert id="saveTestTb" useGeneratedKeys="true" keyProperty="id"
		parameterType=&
      
                                
      • 
                                
    • struts2拦截器配置
                                    云端月影
struts2拦截器
                                    
      struts2拦截器interceptor的三种配置方法 
方法1. 普通配置法 
 
<struts> 
    <package name="struts2" extends="struts-default"> 
        &
      
                                
      • 
                                
    • IE中页面不居中，火狐谷歌等正常
                                    aijuans
IE中页面不居中
                                    
      问题是首页在火狐、谷歌、所有IE中正常显示，列表页的页面在火狐谷歌中正常，在IE6、7、8中都不中，觉得可能那个地方设置的让IE系列都不认识，仔细查看后发现，列表页中没写HTML模板部分没有添加DTD定义，就是<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3
      
                                
      • 
                                
    • String,int,Integer,char 几个类型常见转换
                                    antonyup_2006
htmlsql.net
                                    
      如何将字串 String 转换成整数 int? 
int i = Integer.valueOf(my_str).intValue(); 
 
int i=Integer.parseInt(str); 
 
如何将字串 String 转换成Integer ? 
Integer integer=Integer.valueOf(str); 
 
如何将整数 int 转换成字串 String ? 
1.
      
                                
      • 
                                
    • PL/SQL的游标类型
                                    百合不是茶
显示游标(静态游标)隐式游标游标的更新和删除%rowtyperef游标(动态游标)
                                    
      游标是oracle中的一个结果集,用于存放查询的结果; 
  
PL/SQL中游标的声明; 
1,声明游标

2,打开游标(默认是关闭的);

3,提取数据

4,关闭游标
 
  
  
注意的要点:游标必须声明在declare中,使用open打开游标,fetch取游标中的数据,close关闭游标 
  
隐式游标:主要是对DML数据的操作隐
      
                                
      • 
                                
    • JUnit4中@AfterClass @BeforeClass @after @before的区别对比
                                    bijian1013
JUnit4单元测试
                                    
      一.基础知识 
JUnit4使用Java5中的注解（annotation），以下是JUnit4常用的几个annotation： @Before：初始化方法   对于每一个测试方法都要执行一次（注意与BeforeClass区别，后者是对于所有方法执行一次）@After：释放资源  对于每一个测试方法都要执行一次（注意与AfterClass区别，后者是对于所有方法执行一次
      
                                
      • 
                                
    • 精通Oracle10编程SQL(12)开发包
                                    bijian1013
oracle数据库plsql
                                    
      /*
 *开发包
 *包用于逻辑组合相关的PL/SQL类型（例如TABLE类型和RECORD类型）、PL/SQL项（例如游标和游标变量）和PL/SQL子程序（例如过程和函数）
 */
--包用于逻辑组合相关的PL/SQL类型、项和子程序，它由包规范和包体两部分组成
--建立包规范：包规范实际是包与应用程序之间的接口，它用于定义包的公用组件，包括常量、变量、游标、过程和函数等
--在包规
      
                                
      • 
                                
    • 【EhCache二】ehcache.xml配置详解
                                    bit1129
ehcache.xml
                                    
      在ehcache官网上找了多次，终于找到ehcache.xml配置元素和属性的含义说明文档了，这个文档包含在ehcache.xml的注释中！ 
ehcache.xml ： http://ehcache.org/ehcache.xml 
ehcache.xsd ： http://ehcache.org/ehcache.xsd 
ehcache配置文件的根元素是ehcahe 
  ehcac
      
                                
      • 
                                
    • java.lang.ClassNotFoundException: org.springframework.web.context.ContextLoaderL
                                    白糖_
javaeclipsespringtomcatWeb
                                    
      今天学习spring+cxf的时候遇到一个问题：在web.xml中配置了spring的上下文监听器： 
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener> 
 随后启动
      
                                
      • 
                                
    • angular.element
                                    boyitech
AngularJSAngularJS APIangular.element
                                    
      angular.element 
描述:      包裹着一部分DOM element或者是HTML字符串，把它作为一个jQuery元素来处理。（类似于jQuery的选择器啦）       如果jQuery被引入了，则angular.element就可以看作是jQuery选择器，选择的对象可以使用jQuery的函数；如果jQuery不可用，angular.e
      
                                
      • 
                                
    • java-给定两个已排序序列，找出共同的元素。
                                    bylijinnan
java
                                    
      
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


public class CommonItemInTwoSortedArray {

	/**
	 * 题目：给定两个已排序序列，找出共同的元素。
	 * 1.定义两个指针分别指向序列的开始。
	 * 如果指向的两个元素
      
                                
      • 
                                
    • sftp 异常，有遇到的吗？求解
                                    Chen.H
javajcraftauthjschjschexception
                                    
      com.jcraft.jsch.JSchException: Auth cancel 
 at com.jcraft.jsch.Session.connect(Session.java:460) 
 at com.jcraft.jsch.Session.connect(Session.java:154) 
 at cn.vivame.util.ftp.SftpServerAccess.connec
      
                                
      • 
                                
    • [生物智能与人工智能]神经元中的电化学结构代表什么?
                                    comsci
人工智能
                                    
           我这里做一个大胆的猜想,生物神经网络中的神经元中包含着一些化学和类似电路的结构,这些结构通常用来扮演类似我们在拓扑分析系统中的节点嵌入方程一样,使得我们的神经网络产生智能判断的能力,而这些嵌入到节点中的方程同时也扮演着"经验"的角色.... 
 
     我们可以尝试一下...在某些神经
      
                                
      • 
                                
    • 通过LAC和CID获取经纬度信息
                                    dai_lm
laccid
                                    
      方法1： 
用浏览器打开http://www.minigps.net/cellsearch.html，然后输入lac和cid信息(mcc和mnc可以填0)，如果数据正确就可以获得相应的经纬度 
 
方法2： 
发送HTTP请求到http://www.open-electronics.org/celltrack/cell.php?hex=0&lac=<lac>&cid=&
      
                                
      • 
                                
    • JAVA的困难分析
                                    datamachine
java
                                    
      前段时间转了一篇SQL的文章（http://datamachine.iteye.com/blog/1971896），文章不复杂，但思想深刻，就顺便思考了一下java的不足，当砖头丢出来，希望引点和田玉。 
  
-----------------------------------------------------------------------------------------
      
                                
      • 
                                
    • 小学5年级英语单词背诵第二课
                                    dcj3sjt126com
englishword
                                    
      money 钱 
paper 纸 
speak 讲，说 
tell 告诉 
  
remember 记得，想起 
knock 敲，击，打 
question 问题 
number 数字，号码 
  
learn 学会，学习 
street 街道 
carry 搬运，携带 
send 发送，邮寄，发射 
  
must 必须 
light 灯，光线，轻的 
front 
      
                                
      • 
                                
    • linux下面没有tree命令
                                    dcj3sjt126com
linux
                                    
      centos p安装 
yum -y install tree 
  
mac os安装 
brew install tree 
  首先来看tree的用法  
tree  中文解释：tree
功能说明：以树状图列出目录的内容。
语　　法：tree [-aACdDfFgilnNpqstux][-I <范本样式>][-P <范本样式
      
                                
      • 
                                
    • Map迭代方式，Map迭代，Map循环
                                    蕃薯耀
Map循环Map迭代Map迭代方式
                                    
      Map迭代方式，Map迭代，Map循环 
  
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年
      
                                
      • 
                                
    • Spring Cache注解+Redis
                                    hanqunfeng
spring
                                    
      Spring3.1 Cache注解  
依赖jar包： 
<!-- redis -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			
      
                                
      • 
                                
    • Guava中针对集合的 filter和过滤功能
                                    jackyrong
filter
                                    
      在guava库中，自带了过滤器(filter)的功能，可以用来对collection 进行过滤，先看例子： 
 
   

@Test
public void whenFilterWithIterables_thenFiltered() {
    List<String> names = Lists.newArrayList("John"
      
                                
      • 
                                
    • 学习编程那点事
                                    lampcy
编程androidPHPhtml5
                                    
      一年前的夏天，我还在纠结要不要改行，要不要去学php？能学到真本事吗？改行能成功吗？太多的问题，我终于不顾一切，下定决心，辞去了工作，来到传说中的帝都。老师给的乘车方式还算有效，很顺利的就到了学校，赶巧了，正好学校搬到了新校区。先安顿了下来，过了个轻松的周末，第一次到帝都，逛逛吧！ 
接下来的周一，是我噩梦的开始，学习内容对我这个零基础的人来说，除了勉强完成老师布置的作业外，我已经没有时间和精力去
      
                                
      • 
                                
    • 架构师之流处理---------bytebuffer的mark,limit和flip
                                    nannan408
ByteBuffer
                                    
      1.前言。 
  如题，limit其实就是可以读取的字节长度的意思，flip是清空的意思，mark是标记的意思 。 
2.例子. 
 

例子代码:
     String str = "helloWorld";  
        ByteBuffer buff  = ByteBuffer.wrap(str.getBytes());  
        Sy
      
                                
      • 
                                
    • org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, column 1
                                    Everyday都不同
$转义el表达式
                                    
      最近在做Highcharts的过程中，在写js时，出现了以下异常： 
  
严重: Servlet.service() for servlet jsp threw exception 
org.apache.el.parser.ParseException: Encountered " ":" ": "" at line 1, 
      
                                
      • 
                                
    • 用Java实现发送邮件到163
                                    tntxia
java实现
                                    
      /*

 在java版经常看到有人问如何用javamail发送邮件？如何接收邮件？如何访问多个文件夹等。问题零散，而历史的回复早已经淹没在问题的海洋之中。

 本人之前所做过一个java项目，其中包含有WebMail功能，当初为用java实现而对javamail摸索了一段时间，总算有点收获。看到论坛中的经常有此方面的问题，因此把我的一些经验帖出来，希望对大家有些帮助。

 此篇仅介绍用
      
                                
      • 
                                
    • 探索实体类存在的真正意义
                                    java小叶檀
POJO
                                    
      一. 实体类简述   
 实体类其实就是俗称的POJO,这种类一般不实现特殊框架下的接口，在程序中仅作为数据容器用来持久化存储数据用的 
POJO（Plain Old Java Objects）简单的Java对象 
  
它的一般格式就是 
public class A{
      private String id;
      public Str
      
                                
      •