elysee2008
elysee2008

Spring框架学习【IoC容器依赖注入】

1.当Spring IoC容器完成了Bean定义资源的定位、载入和解析注册以后，IoC容器中已经管理类Bean定义的相关数据，但是此时IoC容器还没有对所管理的Bean进行依赖注入，依赖注入在以下两种情况发生：

(1).用户第一次通过getBean方法向IoC容索要Bean时，IoC容器触发依赖注入。

(2).当用户在Bean定义资源中为元素配置了lazy-init属性，即让容器在解析注册Bean定义时进行预实例化，触发依赖注入。

在第一篇博客《IoC容器的体系架构》中我已经介绍了BeanFactory接口定义了Spring IoC容器的基本功能规范，是Spring IoC容器所应遵守的最底层和最基本的编程规范。BeanFactory接口中定义了几个getBean方法，就是用户向IoC容器索取管理的Bean的方法，我们通过分析其子类的具体实现，理解Spring IoC容器在用户索取Bean时如何完成依赖注入。

2．用户使用getBean方法向Spring IoC容器索取被管理的Bean：

我们查看BeanFactory的getBean方法实现，发现有3个类实现了该方法：SimpleJndiBeanFactory，StaticListableBeanFactory和AbstractApplicationContext。我们以AbstractApplicationContext为例，分析其向容器索取的处理过程。

AbstractApplicationContext中getBean相关方法的源码如下：

[java]  view plaincopy
  1. //根据Bean名称，向容器获取指定名称的Bean  
  2. public Object getBean(String name) throws BeansException {  
  3.         return getBeanFactory().getBean(name);  
  4.     }  
  5.     //根据Bean名称和类型，向容器获取指定名称和类型的Bean  
  6.     public  T getBean(String name, Class requiredType) throws BeansException {  
  7.         return getBeanFactory().getBean(name, requiredType);  
  8.     }  
  9.     //根据Bean的类型，向容器获取指定类型的Bean  
  10.     public  T getBean(Class requiredType) throws BeansException {  
  11.         return getBeanFactory().getBean(requiredType);  
  12.     }  
  13.     //根据Bean名称和一些指定参数，向IoC容器获取符合条件的Bean  
  14.     public Object getBean(String name, Object... args) throws BeansException {  
  15.         return getBeanFactory().getBean(name, args);  
  16. }  
 

 

通过上面这4个getBean方法源码可以看出，真正实现向IoC容器索取被管理的Bean的功能的是getBeanFactory().getBean方法。

继续追踪getBeanFactory()方法看到返回的对象是DefaultListableBeanFactory容器对象，DefaultListableBeanFactory容器的父类AbstractBeanFactory中实现了getBean方法。

3.AbstractBeanFactory通过getBean向IoC容器获取被管理的Bean：

AbstractBeanFactory的getBean相关方法的源码如下：

[java]  view plaincopy
  1. //获取IoC容器中指定名称的Bean  
  2. public Object getBean(String name) throws BeansException {  
  3.         //doGetBean才是真正向IoC容器获取被管理Bean的过程  
  4.         return doGetBean(name, null, null, false);  
  5.     }  
  6.     //获取IoC容器中指定名称和类型的Bean  
  7.     public  T getBean(String name, Class requiredType) throws BeansException {  
  8.         //doGetBean才是真正向IoC容器获取被管理Bean的过程  
  9.         return doGetBean(name, requiredType, null, false);  
  10.     }  
  11. //获取IoC容器中指定名称和参数的Bean  
  12.     public Object getBean(String name, Object... args) throws BeansException {  
  13.         //doGetBean才是真正向IoC容器获取被管理Bean的过程  
  14.         return doGetBean(name, null, args, false);  
  15.     }  
  16. //获取IoC容器中指定名称、类型和参数的Bean  
  17.     public  T getBean(String name, Class requiredType, Object... args) throws BeansException {  
  18. //doGetBean才是真正向IoC容器获取被管理Bean的过程  
  19.         return doGetBean(name, requiredType, args, false);  
  20.     }  
  21. //真正实现向IoC容器获取Bean的功能，也是触发依赖注入功能的地方  
  22.     @SuppressWarnings("unchecked")  
  23.     protected  T doGetBean(  
  24.             final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)  
  25.             throws BeansException {  
  26.         //根据指定的名称获取被管理Bean的名称，剥离指定名称中对容器的相关依赖  
  27.         //如果指定的是别名，将别名转换为规范的Bean名称  
  28.         final String beanName = transformedBeanName(name);  
  29.         Object bean;  
  30.         //先从缓存中取是否已经有被创建过的单态类型的Bean，对于单态模式的Bean整  
  31. //个IoC容器中只创建一次，不需要重复创建  
  32.         Object sharedInstance = getSingleton(beanName);  
  33.         //IoC容器创建单态模式Bean实例对象  
  34.         if (sharedInstance != null && args == null) {  
  35.             if (logger.isDebugEnabled()) {  
  36.                 //如果指定名称的Bean在容器中已有单态模式的Bean被创建，直接返回  
  37. //已经创建的Bean  
  38.                 if (isSingletonCurrentlyInCreation(beanName)) {  
  39.                     logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +  
  40.                             "' that is not fully initialized yet - a consequence of a circular reference");  
  41.                 }  
  42.                 else {  
  43.                     logger.debug("Returning cached instance of singleton bean '" + beanName + "'");  
  44.                 }  
  45.             }  
  46.             //获取给定Bean的实例对象，主要是完成FactoryBean的相关处理  
  47.             //注意：BeanFactory是管理容器中Bean的工厂，而FactoryBean是  
  48.             //创建创建对象的工厂Bean，两者之间有区别  
  49.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);  
  50.         }  
  51.         else {//缓存没有正在创建的单态模式Bean  
  52.             //缓存中已经有已经创建的原型模式Bean，但是由于循环引用的问题导致实  
  53. //例化对象失败  
  54.             if (isPrototypeCurrentlyInCreation(beanName)) {  
  55.                 throw new BeanCurrentlyInCreationException(beanName);  
  56.             }  
  57.             //对IoC容器中是否存在指定名称的BeanDefinition进行检查，首先检查是否  
  58.             //能在当前的BeanFactory中获取的所需要的Bean，如果不能则委托当前容器  
  59.             //的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找  
  60.             BeanFactory parentBeanFactory = getParentBeanFactory();  
  61.             //当前容器的父级容器存在，且当前容器中不存在指定名称的Bean  
  62.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {  
  63.                 //解析指定Bean名称的原始名称  
  64.                 String nameToLookup = originalBeanName(name);  
  65.                 if (args != null) {  
  66.                     //委派父级容器根据指定名称和显式的参数查找  
  67.                     return (T) parentBeanFactory.getBean(nameToLookup, args);  
  68.                 }  
  69.                 else {  
  70.                     //委派父级容器根据指定名称和类型查找  
  71.                     return parentBeanFactory.getBean(nameToLookup, requiredType);  
  72.                 }  
  73.             }  
  74.             //创建的Bean是否需要进行类型验证，一般不需要  
  75.             if (!typeCheckOnly) {  
  76.                 //向容器标记指定的Bean已经被创建  
  77.                 markBeanAsCreated(beanName);  
  78.             }  
  79.         //根据指定Bean名称获取其父级的Bean定义，主要解决Bean继承时子类  
  80. //合并父类公共属性问题  
  81.             final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);  
  82.             checkMergedBeanDefinition(mbd, beanName, args);  
  83.             //获取当前Bean所有依赖Bean的名称  
  84.             String[] dependsOn = mbd.getDependsOn();  
  85.             //如果当前Bean有依赖Bean  
  86.             if (dependsOn != null) {  
  87.                 for (String dependsOnBean : dependsOn) {  
  88.                     //递归调用getBean方法，获取当前Bean的依赖Bean  
  89.                     getBean(dependsOnBean);  
  90.                     //把被依赖Bean注册给当前依赖的Bean  
  91.                     registerDependentBean(dependsOnBean, beanName);  
  92.                 }  
  93.             }  
  94.             //创建单态模式Bean的实例对象  
  95.             if (mbd.isSingleton()) {  
  96.             //这里使用了一个匿名内部类，创建Bean实例对象，并且注册给所依赖的对象  
  97.                 sharedInstance = getSingleton(beanName, new ObjectFactory() {  
  98.                     public Object getObject() throws BeansException {  
  99.                         try {  
  100. //创建一个指定Bean实例对象，如果有父级继承，则合并子//类和父类的定义  
  101.                             return createBean(beanName, mbd, args);  
  102.                         }  
  103.                         catch (BeansException ex) {  
  104.                             //显式地从容器单态模式Bean缓存中清除实例对象  
  105.                             destroySingleton(beanName);  
  106.                             throw ex;  
  107.                         }  
  108.                     }  
  109.                 });  
  110.                 //获取给定Bean的实例对象  
  111.                 bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);  
  112.             }  
  113.             //IoC容器创建原型模式Bean实例对象  
  114.             else if (mbd.isPrototype()) {  
  115.                 //原型模式(Prototype)是每次都会创建一个新的对象  
  116.                 Object prototypeInstance = null;  
  117.                 try {  
  118. //回调beforePrototypeCreation方法，默认的功能是注册当前创//建的原型对象  
  119.                     beforePrototypeCreation(beanName);  
  120.                     //创建指定Bean对象实例  
  121.                     prototypeInstance = createBean(beanName, mbd, args);  
  122.                 }  
  123.                 finally {  
  124. //回调afterPrototypeCreation方法，默认的功能告诉IoC容器指//定Bean的原型对象不再创建了  
  125.                     afterPrototypeCreation(beanName);  
  126.                 }  
  127.                 //获取给定Bean的实例对象  
  128.                 bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);  
  129.             }  
  130.             //要创建的Bean既不是单态模式，也不是原型模式，则根据Bean定义资源中  
  131. //配置的生命周期范围，选择实例化Bean的合适方法，这种在Web应用程序中  
  132. //比较常用，如：request、session、application等生命周期  
  133.             else {  
  134.                 String scopeName = mbd.getScope();  
  135.                 final Scope scope = this.scopes.get(scopeName);  
  136.                 //Bean定义资源中没有配置生命周期范围，则Bean定义不合法  
  137.                 if (scope == null) {  
  138.                     throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");  
  139.                 }  
  140.                 try {  
  141.                     //这里又使用了一个匿名内部类，获取一个指定生命周期范围的实例  
  142.                     Object scopedInstance = scope.get(beanName, new ObjectFactory() {  
  143.                         public Object getObject() throws BeansException {  
  144.                             beforePrototypeCreation(beanName);  
  145.                             try {  
  146.                                 return createBean(beanName, mbd, args);  
  147.                             }  
  148.                             finally {  
  149.                                 afterPrototypeCreation(beanName);  
  150.                             }  
  151.                         }  
  152.                     });  
  153.                     //获取给定Bean的实例对象  
  154.                     bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);  
  155.                 }  
  156.                 catch (IllegalStateException ex) {  
  157.                     throw new BeanCreationException(beanName,  
  158.                             "Scope '" + scopeName + "' is not active for the current thread; " +  
  159.                             "consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",  
  160.                             ex);  
  161.                 }  
  162.             }  
  163.         }  
  164.         //对创建的Bean实例对象进行类型检查  
  165.         if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {  
  166.             throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());  
  167.         }  
  168.         return (T) bean;  
  169.     }  
 

 

通过上面对向IoC容器获取Bean方法的分析，我们可以看到在Spring中，如果Bean定义的单态模式(Singleton)，则容器在创建之前先从缓存中查找，以确保整个容器中只存在一个实例对象。如果Bean定义的是原型模式(Prototype)，则容器每次都会创建一个新的实例对象。除此之外，Bean定义还可以扩展为指定其生命周期范围。

上面的源码只是定义了根据Bean定义的模式，采取的不同创建Bean实例对象的策略，具体的Bean实例对象的创建过程由实现了ObejctFactory接口的匿名内部类的createBean方法完成，ObejctFactory使用委派模式，具体的Bean实例创建过程交由其实现类AbstractAutowireCapableBeanFactory完成，我们继续分析AbstractAutowireCapableBeanFactory的createBean方法的源码，理解其创建Bean实例的具体实现过程。

4.AbstractAutowireCapableBeanFactory创建Bean实例对象：

AbstractAutowireCapableBeanFactory类实现了ObejctFactory接口，创建容器指定的Bean实例对象，同时还对创建的Bean实例对象进行初始化处理。其创建Bean实例对象的方法源码如下：

[java]  view plaincopy
  1. //创建Bean实例对象  
  2. protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)  
  3.             throws BeanCreationException {  
  4.         if (logger.isDebugEnabled()) {  
  5.             logger.debug("Creating instance of bean '" + beanName + "'");  
  6.         }  
  7.         //判断需要创建的Bean是否可以实例化，即是否可以通过当前的类加载器加载  
  8.         resolveBeanClass(mbd, beanName);  
  9.         //校验和准备Bean中的方法覆盖  
  10.         try {  
  11.             mbd.prepareMethodOverrides();  
  12.         }  
  13.         catch (BeanDefinitionValidationException ex) {  
  14.             throw new BeanDefinitionStoreException(mbd.getResourceDescription(),  
  15.                     beanName, "Validation of method overrides failed", ex);  
  16.         }  
  17.         try {  
  18. //如果Bean配置了初始化前和初始化后的处理器，则试图返回一个需要创建//Bean的代理对象  
  19.             Object bean = resolveBeforeInstantiation(beanName, mbd);  
  20.             if (bean != null) {  
  21.                 return bean;  
  22.             }  
  23.         }  
  24.         catch (Throwable ex) {  
  25.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,  
  26.                     "BeanPostProcessor before instantiation of bean failed", ex);  
  27.         }  
  28.         //创建Bean的入口  
  29.         Object beanInstance = doCreateBean(beanName, mbd, args);  
  30.         if (logger.isDebugEnabled()) {  
  31.             logger.debug("Finished creating instance of bean '" + beanName + "'");  
  32.         }  
  33.         return beanInstance;  
  34.     }  
  35. //真正创建Bean的方法  
  36. protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {  
  37.         //封装被创建的Bean对象  
  38.         BeanWrapper instanceWrapper = null;  
  39.         if (mbd.isSingleton()){//单态模式的Bean，先从容器中缓存中获取同名Bean  
  40.             instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
  41.         }  
  42.         if (instanceWrapper == null) {  
  43.             //创建实例对象  
  44.             instanceWrapper = createBeanInstance(beanName, mbd, args);  
  45.         }  
  46.         final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);  
  47.         //获取实例化对象的类型  
  48.         Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);  
  49.         //调用PostProcessor后置处理器  
  50.         synchronized (mbd.postProcessingLock) {  
  51.             if (!mbd.postProcessed) {  
  52.                 applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);  
  53.                 mbd.postProcessed = true;  
  54.             }  
  55.         }  
  56.         // Eagerly cache singletons to be able to resolve circular references  
  57.         //向容器中缓存单态模式的Bean对象，以防循环引用  
  58.         boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&  
  59.                 isSingletonCurrentlyInCreation(beanName));  
  60.         if (earlySingletonExposure) {  
  61.             if (logger.isDebugEnabled()) {  
  62.                 logger.debug("Eagerly caching bean '" + beanName +  
  63.                         "' to allow for resolving potential circular references");  
  64.             }  
  65.             //这里是一个匿名内部类，为了防止循环引用，尽早持有对象的引用  
  66.             addSingletonFactory(beanName, new ObjectFactory() {  
  67.                 public Object getObject() throws BeansException {  
  68.                     return getEarlyBeanReference(beanName, mbd, bean);  
  69.                 }  
  70.             });  
  71.         }  
  72.         //Bean对象的初始化，依赖注入在此触发  
  73.         //这个exposedObject在初始化完成之后返回作为依赖注入完成后的Bean  
  74.         Object exposedObject = bean;  
  75.         try {  
  76.             //将Bean实例对象封装，并且Bean定义中配置的属性值赋值给实例对象  
  77.             populateBean(beanName, mbd, instanceWrapper);  
  78.             if (exposedObject != null) {  
  79.                 //初始化Bean对象  
  80.                 exposedObject = initializeBean(beanName, exposedObject, mbd);  
  81.             }  
  82.         }  
  83.         catch (Throwable ex) {  
  84.             if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {  
  85.                 throw (BeanCreationException) ex;  
  86.             }  
  87.             else {  
  88.                 throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);  
  89.             }  
  90.         }  
  91.         if (earlySingletonExposure) {  
  92.             //获取指定名称的已注册的单态模式Bean对象  
  93.             Object earlySingletonReference = getSingleton(beanName, false);  
  94.             if (earlySingletonReference != null) {  
  95.                 //根据名称获取的以注册的Bean和正在实例化的Bean是同一个  
  96.                 if (exposedObject == bean) {  
  97.                     //当前实例化的Bean初始化完成  
  98.                     exposedObject = earlySingletonReference;  
  99.                 }  
  100.                 //当前Bean依赖其他Bean，并且当发生循环引用时不允许新创建实例对象  
  101.                 else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {  
  102.                     String[] dependentBeans = getDependentBeans(beanName);  
  103.                     Set actualDependentBeans = new LinkedHashSet(dependentBeans.length);  
  104.                     //获取当前Bean所依赖的其他Bean  
  105.                     for (String dependentBean : dependentBeans) {  
  106.                         //对依赖Bean进行类型检查  
  107.                         if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {  
  108.                             actualDependentBeans.add(dependentBean);  
  109.                         }  
  110.                     }  
  111.                     if (!actualDependentBeans.isEmpty()) {  
  112.                         throw new BeanCurrentlyInCreationException(beanName,  
  113.                                 "Bean with name '" + beanName + "' has been injected into other beans [" +  
  114.                                 StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +  
  115.                                 "] in its raw version as part of a circular reference, but has eventually been " +  
  116.                                 "wrapped. This means that said other beans do not use the final version of the " +  
  117.                                 "bean. This is often the result of over-eager type matching - consider using " +  
  118.                                 "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");  
  119.                     }  
  120.                 }  
  121.             }  
  122.         }  
  123.         //注册完成依赖注入的Bean  
  124.         try {  
  125.             registerDisposableBeanIfNecessary(beanName, bean, mbd);  
  126.         }  
  127.         catch (BeanDefinitionValidationException ex) {  
  128.             throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);  
  129.         }  
  130.         return exposedObject;  
  131.     }  
 

 

通过对方法源码的分析，我们看到具体的依赖注入实现在以下两个方法中：

(1).createBeanInstance：生成Bean所包含的java对象实例。

(2).populateBean ：对Bean属性的依赖注入进行处理。

 

下面继续分析这两个方法的代码实现。

5.createBeanInstance方法创建Bean的java实例对象：

在createBeanInstance方法中，根据指定的初始化策略，使用静态工厂、工厂方法或者容器的自动装配特性生成java实例对象，创建对象的源码如下：

[java]  view plaincopy
  1. //创建Bean的实例对象  
  2. protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {  
  3.         //检查确认Bean是可实例化的  
  4.         Class beanClass = resolveBeanClass(mbd, beanName);  
  5.         //使用工厂方法对Bean进行实例化  
  6.         if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {  
  7.             throw new BeanCreationException(mbd.getResourceDescription(), beanName,  
  8.                     "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());  
  9.         }  
  10.         if (mbd.getFactoryMethodName() != null)  {  
  11.             //调用工厂方法实例化  
  12.             return instantiateUsingFactoryMethod(beanName, mbd, args);  
  13.         }  
  14.         //使用容器的自动装配方法进行实例化  
  15.         boolean resolved = false;  
  16.         boolean autowireNecessary = false;  
  17.         if (args == null) {  
  18.             synchronized (mbd.constructorArgumentLock) {  
  19.                 if (mbd.resolvedConstructorOrFactoryMethod != null) {  
  20.                     resolved = true;  
  21.                     autowireNecessary = mbd.constructorArgumentsResolved;  
  22.                 }  
  23.             }  
  24.         }  
  25.         if (resolved) {  
  26.             if (autowireNecessary) {  
  27.                 //配置了自动装配属性，使用容器的自动装配实例化  
  28.                 //容器的自动装配是根据参数类型匹配Bean的构造方法  
  29.                 return autowireConstructor(beanName, mbd, null, null);  
  30.             }  
  31.             else {  
  32.                 //使用默认的无参构造方法实例化  
  33.                 return instantiateBean(beanName, mbd);  
  34.             }  
  35.         }  
  36.         //使用Bean的构造方法进行实例化  
  37.         Constructor[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);  
  38.         if (ctors != null ||  
  39.                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||  
  40.                 mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {  
  41.             //使用容器的自动装配特性，调用匹配的构造方法实例化  
  42.             return autowireConstructor(beanName, mbd, ctors, args);  
  43.         }  
  44.         //使用默认的无参构造方法实例化  
  45.         return instantiateBean(beanName, mbd);  
  46.     }   
  47. //使用默认的无参构造方法实例化Bean对象  
  48. protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {  
  49.         try {  
  50.             Object beanInstance;  
  51.             final BeanFactory parent = this;  
  52.             //获取系统的安全管理接口，JDK标准的安全管理API  
  53.             if (System.getSecurityManager() != null) {  
  54.                 //这里是一个匿名内置类，根据实例化策略创建实例对象  
  55.                 beanInstance = AccessController.doPrivileged(new PrivilegedAction() {  
  56.                     public Object run() {  
  57.                         return getInstantiationStrategy().instantiate(mbd, beanName, parent);  
  58.                     }  
  59.                 }, getAccessControlContext());  
  60.             }  
  61.             else {  
  62.                 //将实例化的对象封装起来  
  63.                 beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);  
  64.             }  
  65.             BeanWrapper bw = new BeanWrapperImpl(beanInstance);  
  66.             initBeanWrapper(bw);  
  67.             return bw;  
  68.         }  
  69.         catch (Throwable ex) {  
  70.             throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);  
  71.         }  
  72.     }  
    73.  

     

    经过对上面的代码分析，我们可以看出，对使用工厂方法和自动装配特性的Bean的实例化相当比较清楚，调用相应的工厂方法或者参数匹配的构造方法即可完成实例化对象的工作，但是对于我们最常使用的默认无参构造方法就需要使用相应的初始化策略(JDK的反射机制或者CGLIB)来进行初始化了，在方法getInstantiationStrategy().instantiate中就具体实现类使用初始策略实例化对象。

    6.SimpleInstantiationStrategy类使用默认的无参构造方法创建Bean实例化对象：

    在使用默认的无参构造方法创建Bean的实例化对象时，方法getInstantiationStrategy().instantiate调用了SimpleInstantiationStrategy类中的实例化Bean的方法，其源码如下：

    [java]  view plaincopy
    1. //使用初始化策略实例化Bean对象  
    2. public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner) {  
    3.         //如果Bean定义中没有方法覆盖，则就不需要CGLIB父类类的方法  
    4.         if (beanDefinition.getMethodOverrides().isEmpty()) {  
    5.             Constructor constructorToUse;  
    6.             synchronized (beanDefinition.constructorArgumentLock) {  
    7.                 //获取对象的构造方法或工厂方法  
    8.                 constructorToUse = (Constructor) beanDefinition.resolvedConstructorOrFactoryMethod;  
    9.                 //如果没有构造方法且没有工厂方法  
    10.                 if (constructorToUse == null) {  
    11.                     //使用JDK的反射机制，判断要实例化的Bean是否是接口  
    12.                     final Class clazz = beanDefinition.getBeanClass();  
    13.                     if (clazz.isInterface()) {  
    14.                         throw new BeanInstantiationException(clazz, "Specified class is an interface");  
    15.                     }  
    16.                     try {  
    17.                         if (System.getSecurityManager() != null) {  
    18.                         //这里是一个匿名内置类，使用反射机制获取Bean的构造方法  
    19.                             constructorToUse = AccessController.doPrivileged(new PrivilegedExceptionAction() {  
    20.                                 public Constructor run() throws Exception {  
    21.                                     return clazz.getDeclaredConstructor((Class[]) null);  
    22.                                 }  
    23.                             });  
    24.                         }  
    25.                         else {  
    26.                             constructorToUse =  clazz.getDeclaredConstructor((Class[]) null);  
    27.                         }  
    28.                         beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;  
    29.                     }  
    30.                     catch (Exception ex) {  
    31.                         throw new BeanInstantiationException(clazz, "No default constructor found", ex);  
    32.                     }  
    33.                 }  
    34.             }  
    35. //使用BeanUtils实例化，通过反射机制调用”构造方法.newInstance(arg)”来进行实例化  
    36.             return BeanUtils.instantiateClass(constructorToUse);  
    37.         }  
    38.         else {  
    39.             //使用CGLIB来实例化对象  
    40.             return instantiateWithMethodInjection(beanDefinition, beanName, owner);  
    41.         }  
    42.     }  
     

     

    通过上面的代码分析，我们看到了如果Bean有方法被覆盖了，则使用JDK的反射机制进行实例化，否则，使用CGLIB进行实例化。

    instantiateWithMethodInjection方法调用SimpleInstantiationStrategy的子类CglibSubclassingInstantiationStrategy使用CGLIB来进行初始化，其源码如下：

    [java]  view plaincopy
    1. //使用CGLIB进行Bean对象实例化  
    2. public Object instantiate(Constructor ctor, Object[] args) {  
    3.             //CGLIB中的类  
    4.             Enhancer enhancer = new Enhancer();  
    5.     //将Bean本身作为其基类  
    6.     enhancer.setSuperclass(this.beanDefinition.getBeanClass());  
    7.             enhancer.setCallbackFilter(new CallbackFilterImpl());  
    8.             enhancer.setCallbacks(new Callback[] {  
    9.                     NoOp.INSTANCE,  
    10.                     new LookupOverrideMethodInterceptor(),  
    11.                     new ReplaceOverrideMethodInterceptor()  
    12.             });  
    13.             //使用CGLIB的create方法生成实例对象  
    14.             return (ctor == null) ?   
    15.                     enhancer.create() :   
    16.                     enhancer.create(ctor.getParameterTypes(), args);  
    17.         }  
     

     

    CGLIB是一个常用的字节码生成器的类库，它提供了一系列API实现java字节码的生成和转换功能。我们在学习JDK的动态代理时都知道，JDK的动态代理只能针对接口，如果一个类没有实现任何接口，要对其进行动态代理只能使用CGLIB。

    7.populateBean方法对Bean属性的依赖注入：

    在第4步的分析中我们已经了解到Bean的依赖注入分为以下两个过程：

    (1).createBeanInstance：生成Bean所包含的java对象实例。

    (2).populateBean ：对Bean属性的依赖注入进行处理。

    第5、6步中我们已经分析了容器初始化生成Bean所包含的Java实例对象的过程，现在我们继续分析生成对象后，Spring IoC容器是如何将Bean的属性依赖关系注入Bean实例对象中并设置好的，属性依赖注入的代码如下：

    [java]  view plaincopy
    1. //将Bean属性设置到生成的实例对象上  
    2. protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {  
    3.         //获取容器在解析Bean定义资源时为BeanDefiniton中设置的属性值  
    4.         PropertyValues pvs = mbd.getPropertyValues();  
    5.         //实例对象为null  
    6.         if (bw == null) {  
    7.             //属性值不为空  
    8.             if (!pvs.isEmpty()) {  
    9.                 throw new BeanCreationException(  
    10.                         mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");  
    11.             }  
    12.             else {  
    13.                 //实例对象为null，属性值也为空，不需要设置属性值，直接返回  
    14.                 return;  
    15.             }  
    16.         }  
    17. //在设置属性之前调用Bean的PostProcessor后置处理器  
    18.         boolean continueWithPropertyPopulation = true;  
    19.         if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {  
    20.             for (BeanPostProcessor bp : getBeanPostProcessors()) {  
    21.                 if (bp instanceof InstantiationAwareBeanPostProcessor) {  
    22.                     InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  
    23.                     if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {  
    24.                         continueWithPropertyPopulation = false;  
    25.                         break;  
    26.                     }  
    27.                 }  
    28.             }  
    29.         }  
    30.         if (!continueWithPropertyPopulation) {  
    31.             return;  
    32.         }  
    33.         //依赖注入开始，首先处理autowire自动装配的注入  
    34.         if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||  
    35.                 mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
    36.             MutablePropertyValues newPvs = new MutablePropertyValues(pvs);  
    37.             //对autowire自动装配的处理，根据Bean名称自动装配注入  
    38.             if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {  
    39.                 autowireByName(beanName, mbd, bw, newPvs);  
    40.             }  
    41.             //根据Bean类型自动装配注入  
    42.             if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {  
    43.                 autowireByType(beanName, mbd, bw, newPvs);  
    44.             }  
    45.             pvs = newPvs;  
    46.         }  
    47.         //检查容器是否持有用于处理单态模式Bean关闭时的后置处理器  
    48.         boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();  
    49.         //Bean实例对象没有依赖，即没有继承基类  
    50.         boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);  
    51.         if (hasInstAwareBpps || needsDepCheck) {  
    52.             //从实例对象中提取属性描述符  
    53.             PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);  
    54.             if (hasInstAwareBpps) {  
    55.                 for (BeanPostProcessor bp : getBeanPostProcessors()) {  
    56.                     if (bp instanceof InstantiationAwareBeanPostProcessor) {  
    57.                         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;  
    58.                         //使用BeanPostProcessor处理器处理属性值  
    59.                         pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);  
    60.                         if (pvs == null) {  
    61.                             return;  
    62.                         }  
    63.                     }  
    64.                 }  
    65.             }  
    66.             if (needsDepCheck) {  
    67.                 //为要设置的属性进行依赖检查  
    68.                 checkDependencies(beanName, mbd, filteredPds, pvs);  
    69.             }  
    70.         }  
    71.         //对属性进行注入  
    72.         applyPropertyValues(beanName, mbd, bw, pvs);  
    73.     }  
    74. //解析并注入依赖属性的过程  
    75. protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs) {  
    76.         if (pvs == null || pvs.isEmpty()) {  
    77.             return;  
    78.         }  
    79.         //封装属性值  
    80.         MutablePropertyValues mpvs = null;  
    81.         List original;  
    82.         if (System.getSecurityManager()!= null) {  
    83.             if (bw instanceof BeanWrapperImpl) {  
    84.                 //设置安全上下文，JDK安全机制  
    85.                 ((BeanWrapperImpl) bw).setSecurityContext(getAccessControlContext());  
    86.             }  
    87.         }  
    88.         if (pvs instanceof MutablePropertyValues) {  
    89.             mpvs = (MutablePropertyValues) pvs;  
    90.             //属性值已经转换  
    91.             if (mpvs.isConverted()) {  
    92.                 try {  
    93.                     //为实例化对象设置属性值  
    94.                     bw.setPropertyValues(mpvs);  
    95.                     return;  
    96.                 }  
    97.                 catch (BeansException ex) {  
    98.                     throw new BeanCreationException(  
    99.                             mbd.getResourceDescription(), beanName, "Error setting property values", ex);  
    100.                 }  
    101.             }  
    102.             //获取属性值对象的原始类型值  
    103.             original = mpvs.getPropertyValueList();  
    104.         }  
    105.         else {  
    106.             original = Arrays.asList(pvs.getPropertyValues());  
    107.         }  
    108.         //获取用户自定义的类型转换  
    109.         TypeConverter converter = getCustomTypeConverter();  
    110.         if (converter == null) {  
    111.             converter = bw;  
    112.         }  
    113.         //创建一个Bean定义属性值解析器，将Bean定义中的属性值解析为Bean实例对象  
    114. //的实际值  
    115.         BeanDefinitionValueResolver valueResolver = new BeanDefinitionValueResolver(this, beanName, mbd, converter);  
    116.         //为属性的解析值创建一个拷贝，将拷贝的数据注入到实例对象中  
    117.         List deepCopy = new ArrayList(original.size());  
    118.         boolean resolveNecessary = false;  
    119.         for (PropertyValue pv : original) {  
    120.             //属性值不需要转换  
    121.             if (pv.isConverted()) {  
    122.                 deepCopy.add(pv);  
    123.             }  
    124.             //属性值需要转换  
    125.             else {  
    126.                 String propertyName = pv.getName();  
    127.                 //原始的属性值，即转换之前的属性值  
    128.                 Object originalValue = pv.getValue();  
    129.                 //转换属性值，例如将引用转换为IoC容器中实例化对象引用  
    130.                 Object resolvedValue = valueResolver.resolveValueIfNecessary(pv, originalValue);  
    131. //转换之后的属性值  
    132.                 Object convertedValue = resolvedValue;  
    133.                 //属性值是否可以转换  
    134.                 boolean convertible = bw.isWritableProperty(propertyName) &&  
    135.                         !PropertyAccessorUtils.isNestedOrIndexedProperty(propertyName);  
    136.                 if (convertible) {  
    137.                     //使用用户自定义的类型转换器转换属性值  
    138.                     convertedValue = convertForProperty(resolvedValue, propertyName, bw, converter);  
    139.                 }  
    140.                 //存储转换后的属性值，避免每次属性注入时的转换工作  
    141.                 if (resolvedValue == originalValue) {  
    142.                     if (convertible) {  
    143.                         //设置属性转换之后的值  
    144.                         pv.setConvertedValue(convertedValue);  
    145.                     }  
    146.                     deepCopy.add(pv);  
    147.                 }  
    148.                 //属性是可转换的，且属性原始值是字符串类型，且属性的原始类型值不是  
    149.                 //动态生成的字符串，且属性的原始值不是集合或者数组类型  
    150.                 else if (convertible && originalValue instanceof TypedStringValue &&  
    151.                         !((TypedStringValue) originalValue).isDynamic() &&  
    152.                         !(convertedValue instanceof Collection || ObjectUtils.isArray(convertedValue))) {  
    153.                     pv.setConvertedValue(convertedValue);  
    154.                     deepCopy.add(pv);  
    155.                 }  
    156.                 else {  
    157.                     resolveNecessary = true;  
    158.                     //重新封装属性的值  
    159.                     deepCopy.add(new PropertyValue(pv, convertedValue));  
    160.                 }  
    161.             }  
    162.         }  
    163.         if (mpvs != null && !resolveNecessary) {  
    164.             //标记属性值已经转换过  
    165.             mpvs.setConverted();  
    166.         }  
    167.         //进行属性依赖注入  
    168.         try {  
    169.             bw.setPropertyValues(new MutablePropertyValues(deepCopy));  
    170.         }  
    171.         catch (BeansException ex) {  
    172.             throw new BeanCreationException(  
    173.                     mbd.getResourceDescription(), beanName, "Error setting property values", ex);  
    174.         }  
    175.     }  
     

     

    分析上述代码，我们可以看出，对属性的注入过程分以下两种情况：

    (1).属性值类型不需要转换时，不需要解析属性值，直接准备进行依赖注入。

    (2).属性值需要进行类型转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性值进行依赖注入。

    对属性值的解析是在BeanDefinitionValueResolver类中的resolveValueIfNecessary方法中进行的，对属性值的依赖注入是通过bw.setPropertyValues方法实现的，在分析属性值的依赖注入之前，我们先分析一下对属性值的解析过程。

    8. BeanDefinitionValueResolver解析属性值：

    当容器在对属性进行依赖注入时，如果发现属性值需要进行类型转换，如属性值是容器中另一个Bean实例对象的引用，则容器首先需要根据属性值解析出所引用的对象，然后才能将该引用对象注入到目标实例对象的属性上去，对属性进行解析的由resolveValueIfNecessary方法实现，其源码如下：

    [java]  view plaincopy
    1. //解析属性值，对注入类型进行转换  
    2. public Object resolveValueIfNecessary(Object argName, Object value) {  
    3.         //对引用类型的属性进行解析  
    4.         if (value instanceof RuntimeBeanReference) {  
    5.             RuntimeBeanReference ref = (RuntimeBeanReference) value;  
    6.             //调用引用类型属性的解析方法  
    7.             return resolveReference(argName, ref);  
    8.         }  
    9.         //对属性值是引用容器中另一个Bean名称的解析  
    10.         else if (value instanceof RuntimeBeanNameReference) {  
    11.             String refName = ((RuntimeBeanNameReference) value).getBeanName();  
    12.             refName = String.valueOf(evaluate(refName));  
    13.             //从容器中获取指定名称的Bean  
    14.             if (!this.beanFactory.containsBean(refName)) {  
    15.                 throw new BeanDefinitionStoreException(  
    16.                         "Invalid bean name '" + refName + "' in bean reference for " + argName);  
    17.             }  
    18.             return refName;  
    19.         }  
    20.         //对Bean类型属性的解析，主要是Bean中的内部类  
    21.         else if (value instanceof BeanDefinitionHolder) {  
    22.             BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;  
    23.             return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());  
    24.         }  
    25.         else if (value instanceof BeanDefinition) {  
    26.             BeanDefinition bd = (BeanDefinition) value;  
    27.             return resolveInnerBean(argName, "(inner bean)", bd);  
    28.         }  
    29.         //对集合数组类型的属性解析  
    30.         else if (value instanceof ManagedArray) {  
    31.             ManagedArray array = (ManagedArray) value;  
    32.             //获取数组的类型  
    33.             Class elementType = array.resolvedElementType;  
    34.             if (elementType == null) {  
    35.                 //获取数组元素的类型  
    36.                 String elementTypeName = array.getElementTypeName();  
    37.                 if (StringUtils.hasText(elementTypeName)) {  
    38.                     try {  
    39.                         //使用反射机制创建指定类型的对象  
    40.                         elementType = ClassUtils.forName(elementTypeName, this.beanFactory.getBeanClassLoader());  
    41.                         array.resolvedElementType = elementType;  
    42.                     }  
    43.                     catch (Throwable ex) {  
    44.                         throw new BeanCreationException(  
    45.                                 this.beanDefinition.getResourceDescription(), this.beanName,  
    46.                                 "Error resolving array type for " + argName, ex);  
    47.                     }  
    48.                 }  
    49.                 //没有获取到数组的类型，也没有获取到数组元素的类型，则直接设置数  
    50. //组的类型为Object  
    51.                 else {  
    52.                     elementType = Object.class;  
    53.                 }  
    54.             }  
    55.             //创建指定类型的数组  
    56.             return resolveManagedArray(argName, (List) value, elementType);  
    57.         }  
    58.         //解析list类型的属性值  
    59.         else if (value instanceof ManagedList) {  
    60.             return resolveManagedList(argName, (List) value);  
    61.         }  
    62.         //解析set类型的属性值  
    63.         else if (value instanceof ManagedSet) {  
    64.             return resolveManagedSet(argName, (Set) value);  
    65.         }  
    66.         //解析map类型的属性值  
    67.         else if (value instanceof ManagedMap) {  
    68.             return resolveManagedMap(argName, (Map) value);  
    69.         }  
    70.         //解析props类型的属性值，props其实就是key和value均为字符串的map  
    71.         else if (value instanceof ManagedProperties) {  
    72.             Properties original = (Properties) value;  
    73.             //创建一个拷贝，用于作为解析后的返回值  
    74.             Properties copy = new Properties();  
    75.             for (Map.Entry propEntry : original.entrySet()) {  
    76.                 Object propKey = propEntry.getKey();  
    77.                 Object propValue = propEntry.getValue();  
    78.                 if (propKey instanceof TypedStringValue) {  
    79.                     propKey = evaluate((TypedStringValue) propKey);  
    80.                 }  
    81.                 if (propValue instanceof TypedStringValue) {  
    82.                     propValue = evaluate((TypedStringValue) propValue);  
    83.                 }  
    84.                 copy.put(propKey, propValue);  
    85.             }  
    86.             return copy;  
    87.         }  
    88.         //解析字符串类型的属性值  
    89.         else if (value instanceof TypedStringValue) {  
    90.             TypedStringValue typedStringValue = (TypedStringValue) value;  
    91.             Object valueObject = evaluate(typedStringValue);  
    92.             try {  
    93.                 //获取属性的目标类型  
    94.                 Class resolvedTargetType = resolveTargetType(typedStringValue);  
    95.                 if (resolvedTargetType != null) {  
    96.                     //对目标类型的属性进行解析，递归调用  
    97.                     return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);  
    98.                 }  
    99.                 //没有获取到属性的目标对象，则按Object类型返回  
    100.                 else {  
    101.                     return valueObject;  
    102.                 }  
    103.             }  
    104.             catch (Throwable ex) {  
    105.                 throw new BeanCreationException(  
    106.                         this.beanDefinition.getResourceDescription(), this.beanName,  
    107.                         "Error converting typed String value for " + argName, ex);  
    108.             }  
    109.         }  
    110.         else {  
    111.             return evaluate(value);  
    112.         }  
    113.     }  
    114.  //解析引用类型的属性值  
    115. private Object resolveReference(Object argName, RuntimeBeanReference ref) {  
    116.         try {  
    117.             //获取引用的Bean名称  
    118.             String refName = ref.getBeanName();  
    119.             refName = String.valueOf(evaluate(refName));  
    120.             //如果引用的对象在父类容器中，则从父类容器中获取指定的引用对象  
    121.             if (ref.isToParent()) {  
    122.                 if (this.beanFactory.getParentBeanFactory() == null) {  
    123.                     throw new BeanCreationException(  
    124.                             this.beanDefinition.getResourceDescription(), this.beanName,  
    125.                             "Can't resolve reference to bean '" + refName +  
    126.                             "' in parent factory: no parent factory available");  
    127.                 }  
    128.                 return this.beanFactory.getParentBeanFactory().getBean(refName);  
    129.             }  
    130.             //从当前的容器中获取指定的引用Bean对象，如果指定的Bean没有被实例化  
    131.             //则会递归触发引用Bean的初始化和依赖注入  
    132.             else {  
    133.                 Object bean = this.beanFactory.getBean(refName);  
    134.                 //将当前实例化对象的依赖引用对象  
    135.                 this.beanFactory.registerDependentBean(refName, this.beanName);  
    136.                 return bean;  
    137.             }  
    138.         }  
    139.         catch (BeansException ex) {  
    140.             throw new BeanCreationException(  
    141.                     this.beanDefinition.getResourceDescription(), this.beanName,  
    142.                     "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " + argName, ex);  
    143.         }  
    144.     }   
    145. //解析array类型的属性  
    146. private Object resolveManagedArray(Object argName, List ml, Class elementType) {  
    147.         //创建一个指定类型的数组，用于存放和返回解析后的数组  
    148.         Object resolved = Array.newInstance(elementType, ml.size());  
    149.         for (int i = 0; i < ml.size(); i++) {  
    150.         //递归解析array的每一个元素，并将解析后的值设置到resolved数组中，索引为i  
    151.             Array.set(resolved, i,  
    152.                 resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));  
    153.         }  
    154.         return resolved;  
    155.     }  
    156.     //解析list类型的属性  
    157.     private List resolveManagedList(Object argName, List ml) {  
    158.         List resolved = new ArrayList(ml.size());  
    159.         for (int i = 0; i < ml.size(); i++) {  
    160.             //递归解析list的每一个元素  
    161.             resolved.add(  
    162.                 resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));  
    163.         }  
    164.         return resolved;  
    165.     }  
    166. //解析set类型的属性  
    167.     private Set resolveManagedSet(Object argName, Set ms) {  
    168.         Set resolved = new LinkedHashSet(ms.size());  
    169.         int i = 0;  
    170.         //递归解析set的每一个元素  
    171.         for (Object m : ms) {  
    172.             resolved.add(resolveValueIfNecessary(new KeyedArgName(argName, i), m));  
    173.             i++;  
    174.         }  
    175.         return resolved;  
    176.     }  
    177.     //解析map类型的属性  
    178.     private Map resolveManagedMap(Object argName, Map mm) {  
    179.         Map resolved = new LinkedHashMap(mm.size());  
    180.         //递归解析map中每一个元素的key和value  
    181.         for (Map.Entry entry : mm.entrySet()) {  
    182.             Object resolvedKey = resolveValueIfNecessary(argName, entry.getKey());  
    183.             Object resolvedValue = resolveValueIfNecessary(  
    184.                     new KeyedArgName(argName, entry.getKey()), entry.getValue());  
    185.             resolved.put(resolvedKey, resolvedValue);  
    186.         }  
    187.         return resolved;  
    188.     }   
      189.  

       

      通过上面的代码分析，我们明白了Spring是如何将引用类型，内部类以及集合类型等属性进行解析的，属性值解析完成后就可以进行依赖注入了，依赖注入的过程就是Bean对象实例设置到它所依赖的Bean对象属性上去，在第7步中我们已经说过，依赖注入是通过bw.setPropertyValues方法实现的，该方法也使用了委托模式，在BeanWrapper接口中至少定义了方法声明，依赖注入的具体实现交由其实现类BeanWrapperImpl来完成，下面我们就分析依BeanWrapperImpl中赖注入相关的源码。

      9.BeanWrapperImpl对Bean属性的依赖注入：

      BeanWrapperImpl类主要是对容器中完成初始化的Bean实例对象进行属性的依赖注入，即把Bean对象设置到它所依赖的另一个Bean的属性中去，依赖注入的相关源码如下：

      [java]  view plaincopy
      1. //实现属性依赖注入功能  
      2. private void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException {  
      3.         //PropertyTokenHolder主要保存属性的名称、路径，以及集合的size等信息  
      4.         String propertyName = tokens.canonicalName;  
      5.         String actualName = tokens.actualName;  
      6.         //keys是用来保存集合类型属性的size  
      7.         if (tokens.keys != null) {  
      8.             //将属性信息拷贝  
      9.             PropertyTokenHolder getterTokens = new PropertyTokenHolder();  
      10.             getterTokens.canonicalName = tokens.canonicalName;  
      11.             getterTokens.actualName = tokens.actualName;  
      12.             getterTokens.keys = new String[tokens.keys.length - 1];  
      13.             System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);  
      14.             Object propValue;  
      15.             try {  
      16. //获取属性值，该方法内部使用JDK的内省( Introspector)机制，调用属性//的getter(readerMethod)方法，获取属性的值  
      17.                 propValue = getPropertyValue(getterTokens);  
      18.             }  
      19.             catch (NotReadablePropertyException ex) {  
      20.                 throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,  
      21.                         "Cannot access indexed value in property referenced " +  
      22.                         "in indexed property path '" + propertyName + "'", ex);  
      23.             }  
      24.             //获取集合类型属性的长度  
      25.             String key = tokens.keys[tokens.keys.length - 1];  
      26.             if (propValue == null) {  
      27.                 throw new NullValueInNestedPathException(getRootClass(), this.nestedPath + propertyName,  
      28.                         "Cannot access indexed value in property referenced " +  
      29.                         "in indexed property path '" + propertyName + "': returned null");  
      30.             }  
      31.             //注入array类型的属性值  
      32.             else if (propValue.getClass().isArray()) {  
      33.                 //获取属性的描述符  
      34.                 PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);  
      35.                 //获取数组的类型  
      36.                 Class requiredType = propValue.getClass().getComponentType();  
      37.                 //获取数组的长度  
      38.                 int arrayIndex = Integer.parseInt(key);  
      39.                 Object oldValue = null;  
      40.                 try {  
      41.                     //获取数组以前初始化的值  
      42.                     if (isExtractOldValueForEditor()) {  
      43.                         oldValue = Array.get(propValue, arrayIndex);  
      44.                     }  
      45.                     //将属性的值赋值给数组中的元素  
      46.                     Object convertedValue = convertIfNecessary(propertyName, oldValue, pv.getValue(), requiredType,  
      47.                             new PropertyTypeDescriptor(pd, new MethodParameter(pd.getReadMethod(), -1), requiredType));  
      48.                     Array.set(propValue, arrayIndex, convertedValue);  
      49.                 }  
      50.                 catch (IndexOutOfBoundsException ex) {  
      51.                     throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,  
      52.                             "Invalid array index in property path '" + propertyName + "'", ex);  
      53.                 }  
      54.             }  
      55.             //注入list类型的属性值  
      56.             else if (propValue instanceof List) {  
      57.                 PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);  
      58.                 //获取list集合的类型  
      59.                 Class requiredType = GenericCollectionTypeResolver.getCollectionReturnType(  
      60.                         pd.getReadMethod(), tokens.keys.length);  
      61.                 List list = (List) propValue;  
      62.                 //获取list集合的size  
      63.                 int index = Integer.parseInt(key);  
      64.                 Object oldValue = null;  
      65.                 if (isExtractOldValueForEditor() && index < list.size()) {  
      66.                     oldValue = list.get(index);  
      67.                 }  
      68.                 //获取list解析后的属性值  
      69.                 Object convertedValue = convertIfNecessary(propertyName, oldValue, pv.getValue(), requiredType,  
      70.                         new PropertyTypeDescriptor(pd, new MethodParameter(pd.getReadMethod(), -1), requiredType));  
      71.                 if (index < list.size()) {  
      72.                     //为list属性赋值  
      73.                     list.set(index, convertedValue);  
      74.                 }  
      75.                 //如果list的长度大于属性值的长度，则多余的元素赋值为null  
      76.                 else if (index >= list.size()) {  
      77.                     for (int i = list.size(); i < index; i++) {  
      78.                         try {  
      79.                             list.add(null);  
      80.                         }  
      81.                         catch (NullPointerException ex) {  
      82.                             throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,  
      83.                                     "Cannot set element with index " + index + " in List of size " +  
      84.                                     list.size() + ", accessed using property path '" + propertyName +  
      85.                                     "': List does not support filling up gaps with null elements");  
      86.                         }  
      87.                     }  
      88.                     list.add(convertedValue);  
      89.                 }  
      90.             }  
      91.             //注入map类型的属性值  
      92.             else if (propValue instanceof Map) {  
      93.                 PropertyDescriptor pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);  
      94.                 //获取map集合key的类型  
      95.                 Class mapKeyType = GenericCollectionTypeResolver.getMapKeyReturnType(  
      96.                         pd.getReadMethod(), tokens.keys.length);  
      97.                 //获取map集合value的类型  
      98.                 Class mapValueType = GenericCollectionTypeResolver.getMapValueReturnType(  
      99.                         pd.getReadMethod(), tokens.keys.length);  
      100.                 Map map = (Map) propValue;  
      101.                 //解析map类型属性key值  
      102.                 Object convertedMapKey = convertIfNecessary(null, null, key, mapKeyType,  
      103.                         new PropertyTypeDescriptor(pd, new MethodParameter(pd.getReadMethod(), -1), mapKeyType));  
      104.                 Object oldValue = null;  
      105.                 if (isExtractOldValueForEditor()) {  
      106.                     oldValue = map.get(convertedMapKey);  
      107.                 }  
      108.                 //解析map类型属性value值  
      109.                 Object convertedMapValue = convertIfNecessary(  
      110.                         propertyName, oldValue, pv.getValue(), mapValueType,  
      111.                         new TypeDescriptor(new MethodParameter(pd.getReadMethod(), -1, tokens.keys.length + 1)));  
      112.                 //将解析后的key和value值赋值给map集合属性  
      113.                 map.put(convertedMapKey, convertedMapValue);  
      114.             }  
      115.             else {  
      116.                 throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,  
      117.                         "Property referenced in indexed property path '" + propertyName +  
      118.                         "' is neither an array nor a List nor a Map; returned value was [" + pv.getValue() + "]");  
      119.             }  
      120.         }  
      121.         //对非集合类型的属性注入  
      122.         else {  
      123.             PropertyDescriptor pd = pv.resolvedDescriptor;  
      124.             if (pd == null || !pd.getWriteMethod().getDeclaringClass().isInstance(this.object)) {  
      125.                 pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);  
      126.                 //无法获取到属性名或者属性没有提供setter(写方法)方法  
      127.                 if (pd == null || pd.getWriteMethod() == null) {  
      128.                     //如果属性值是可选的，即不是必须的，则忽略该属性值  
      129.                     if (pv.isOptional()) {  
      130.                         logger.debug("Ignoring optional value for property '" + actualName +  
      131.                                 "' - property not found on bean class [" + getRootClass().getName() + "]");  
      132.                         return;  
      133.                     }  
      134.         //如果属性值是必须的，则抛出无法给属性赋值，因为每天提供setter方法异常  
      135.                     else {  
      136.                         PropertyMatches matches = PropertyMatches.forProperty(propertyName, getRootClass());  
      137.                         throw new NotWritablePropertyException(  
      138.                                 getRootClass(), this.nestedPath + propertyName,  
      139.                                 matches.buildErrorMessage(), matches.getPossibleMatches());  
      140.                     }  
      141.                 }  
      142.                 pv.getOriginalPropertyValue().resolvedDescriptor = pd;  
      143.             }  
      144.             Object oldValue = null;  
      145.             try {  
      146.                 Object originalValue = pv.getValue();  
      147.                 Object valueToApply = originalValue;  
      148.                 if (!Boolean.FALSE.equals(pv.conversionNecessary)) {  
      149.                     if (pv.isConverted()) {  
      150.                         valueToApply = pv.getConvertedValue();  
      151.                     }  
      152.                     else {  
      153.                         if (isExtractOldValueForEditor() && pd.getReadMethod() != null) {  
      154.                             //获取属性的getter方法(读方法)，JDK内省机制  
      155.                             final Method readMethod = pd.getReadMethod();  
      156.         //如果属性的getter方法不是public访问控制权限的，即访问控制权限比较严格，  
      157.         //则使用JDK的反射机制强行访问非public的方法(暴力读取属性值)  
      158.                             if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers()) &&  
      159.                                     !readMethod.isAccessible()) {  
      160.                                 if (System.getSecurityManager()!= null) {  
      161.                                     //匿名内部类，根据权限修改属性的读取控制限制  
      162.                                     AccessController.doPrivileged(new PrivilegedAction() {  
      163.                                         public Object run() {  
      164.                                             readMethod.setAccessible(true);  
      165.                                             return null;  
      166.                                         }  
      167.                                     });  
      168.                                 }  
      169.                                 else {  
      170.                                     readMethod.setAccessible(true);  
      171.                                 }  
      172.                             }  
      173.                             try {  
      174. //属性没有提供getter方法时，调用潜在的读取属性值//的方法，获取属性值  
      175.                                 if (System.getSecurityManager() != null) {  
      176.                                     oldValue = AccessController.doPrivileged(new PrivilegedExceptionAction() {  
      177.                                         public Object run() throws Exception {  
      178.                                             return readMethod.invoke(object);  
      179.                                         }  
      180.                                     }, acc);  
      181.                                 }  
      182.                                 else {  
      183.                                     oldValue = readMethod.invoke(object);  
      184.                                 }  
      185.                             }  
      186.                             catch (Exception ex) {  
      187.                                 if (ex instanceof PrivilegedActionException) {  
      188.                                     ex = ((PrivilegedActionException) ex).getException();  
      189.                                 }  
      190.                                 if (logger.isDebugEnabled()) {  
      191.                                     logger.debug("Could not read previous value of property '" +  
      192.                                             this.nestedPath + propertyName + "'", ex);  
      193.                                 }  
      194.                             }  
      195.                         }  
      196.                         //设置属性的注入值  
      197.                         valueToApply = convertForProperty(propertyName, oldValue, originalValue, pd);  
      198.                     }  
      199.                     pv.getOriginalPropertyValue().conversionNecessary = (valueToApply != originalValue);  
      200.                 }  
      201.                 //根据JDK的内省机制，获取属性的setter(写方法)方法  
      202.                 final Method writeMethod = (pd instanceof GenericTypeAwarePropertyDescriptor ?  
      203.                         ((GenericTypeAwarePropertyDescriptor) pd).getWriteMethodForActualAccess() :  
      204.                         pd.getWriteMethod());  
      205. //如果属性的setter方法是非public，即访问控制权限比较严格，则使用JDK的反射机制，  
      206. //强行设置setter方法可访问(暴力为属性赋值)  
      207.                 if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers()) && !writeMethod.isAccessible()) {  
      208.                     //如果使用了JDK的安全机制，则需要权限验证  
      209.                     if (System.getSecurityManager()!= null) {  
      210.                         AccessController.doPrivileged(new PrivilegedAction() {  
      211.                             public Object run() {  
      212.                                 writeMethod.setAccessible(true);  
      213.                                 return null;  
      214.                             }  
      215.                         });  
      216.                     }  
      217.                     else {  
      218.                         writeMethod.setAccessible(true);  
      219.                     }  
      220.                 }  
      221.                 final Object value = valueToApply;  
      222.                 if (System.getSecurityManager() != null) {  
      223.                     try {  
      224.                         //将属性值设置到属性上去  
      225.                         AccessController.doPrivileged(new PrivilegedExceptionAction() {  
      226.                             public Object run() throws Exception {  
      227.                                 writeMethod.invoke(object, value);  
      228.                                 return null;  
      229.                             }  
      230.                         }, acc);  
      231.                     }  
      232.                     catch (PrivilegedActionException ex) {  
      233.                         throw ex.getException();  
      234.                     }  
      235.                 }  
      236.                 else {  
      237.                     writeMethod.invoke(this.object, value);  
      238.                 }  
      239.             }  
      240.             catch (TypeMismatchException ex) {  
      241.                 throw ex;  
      242.             }  
      243.             catch (InvocationTargetException ex) {  
      244.                 PropertyChangeEvent propertyChangeEvent =  
      245.                         new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName, oldValue, pv.getValue());  
      246.                 if (ex.getTargetException() instanceof ClassCastException) {  
      247.                     throw new TypeMismatchException(propertyChangeEvent, pd.getPropertyType(), ex.getTargetException());  
      248.                 }  
      249.                 else {  
      250.                     throw new MethodInvocationException(propertyChangeEvent, ex.getTargetException());  
      251.                 }  
      252.             }  
      253.             catch (Exception ex) {  
      254.                 PropertyChangeEvent pce =  
      255.                         new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName, oldValue, pv.getValue());  
      256.                 throw new MethodInvocationException(pce, ex);  
      257.             }  
      258.         }  
      259.     }  
        260.  

        通过对上面注入依赖代码的分析，我们已经明白了Spring IoC容器是如何将属性的值注入到Bean实例对象中去的：

        (1).对于集合类型的属性，将其属性值解析为目标类型的集合后直接赋值给属性。

        (2).对于非集合类型的属性，大量使用了JDK的反射和内省机制，通过属性的getter方法(reader method)获取指定属性注入以前的值，同时调用属性的setter方法(writer method)为属性设置注入后的值。看到这里相信很多人都明白了Spring的setter注入原理。

        至此Spring IoC容器对Bean定义资源文件的定位，载入、解析和依赖注入已经全部分析完毕，现在Spring IoC容器中管理了一系列靠依赖关系联系起来的Bean，应用程序不需要自己手动创建所需的对象，Spring IoC容器会在我们使用的时候自动为我们创建，并且为我们注入好相关的依赖，这就是Spring核心功能的控制反转和依赖注入的相关功能。

        你可能感兴趣的:(JAVA编程)

        • 白骑士的Java教学基础篇 2.5 控制流语句 白骑士所长 Java教学java开发语言
          欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
        • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算 码踏云端 springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
          博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
        • 品读 Java 经典巨著《Effective Java》90条编程法则，第4条：通过私有构造器强化不可实例化的能力 @赵士杰 品读《EffectiveJava》java开发语言EffectiveJava
          文章目录【前言】欢迎订阅【品读《EffectiveJava》】系列专栏java.lang.Math类的设计经验总结【前言】欢迎订阅【品读《EffectiveJava》】系列专栏《EffectiveJava》是Java开发领域的经典著作，作者JoshuaBloch以丰富的经验和深入的知识，全面探讨了Java编程中的最佳实践。这本书被公认为Java开发者的必读经典，对提升编码技巧和代码质量具有重要意义
        • Java初级学习路线概要~ 艾伦~耶格尔 Java初级java学习开发语言intellij-ideajdk
          前言如果你刚刚开始学习Java，掌握基础知识是关键。本文将提供一个详细的Java初级学习路线，帮助各位看官从基础开始，逐步掌握Java编程语言的核心概念。1.Java语言基础1.1Java简介-**Java介绍**：Java是一种广泛使用的编程语言，以其跨平台特性和面向对象设计而著名。-**应用场景**：Web应用、桌面应用、移动应用等。1.2环境搭建**安装JDK**：从[Oracle官网](h
        • 如何避免 Java 学习中误用 break 和 continue？ Itmastergo 学习
          在Java编程学习过程中，许多初学者经常会误用break和continue语句。这种情况不仅影响代码的可读性，还可能导致逻辑错误，从而使程序无法按预期工作。一、break和continue的基本概念1.1break语句break语句在Java中用于立即终止循环或者switch语句。当程序遇到break时，控制权将跳出当前的循环体或switch块，并且不再执行该结构中的剩余代码。通常情况下，brea
        • Java 学习中使用文件、网络连接等资源时，未正确关闭资源，导致资源泄漏应该怎么办？ Itmastergo java学习数据库
          在Java编程中，处理文件、网络连接、数据库连接等资源时，如果没有正确关闭资源，就会发生资源泄漏。资源泄漏会导致系统性能下降、内存占用增加，甚至可能导致程序崩溃，特别是在高负载的系统中。一、什么是资源泄漏？资源泄漏（ResourceLeak）是指程序在使用完某些资源（如文件、数据库连接、网络连接等）后，未能正确地释放这些资源，导致资源在不被使用的情况下依然占用系统的资源。这些未释放的资源会消耗内存
        • Java 学习路线：适合小白的超细学习路线及实例代码 Dreams°123 后端javaeclipsejvmspringtomcatideintellij-idea
          Java学习路线：适合小白的超细学习路线及实例代码一、入门基础1.1、Java基础语法1.2、面向对象编程(OOP)二、核心Java编程2.1、数据结构和算法基础2.2、输入输出(I/O)三、进阶Java编程3.1、多线程编程3.2、网络编程四、高级应用4.1、数据库编程4.2、Web开发4.3、框架与库五、实践项目与进阶学习（留作业啦）5.1、实践项目5.2、持续学习一、入门基础1.1、Java
        • JDBC理解 迷糊银儿
          DBC：databaseconnection这是数据库连接，JDBC是java编程语言支持的数据库连接。SUM公司提供了一些接口供各个数据库厂商实现，因为很多数据库的操作都是共用的，所以以接口的方式提供出来，由个大厂商实现。如在eclipse中引入的java-mysql-connector的jar包就实现了这些接口。数据库驱动：驱动就是两个设备之间沟通的桥梁，所以在使用数据库之前必须进行“加载驱动
        • 什么是JVM GG编程 jvm
          1.基本概念：JVM（JavaVirtualMachine，Java虚拟机）是一个用于运行Java程序的虚拟机。它是Java编程语言的核心部分，负责将Java字节码（bytecode）解释或编译成计算机可以执行的机器码，从而实现Java程序的跨平台特性。2.主要功能：(1).加载字节码：JVM将编译后的Java字节码文件（.class文件）加载到内存中。(2).字节码验证：验证字节码的正确性和安全
        • java 接口创建对象 专注API从业者 经验分享电商平台API接口java开发语言大数据数据库数据挖掘
          Java接口创建对象：深度解析与示例在Java编程中，接口是一种非常重要的概念。它不仅为不同类之间的交互提供了规范，也促进了代码的重用和解耦。本文将深入探讨如何在Java中使用接口创建对象，带您理解这一关键特性。什么是接口？接口（Interface）是一种特殊的抽象类，定义了一组方法的声明，但不提供具体的实现。接口允许我们定义类的方法，而不需要指定它们是什么。这使得接口在Java中成为实现多态性、
        • Java面试题--JVM大厂篇之深入解析JVM运行时数据区：Java开发者必读 青云交 Java大厂面试题Java技术栈Java虚拟机（JVM）专栏javaJava虚拟机的运行时数据区JVM运行时数据区程序计数器Java虚拟机栈本地方法栈堆（Heap）方法区或元空间
          引言：Java虚拟机（JVM）是Java编程语言的重要组件，它不仅实现了Java程序的跨平台特性，还高度关注内存管理和性能优化。在JVM的体系结构中，运行时数据区是实现这些特性的关键部分。本文将详细介绍JVM的运行时数据区及其各部分的作用，以帮助开发者更好地理解和优化Java程序。正文：在Java虚拟机（JVM）的运行时数据区中，主要分为若干内存区域，这些区域各自承担着不同的职责。了解这些区域及其
        • Java多线程：深入探索与详细解析 m0_63550220 java开发语言
          1.基础概念与重要性在Java编程中，多线程是并发编程的基石，它允许应用程序同时执行多个任务。这种能力不仅提高了程序的执行效率，还增强了其响应性和用户界面的流畅性。随着现代计算机系统的多核化趋势，多线程编程变得越来越重要，因为它能够充分利用硬件资源，提升程序的总体性能。线程（Thread）：作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线
        • java编程题——八皇后问题 sdg_advance java算法排序算法数据结构
          背景及问题介绍：八皇后问题（英文：Eightqueens），是由国际象棋棋手马克斯·贝瑟尔于1848年提出的问题，是回溯算法的典型案例。问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。如果经过±9
        • 空指针异常 (NullPointerException)怎么办 Itmastergo 开发语言java
          在Java编程中，空指针异常（NullPointerException，简称NPE）是最常见且困扰开发人员的异常之一。尽管Java是一种强类型语言，设计上提供了类型安全的特性，但空指针问题依然是开发过程中最常见的运行时异常之一。理解NullPointerException的产生原因及其预防措施对于编写健壮和安全的代码至关重要。一、什么是NullPointerException？NullPointe
        • 如何处理忘记实现接口所有方法 Itmastergo java学习开发语言
          在Java编程中，当你声明一个类实现了某个接口时，但没有实现接口中的所有方法，编译器会报错。这是因为接口规定了必须由实现类提供的功能，任何没有实现的接口方法，都会被认为是实现不完整的，导致编译失败。一、Java接口的基本概念1.1什么是接口接口（Interface）是Java中一种特殊的类型，它是抽象类的一种更彻底的形式。接口可以看作是一组方法的声明，任何实现这个接口的类必须提供具体的实现。接口的
        • java邮箱服务器如何配置？java怎么发邮件？ danplus EDM邮件营销邮件营销服务器SMTP服务器API接口触发式邮件营销邮件
          Java邮箱发送服务如何设置？怎么使用Java实现发邮件？通过Java编程语言，我们可以高效地配置和管理邮箱服务器，实现邮件的发送和接收功能。AokSend将详细介绍如何使用Java配置邮箱服务器的过程，并深入探讨一些常见问题的解决方案。java邮箱：安装软件需要确保服务器上已经安装了Java运行环境。然后，根据java邮箱服务器软件的官方文档，下载并解压安装包，按照步骤进行安装。安装过程中，可能
        • 《Effective Java》读书笔记-1 洵乙 《EffectiveJava》读书笔记java开发语言
          第一章引言书里写道：“本书不是针对初学者的，而是假设读者已经熟悉Java编程语言”本书大部分内容不讨论性能，而是关心如何编写出清晰、正确、可用、健壮、灵活和可维护的程序。第二章创建和销毁对象第1条【用静态工厂方法代替构造器】举例：有一个类People，当我们需要一个People的对象时，一般会用Peoplepeople=newPeople();本书建议在People类中添加一个静态方法：publi
        • Java的Base64加密解密详解 微赚淘客系统开发者 java开发语言
          Java的Base64加密解密详解大家好，我是免费搭建查券返利机器人赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！在当今数字化时代，数据的安全性和可传递性变得尤为重要。Java编程语言提供了Base64编码和解码的工具，成为保障数据传输和存储安全性的一项重要技术。让我们深入探讨Java中Base64加密解密的原理及应用。什么是Base64？Base64是一种基于64个
        • 第十六节 Java String类 程序猿小D java开发语言jdkjava-eejvmeclipseintellij-idea
          字符串广泛应用在Java编程中，在Java中字符串属于对象，Java提供了String类来创建和操作字符串。创建字符串创建字符串最简单的方式如下:Stringgreeting="Helloworld!";在代码中遇到字符串常量时，这里的值是"Helloworld!"，编译器会使用该值创建一个String对象。和其它对象一样，可以使用关键字和构造方法来创建String对象。String类有11种构造
        • 探索Java设计模式：模板方法模式 放码过来_ 设计模式java设计模式模板方法模式
          探索Java设计模式：深入理解与实践模板方法模式模板方法模式（TemplateMethodPattern）是一种行为型设计模式，它定义了一个算法的框架，并允许子类在不改变算法整体结构的情况下重定义某些步骤。在Java编程中，模板方法模式常用于封装重复的行为模式，实现算法的可扩展性。本文将通过简要介绍、实现示例及实际运用等模块，帮助读者全面掌握模板方法模式及其在Java环境下的应用。一、简要介绍模板
        • 入门Java编程的知识点—＞重写（day10） 小星袁 Java基础知识点javapythonlinux
          重点掌握重写的适用性？重写的语法?重点掌握多态是什么？多态-向上造型的语法?多态的意义?重点掌握接口是什么?接口如何语法如何定义?重点掌握引用类型转换有哪些？instanceOf关键字如何用?回顾在昨天的ExtendsDemo测试类中,我们如果想要表示多个学生对象,多个老师对象,多个医生对象,则需要使用数组来完成Student[]students=newStudent[3];students[0]
        • 2022年最新阿里Java高级岗200+面试题，掌握80%进阿里没问题 繁华哟 面试学习路线阿里巴巴android前端后端
          2022年更新的阿里集团Java岗JD标准，信息来源于阿里集团的招聘专场，包括天猫、蚂蚁金服、中间件团队的高级Java、技术专家岗位。文末随附BATJTMD等一线互联网企业的Java高级研发岗位的面试题目及答案。以下面试题能答出百分之八十你就可以去试试01阿里集团各大事业部Java岗JD标准阿里巴巴天猫1.高级JAVA工程师要求3年以上JEE开发经验；2.扎实的Java编程基础，熟悉各种设计模式3
        • JAVA Web学习(22)___第16章Hibernate技术 岁月静好浅笑安然
          第16章Hibernate技术16.1初识Hibernate16.1.1理解ORM原理16.1.2Hibernate简介Hibernate是一款免费开源的持久层框架，它对JDBC进行了轻量级的对象封装，将对象与数据库表建立了映射关系，使Java编程人员可以随心所欲地使用面向对象的编程思想操作数据库。Hibernate具有简单易用、灵活性强、扩展性强等特点，大大提高了程序的开发效率。使用传统的JDB
        • Java编程开发新手学习：数组方法的应用猜字母游戏 Java小辰
          Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。给你学习路线：html-css-js-jq-javase-数据库-jsp-servlet-Struts2-hibernate-mybatis-spring4-springmv
        • Java垃圾回收器的工作原理 java菜
          上课，老师照本宣科，实在难以理解，干脆就看书里的Java书，正好看了Java的垃圾回收器是如何工作的，觉得有必要记录一下。参考于Java编程思想第四版（ThinkinginJava）1.垃圾回收器对于提高对象的创建速度，有明显的效果问题来了，垃圾回收是释放对象，而关创建对象什么事？首先了解一下Java是如何在堆上分配内存的，Java使用“堆指针”，每分配一个对象，指针就往后移一位，类似于堆栈，这样
        • Java 进阶篇之try-catch-finally语句与自定义异常 code2cat Java进阶java开发语言ideintellij-idea
          引言在前面的文章中，我们介绍了创建、使用和导入包（Java进阶篇之异常处理的概念和种类），在Java编程中，异常处理是确保程序健壮性和稳定性的重要机制。通过异常处理，程序可以应对运行时错误，避免崩溃并提供友好的错误信息。本篇文章将详细介绍Java中的try-catch-finally语句及其使用方式，并深入探讨如何创建和使用自定义异常。通过本文，你将掌握异常处理的基本原则与高级技巧，写出更加健壮的
        • Kotlin内联类、内部类、嵌套类 维特or卡顿
          Kotlin内联类、内部类、嵌套类在开始介绍Kotlin内联类、内部类、嵌套类之前，先简要回顾一下java中的内部类java中的内部类可以将一个类的定义放在另一个类的定义内部，这就是内部类——《Java编程思想》概述在java中，内部类有一中非常有用的特性，它允许将一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。java内部类拥有其外围类所有元素的访问权，不需要特殊条件就可以访问外围类的所
        • equalsIgnoreCase方法详解 微赚淘客系统开发者 开发语言java
          equalsIgnoreCase方法详解大家好，我是免费搭建查券返利机器人赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！在Java编程的世界中，有一款强大而实用的字符串比较方法备受程序员们的关注——那就是equalsIgnoreCase()方法。今天，让我们一同深入探讨这个方法的详细用法，为你揭示在字符串比较中如何巧妙地应用equalsIgnoreCase()。1.什
        • Java必知必会-基础篇 探索星辰大海 Java必知必会java开发语言
          说明：《Java必知必会》是一档专为Java学习者设计的专栏，旨在帮助读者系统地掌握Java编程语言的核心知识，从基础语法到高级特性，从理论应用到实战演练，一站式解决你的Java学习难题。可在我的专栏里订阅，该专栏一共有15篇，本篇是第二篇。会先教会大家如何使用，并给出相应的练习题示例作业习题是帮助大家巩固所学内容，需要大家独立完成学完入门篇和基础篇就算掌握Java的常用基础知识了，下一篇开始学习
        • Java 编程中的无参构造函数：为何建议自定义？ 需要重新演唱 Java基础java开发语言
          Java编程中的无参构造函数：为何建议自定义？在Java编程中，构造函数是用于初始化对象的特殊方法。Java提供了默认的无参构造函数，但在某些情况下，建议自定义一个无参构造函数。本文将深入探讨这一建议背后的原因，并通过丰富的代码示例和详细的解释，帮助你全面理解无参构造函数的必要性及实际应用。前置知识在深入探讨之前，我们需要了解一些基本概念：构造函数：构造函数是用于初始化对象的特殊方法，与类同名，没
        • web报表工具FineReport常见的数据集报错错误代码和解释 老A不折腾 web报表finereport代码可视化工具
          在使用finereport制作报表，若预览发生错误，很多朋友便手忙脚乱不知所措了，其实没什么，只要看懂报错代码和含义，可以很快的排除错误，这里我就分享一下finereport的数据集报错错误代码和解释，如果有说的不准确的地方，也请各位小伙伴纠正一下。   NS-war-remote=错误代码\:1117 压缩部署不支持远程设计 NS_LayerReport_MultiDs=错误代码
        • Java的WeakReference与WeakHashMap bylijinnan java弱引用
          首先看看 WeakReference wiki 上 Weak reference 的一个例子： public class ReferenceTest { public static void main(String[] args) throws InterruptedException { WeakReference r = new Wea
        • Linux——（hostname）主机名与ip的映射 eksliang linuxhostname
          一、 什么是主机名 无论在局域网还是INTERNET上，每台主机都有一个IP地址，是为了区分此台主机和彼台主机，也就是说IP地址就是主机的门牌号。但IP地址不方便记忆，所以又有了域名。域名只是在公网（INtERNET)中存在，每个域名都对应一个IP地址，但一个IP地址可有对应多个域名。域名类型 linuxsir.org 这样的； 主机名是用于什么的呢？ 答：在一个局域网中，每台机器都有一个主
        • oracle 常用技巧 18289753290
          oracle常用技巧 ①复制表结构和数据   create table  temp_clientloginUser as   select distinct userid from tbusrtloginlog ②仅复制数据 如果表结构一样 insert into  mytable  select  * &nb
        • 使用c3p0数据库连接池时出现com.mchange.v2.resourcepool.TimeoutException 酷的飞上天空 exception
          有一个线上环境使用的是c3p0数据库，为外部提供接口服务。最近访问压力增大后台tomcat的日志里面频繁出现 com.mchange.v2.resourcepool.TimeoutException: A client timed out while waiting to acquire a resource from com.mchange.v2.resourcepool.BasicResou
        • IT系统分析师如何学习大数据 蓝儿唯美 大数据
          我是一名从事大数据项目的IT系统分析师。在深入这个项目前需要了解些什么呢？学习大数据的最佳方法就是先从了解信息系统是如何工作着手，尤其是数据库和基础设施。同样在开始前还需要了解大数据工具，如Cloudera、Hadoop、Spark、Hive、Pig、Flume、Sqoop与Mesos。系 统分析师需要明白如何组织、管理和保护数据。在市面上有几十款数据管理产品可以用于管理数据。你的大数据数据库可能
        • spring学习——简介 a-john spring
          Spring是一个开源框架，是为了解决企业应用开发的复杂性而创建的。Spring使用基本的JavaBean来完成以前只能由EJB完成的事情。然而Spring的用途不仅限于服务器端的开发，从简单性，可测试性和松耦合的角度而言，任何Java应用都可以从Spring中受益。其主要特征是依赖注入、AOP、持久化、事务、SpringMVC以及Acegi Security 为了降低Java开发的复杂性，
        • 自定义颜色的xml文件 aijuans xml
          <?xml version="1.0" encoding="utf-8"?> <resources> <color name="white">#FFFFFF</color> <color name="black">#000000</color> &
        • 运营到底是做什么的？ aoyouzi 运营到底是做什么的？
          文章来源：夏叔叔（微信号：woshixiashushu），欢迎大家关注！很久没有动笔写点东西，近些日子，由于爱狗团产品上线，不断面试，经常会被问道一个问题。问：爱狗团的运营主要做什么？答：带着用户一起嗨。为什么是带着用户玩起来呢？究竟什么是运营？运营到底是做什么的？那么，我们先来回答一个更简单的问题——互联网公司对运营考核什么？以爱狗团为例，绝大部分的移动互联网公司，对运营部门的考核分为三块——用
        • js面向对象类和对象 百合不是茶 js面向对象函数创建类和对象
          接触js已经有几个月了,但是对js的面向对象的一些概念根本就是模糊的,js是一种面向对象的语言 但又不像java一样有class,js不是严格的面向对象语言 ,js在java web开发的地位和java不相上下  ,其中web的数据的反馈现在主流的使用json,json的语法和js的类和属性的创建相似   下面介绍一些js的类和对象的创建的技术   一:类和对
        • web.xml之资源管理对象配置 resource-env-ref bijian1013 javaweb.xmlservlet
          resource-env-ref元素来指定对管理对象的servlet引用的声明，该对象与servlet环境中的资源相关联 <resource-env-ref> <resource-env-ref-name>资源名</resource-env-ref-name> <resource-env-ref-type>查找资源时返回的资源类
        • Create a composite component with a custom namespace sunjing
          https://weblogs.java.net/blog/mriem/archive/2013/11/22/jsf-tip-45-create-composite-component-custom-namespace   When you developed a composite component the namespace you would be seeing would
        • 【MongoDB学习笔记十二】Mongo副本集服务器角色之Arbiter bit1129 mongodb
           一、复本集为什么要加入Arbiter这个角色 回答这个问题，要从复本集的存活条件和Aribter服务器的特性两方面来说。 什么是Artiber？ An arbiter does not have a copy of data set and cannot become a primary. Replica sets may have arbiters to add a
        • Javascript开发笔记 白糖_ JavaScript
          获取iframe内的元素 通常我们使用window.frames["frameId"].document.getElementById("divId").innerHTML这样的形式来获取iframe内的元素，这种写法在IE、safari、chrome下都是通过的，唯独在fireforx下不通过。其实jquery的contents方法提供了对if
        • Web浏览器Chrome打开一段时间后，运行alert无效 bozch Webchormealert无效
          今天在开发的时候，突然间发现alert在chrome浏览器就没法弹出了，很是怪异。 试了试其他浏览器，发现都是没有问题的。 开始想以为是chorme浏览器有啥机制导致的，就开始尝试各种代码让alert出来。尝试结果是仍然没有显示出来。 这样开发的结果，如果客户在使用的时候没有提示，那会带来致命的体验。哎，没啥办法了 就关闭浏览器重启。   结果就好了，这也太怪异了。难道是cho
        • 编程之美-高效地安排会议 图着色问题 贪心算法 bylijinnan 编程之美
          import java.util.ArrayList; import java.util.Collections; import java.util.List; import java.util.Random; public class GraphColoringProblem { /**编程之美 高效地安排会议 图着色问题 贪心算法 * 假设要用很多个教室对一组
        • 机器学习相关概念和开发工具 chenbowen00 算法matlab机器学习
          基本概念： 机器学习(Machine Learning, ML)是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多门学科。专门研究计算机怎样模拟或实现人类的学习行为，以获取新的知识或技能，重新组织已有的知识结构使之不断改善自身的性能。 它是人工智能的核心，是使计算机具有智能的根本途径，其应用遍及人工智能的各个领域，它主要使用归纳、综合而不是演绎。 开发工具 M
        • [宇宙经济学]关于在太空建立永久定居点的可能性 comsci 经济
                 大家都知道,地球上的房地产都比较昂贵,而且土地证经常会因为新的政府的意志而变幻文本格式........        所以,在地球议会尚不具有在太空行使法律和权力的力量之前,我们外太阳系统的友好联盟可以考虑在地月系的某些引力平衡点上面,修建规模较大的定居点
        • oracle 11g database control 证书错误 daizj oracle证书错误oracle 11G 安装
          oracle 11g database control 证书错误  win7 安装完oracle11后打开 Database control 后，会打开em管理页面，提示证书错误，点“继续浏览此网站”，还是会继续停留在证书错误页面 解决办法： 是 KB2661254 这个更新补丁引起的，它限制了 RSA 密钥位长度少于 1024 位的证书的使用。具体可以看微软官方公告：
        • Java I/O之用FilenameFilter实现根据文件扩展名删除文件 游其是你 FilenameFilter
          在Java中，你可以通过实现FilenameFilter类并重写accept(File dir, String name) 方法实现文件过滤功能。 在这个例子中，我们向你展示在“c:\\folder”路径下列出所有“.txt”格式的文件并删除。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16
        • C语言数组的简单以及一维数组的简单排序算法示例，二维数组简单示例 dcj3sjt126com carray
          # include <stdio.h> int main(void) { int a[5] = {1, 2, 3, 4, 5}; //a 是数组的名字 5是表示数组元素的个数，并且这五个元素分别用a[0], a[1]...a[4] int i; for (i=0; i<5; ++i) printf("%d\n",
        • PRIMARY, INDEX, UNIQUE 这3种是一类 PRIMARY 主键。 就是 唯一 且 不能为空。 INDEX 索引，普通的 UNIQUE 唯一索引 dcj3sjt126com primary
          PRIMARY, INDEX, UNIQUE 这3种是一类PRIMARY 主键。 就是 唯一 且 不能为空。INDEX 索引，普通的UNIQUE 唯一索引。 不允许有重复。FULLTEXT 是全文索引，用于在一篇文章中，检索文本信息的。举个例子来说，比如你在为某商场做一个会员卡的系统。这个系统有一个会员表有下列字段：会员编号   INT会员姓名  
        • java集合辅助类 Collections、Arrays shuizhaosi888 CollectionsArraysHashCode
            Arrays、Collections   1 ）数组集合之间转换 public static <T> List<T> asList(T... a) { return new ArrayList<>(a); }      a）Arrays.asL
        • Spring Security（10）——退出登录logout 234390216 logoutSpring Security退出登录logout-urlLogoutFilter
                 要实现退出登录的功能我们需要在http元素下定义logout元素，这样Spring Security将自动为我们添加用于处理退出登录的过滤器LogoutFilter到FilterChain。当我们指定了http元素的auto-config属性为true时logout定义是会自动配置的，此时我们默认退出登录的URL为“/j_spring_secu
        • 透过源码学前端 之 Backbone 三 Model 逐行分析JS源代码 backbone源码分析js学习
          Backbone 分析第三部分  Model 概述： Model 提供了数据存储，将数据以JSON的形式保存在 Model的 attributes里， 但重点功能在于其提供了一套功能强大，使用简单的存、取、删、改数据方法，并在不同的操作里加了相应的监听事件， 如每次修改添加里都会触发 change，这在据模型变动来修改视图时很常用，并且与collection建立了关联。
        • SpringMVC源码总结（七）mvc:annotation-driven中的HttpMessageConverter 乒乓狂魔 springMVC
          这一篇文章主要介绍下HttpMessageConverter整个注册过程包含自定义的HttpMessageConverter，然后对一些HttpMessageConverter进行具体介绍。 HttpMessageConverter接口介绍： public interface HttpMessageConverter<T> { /** * Indicate
        • 分布式基础知识和算法理论 bluky999 算法zookeeper分布式一致性哈希paxos
            分布式基础知识和算法理论 BY [email protected] 本文永久链接：http://nodex.iteye.com/blog/2103218   在大数据的背景下，不管是做存储，做搜索，做数据分析，或者做产品或服务本身，面向互联网和移动互联网用户，已经不可避免地要面对分布式环境。笔者在此收录一些分布式相关的基础知识和算法理论介绍，在完善自我知识体系的同
        • Android Studio的.gitignore以及gitignore无效的解决 bell0901 androidgitignore
          　　github上.gitignore模板合集，里面有各种.gitignore ： https://github.com/github/gitignore 　　自己用的Android Studio下项目的.gitignore文件，对github上的android.gitignore添加了 　　　　　　# OSX files　　　　　　//mac os下　　　　　　.DS_Store
        • 成为高级程序员的10个步骤 tomcat_oracle 编程
          What 软件工程师的职业生涯要历经以下几个阶段：初级、中级，最后才是高级。这篇文章主要是讲如何通过 10 个步骤助你成为一名高级软件工程师。   Why 得到更多的报酬！因为你的薪水会随着你水平的提高而增加 提升你的职业生涯。成为了高级软件工程师之后，就可以朝着架构师、团队负责人、CTO 等职位前进 历经更大的挑战。随着你的成长，各种影响力也会提高。
        • mongdb在linux下的安装 xtuhcy mongodblinux
          一、查询linux版本号： lsb_release -a  LSB Version:    :base-4.0-amd64:base-4.0-noarch:core-4.0-amd64:core-4.0-noarch:graphics-4.0-amd64:graphics-4.0-noarch:printing-4.0-amd64:printing-4.0-noa