毛子果
毛子果

2018-05-05

spring源码分析（三）

目录

五、Spring 源码解读
--5.4、IOC 容器的依赖注入
----1、依赖注入发生的时间
----2、AbstractBeanFactory 通过 getBean 向 IOC 容器获取被管理的 Bean
----3、AbstractAutowireCapableBeanFactory 创建 Bean 实例对象
----4、createBeanInstance 方法创建 Bean 的 java 实例对象
----5、SimpleInstantiationStrategy 类使用默认的无参构造方法创建 Bean 实例化对象
----6、populateBean 方法对 Bean 属性的依赖注入
----7、BeanDefinitionValueResolver 解析属性值
----8、BeanWrapperImpl 对 Bean 属性的依赖注入

五、Spring 源码解读

5.4、IOC 容器的依赖注入

1、依赖注入发生的时间

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

(1).用户第一次通过 getBean 方法向 IOC 容索要 Bean 时，IOC 容器触发依赖注入。
(2).当用户在 Bean 定义资源中为元素配置了 lazy-init 属性，即让容器在解析注册 Bean 定义时 进行预实例化，触发依赖注入。

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


2018-05-05_第1张图片
abstractBeanFactory.PNG

在 BeanFactory 中我们看到 getBean（String…）函数，它的具体实现在 AbstractBeanFactory 中

2、AbstractBeanFactory 通过 getBean 向 IOC 容器获取被管理的 Bean：
AbstractBeanFactory 的 getBean 相关方法的源码如下：

//获取 IOC 容器中指定名称的 Bean
public Object getBean(String name) throws BeansException {
    //doGetBean 才是真正向 IoC 容器获取被管理 Bean 的过程
    return doGetBean(name, null, null, false);
}
//获取 IOC 容器中指定名称和类型的 Bean
public  T getBean(String name, Class requiredType) throws BeansException {
    //doGetBean 才是真正向 IoC 容器获取被管理 Bean 的过程
    return doGetBean(name, requiredType, null, false);
}
//获取 IOC 容器中指定名称和参数的 Bean
public Object getBean(String name, Object... args) throws BeansException {
    //doGetBean 才是真正向 IoC 容器获取被管理 Bean 的过程
    return doGetBean(name, null, args, false);
}
//获取 IOC 容器中指定名称、类型和参数的 Bean
public  T getBean(String name, Class requiredType, Object... args) throws BeansException {
    //doGetBean 才是真正向 IoC 容器获取被管理 Bean 的过程
    return doGetBean(name, requiredType, args, false);
}
//真正实现向 IOC 容器获取 Bean 的功能，也是触发依赖注入功能的地方
@SuppressWarnings("unchecked")
protected  T doGetBean(
final String name, final Class requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
//根据指定的名称获取被管理 Bean 的名称，剥离指定名称中对容器的相关依赖
//如果指定的是别名，将别名转换为规范的 Bean 名称
    final String beanName = transformedBeanName(name);
    Object bean;
    //先从缓存中取是否已经有被创建过的单态类型的 Bean
    //对于单例模式的 Bean 整个 IOC 容器中只创建一次，不需要重复创建
    Object sharedInstance = getSingleton(beanName);
    //IOC 容器创建单例模式 Bean 实例对象
    if (sharedInstance != null && args == null) {
        if (logger.isDebugEnabled()) {
            //如果指定名称的 Bean 在容器中已有单例模式的 Bean 被创建
            //直接返回已经创建的 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 的实例对象，主要是完成 FactoryBean 的相关处理
        //注意：BeanFactory 是管理容器中 Bean 的工厂，而 FactoryBean 是
        //创建创建对象的工厂 Bean，两者之间有区别
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
        
    }else {
        //缓存没有正在创建的单例模式 Bean
        //缓存中已经有已经创建的原型模式 Bean
        //但是由于循环引用的问题导致实例化对象失败
        if (isPrototypeCurrentlyInCreation(beanName)) {
             throw new BeanCurrentlyInCreationException(beanName);
        }
        //对 IOC 容器中是否存在指定名称的 BeanDefinition 进行检查，首先检查是否
        //能在当前的 BeanFactory 中获取的所需要的 Bean，如果不能则委托当前容器
        //的父级容器去查找，如果还是找不到则沿着容器的继承体系向父级容器查找
        BeanFactory parentBeanFactory = getParentBeanFactory();
        //当前容器的父级容器存在，且当前容器中不存在指定名称的 Bean
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            //解析指定 Bean 名称的原始名称
            String nameToLookup = originalBeanName(name);
            if (args != null) {
                //委派父级容器根据指定名称和显式的参数查找
                return (T) parentBeanFactory.getBean(nameToLookup, args);
            } else {
                //委派父级容器根据指定名称和类型查找
                return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
        }
        //创建的 Bean 是否需要进行类型验证，一般不需要
        if (!typeCheckOnly) {
            //向容器标记指定的 Bean 已经被创建
            markBeanAsCreated(beanName);
        }
        //根据指定 Bean 名称获取其父级的 Bean 定义
        //主要解决 Bean 继承时子类合并父类公共属性问题
        final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        checkMergedBeanDefinition(mbd, beanName, args);
        //获取当前 Bean 所有依赖 Bean 的名称
        String[] dependsOn = mbd.getDependsOn();
        //如果当前 Bean 有依赖 Bean
        if (dependsOn != null) {
            for (String dependsOnBean : dependsOn) {
                //递归调用 getBean 方法，获取当前 Bean 的依赖 Bean
                getBean(dependsOnBean);
                //把被依赖 Bean 注册给当前依赖的 Bean
                registerDependentBean(dependsOnBean, beanName);
            }
        }
        //创建单例模式 Bean 的实例对象
        if (mbd.isSingleton()) {
            //这里使用了一个匿名内部类，创建 Bean 实例对象，并且注册给所依赖的对象
            sharedInstance = getSingleton(beanName, new ObjectFactory() {
                public Object getObject() throws BeansException {
                    try {
                        //创建一个指定 Bean 实例对象，如果有父级继承，则合并子类和父类的定义
                        return createBean(beanName, mbd, args);
                    }catch (BeansException ex) {
                        //显式地从容器单例模式 Bean 缓存中清除实例对象
                        destroySingleton(beanName);
                        throw ex;
                    }
                }
            });
            //获取给定 Bean 的实例对象
            bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
        //IOC 容器创建原型模式 Bean 实例对象
        else if (mbd.isPrototype()) {
            //原型模式(Prototype)是每次都会创建一个新的对象
            Object prototypeInstance = null;
            try {
                //回调 beforePrototypeCreation 方法，默认的功能是注册当前创//建的原型对象
                beforePrototypeCreation(beanName);
                //创建指定 Bean 对象实例
                prototypeInstance = createBean(beanName, mbd, args);
            }finally {
                //回调 afterPrototypeCreation 方法，默认的功能告诉 IoC 容器指定 Bean 的原型对象不再创建了
                afterPrototypeCreation(beanName);
            }
            //获取给定 Bean 的实例对象
            bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
        }
        //要创建的 Bean 既不是单例模式，也不是原型模式，则根据 Bean 定义资源中
        //配置的生命周期范围，选择实例化 Bean 的合适方法，这种在 Web 应用程序中
        //比较常用，如：request、session、application 等生命周期
        else {
            String scopeName = mbd.getScope();
            final Scope scope = this.scopes.get(scopeName);
            //Bean 定义资源中没有配置生命周期范围，则 Bean 定义不合法
            if (scope == null) {
                throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");
            }
            try {
                //这里又使用了一个匿名内部类，获取一个指定生命周期范围的实例
                Object scopedInstance = scope.get(beanName, new ObjectFactory() {
                    public Object getObject() throws BeansException {
                        beforePrototypeCreation(beanName);
                        try {
                            return createBean(beanName, mbd, args);
                        }finally {
                            afterPrototypeCreation(beanName);
                        }
                    }
                });
                //获取给定 Bean 的实例对象
                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);
            }
        }
    }
    //对创建的 Bean 实例对象进行类型检查
    if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass()){
         throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    }
    return (T) bean;
}

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

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

3、AbstractAutowireCapableBeanFactory 创建 Bean 实例对象：

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

//创建 Bean 实例对象
protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[]
args) throws BeanCreationException {
    if (logger.isDebugEnabled()) {
     logger.debug("Creating instance of bean '" + beanName + "'");
    }
    //判断需要创建的 Bean 是否可以实例化，即是否可以通过当前的类加载器加载
    resolveBeanClass(mbd, beanName);
    //校验和准备 Bean 中的方法覆盖
    try {
     mbd.prepareMethodOverrides();
    }catch (BeanDefinitionValidationException ex) {
     throw new BeanDefinitionStoreException(mbd.getResourceDescription(),
    beanName, "Validation of method overrides failed", ex);
    }
    try {
        //如果 Bean 配置了初始化前和初始化后的处理器，则试图返回一个需要创建 Bean 的代理对象
        Object bean = resolveBeforeInstantiation(beanName, mbd);
        if (bean != null) {
            return bean;
        }
    }catch (Throwable ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
    "BeanPostProcessor before instantiation of bean failed", ex);
    }
    //创建 Bean 的入口
    Object beanInstance = doCreateBean(beanName, mbd, args);
    if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
    }
    return beanInstance;
}
//真正创建 Bean 的方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    //封装被创建的 Bean 对象
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()){//单例模式的 Bean，先从容器中缓存中获取同名 Bean
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
      //创建实例对象
     instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    //获取实例化对象的类型
    Class beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);
    //调用 PostProcessor 后置处理器
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            mbd.postProcessed = true;
        }
    }
    // Eagerly cache singletons to be able to resolve circular references
    //向容器中缓存单例模式的 Bean 对象，以防循环引用
    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");
            }
            //这里是一个匿名内部类，为了防止循环引用，尽早持有对象的引用
            addSingletonFactory(beanName, new ObjectFactory() {
                public Object getObject() throws BeansException {
                    return getEarlyBeanReference(beanName, mbd, bean);
                }
            });
    }
    //Bean 对象的初始化，依赖注入在此触发
    //这个 exposedObject 在初始化完成之后返回作为依赖注入完成后的 Bean
    Object exposedObject = bean;
    try {
        //将 Bean 实例对象封装，并且 Bean 定义中配置的属性值赋值给实例对象
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            //初始化 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) {
                //当前实例化的 Bean 初始化完成
                exposedObject = earlySingletonReference;    
            }
            //当前 Bean 依赖其他 Bean，并且当发生循环引用时不允许新创建实例对象
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
                String[] dependentBeans = getDependentBeans(beanName);
                Set actualDependentBeans = new
                LinkedHashSet(dependentBeans.length);
                //获取当前 Bean 所依赖的其他 Bean
                for (String dependentBean : dependentBeans) {
                    //对依赖 Bean 进行类型检查
                    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.");
                }
            }
        }
    }
    //注册完成依赖注入的 Bean
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid
        destruction signature", ex);
    }
    return exposedObject;
}

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

(1).createBeanInstance：生成 Bean 所包含的 java 对象实例。
(2).populateBean ：对 Bean 属性的依赖注入进行处理。

4、createBeanInstance 方法创建 Bean 的 java 实例对象：

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

//创建 Bean 的实例对象
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args)
{
    //检查确认 Bean 是可实例化的
    Class beanClass = resolveBeanClass(mbd, beanName);
    //使用工厂方法对 Bean 进行实例化
    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());
    }
    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) {
            //配置了自动装配属性，使用容器的自动装配实例化
            //容器的自动装配是根据参数类型匹配 Bean 的构造方法
            return autowireConstructor(beanName, mbd, null, null);
        }else {
            //使用默认的无参构造方法实例化
            return instantiateBean(beanName, mbd);
        }
    }
    //使用 Bean 的构造方法进行实例化
    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);
}
//使用默认的无参构造方法实例化 Bean 对象
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(new PrivilegedAction() {
                public Object run() {
                     return 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);
    }
}
 
 
经过对上面的代码分析，我们可以看出，对使用工厂方法和自动装配特性的 Bean 的实例化相当比较清 楚，调用相应的工厂方法或者参数匹配的构造方法即可完成实例化对象的工作，但是对于我们最常使用 的默认无参构造方法就需要使用相应的初始化策略(JDK 的反射机制或者 CGLIB)来进行初始化了，在方 法 getInstantiationStrategy().instantiate 中就具体实现类使用初始策略实例化对象。
 
 
5、SimpleInstantiationStrategy 类使用默认的无参构造方法创建 Bean 实例化对象：
 
 
在使用默认的无参构造方法创建Bean的实例化对象时，方法getInstantiationStrategy().instantiate 调用了 SimpleInstantiationStrategy 类中的实例化 Bean 的方法，其源码如下：
 
 
//使用初始化策略实例化 Bean 对象
public Object instantiate(RootBeanDefinition beanDefinition, String beanName, BeanFactory owner)
{
    //如果 Bean 定义中没有方法覆盖，则就不需要 CGLIB 父类类的方法
    if (beanDefinition.getMethodOverrides().isEmpty()) {
        Constructor constructorToUse;
        synchronized (beanDefinition.constructorArgumentLock) {
            //获取对象的构造方法或工厂方法
            constructorToUse = (Constructor)
            beanDefinition.resolvedConstructorOrFactoryMethod;
            //如果没有构造方法且没有工厂方法
            if (constructorToUse == null) {
                //使用 JDK 的反射机制，判断要实例化的 Bean 是否是接口
                final Class clazz = beanDefinition.getBeanClass();
                if (clazz.isInterface()) {
                 throw new BeanInstantiationException(clazz, "Specified class is an interface");
                }
                try {
                    if (System.getSecurityManager() != null) {
                        //这里是一个匿名内置类，使用反射机制获取 Bean 的构造方法
                        constructorToUse = AccessController.doPrivileged(new
                        PrivilegedExceptionAction() {
                            public Constructor run() throws Exception {
                                return clazz.getDeclaredConstructor((Class[]) null);
                            }
                        });
                    }else {
                        constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
                    }
                    beanDefinition.resolvedConstructorOrFactoryMethod = constructorToUse;
                }catch (Exception ex) {
                    throw new BeanInstantiationException(clazz, "No default constructor found",
               }
            }
        }
        //使用 BeanUtils 实例化，通过反射机制调用”构造方法.newInstance(arg)”来进行实例化
        return BeanUtils.instantiateClass(constructorToUse);
    }else {
        //使用 CGLIB 来实例化对象
        return instantiateWithMethodInjection(beanDefinition, beanName, owner);
    }
}   

 
 
通过上面的代码分析，我们看到了如果 Bean 有方法被覆盖了，则使用 JDK 的反射机制进行实例化，否 则，使用 CGLIB 进行实例化。
 
 
instantiateWithMethodInjection 方法调用 SimpleInstantiationStrategy 的子类 CglibSubclassingInstantiationStrategy 使用 CGLIB 来进行初始化，其源码如下：
 
 
//使用 CGLIB 进行 Bean 对象实例化
public Object instantiate(Constructor ctor, Object[] args) {
    //CGLIB 中的类
    Enhancer enhancer = new Enhancer();
    //将 Bean 本身作为其基类
    enhancer.setSuperclass(this.beanDefinition.getBeanClass());
    enhancer.setCallbackFilter(new CallbackFilterImpl());
    enhancer.setCallbacks(new Callback[] {
        NoOp.INSTANCE,
        new LookupOverrideMethodInterceptor(),
        new ReplaceOverrideMethodInterceptor()
    });
    //使用 CGLIB 的 create 方法生成实例对象
    return (ctor == null) ?
    enhancer.create() :
    enhancer.create(ctor.getParameterTypes(), args);
}

 
 
CGLIB 是一个常用的字节码生成器的类库，它提供了一系列 API 实现 java 字节码的生成和转换功能。我们在学习 JDK 的动态代理时都知道，JDK 的动态代理只能针对接口，如果一个类没有实现任何接口，要对其进行动态代理只能使用 CGLIB。
 
 
6、populateBean 方法对 Bean 属性的依赖注入：
 
 
在第 3 步的分析中我们已经了解到 Bean 的依赖注入分为以下两个过程：
 
 
 
  
(1).createBeanInstance：生成 Bean 所包含的 java 对象实例。
 (2).populateBean ：对 Bean 属性的依赖注入进行处理。
 
 
 
 
第 4、5 步中我们已经分析了容器初始化生成 Bean 所包含的 Java 实例对象的过程，现在我们继续分析
 生成对象后，Spring IOC 容器是如何将 Bean 的属性依赖关系注入 Bean 实例对象中并设置好的，属性
 依赖注入的代码如下：
 
 
//将 Bean 属性设置到生成的实例对象上
protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {
    //获取容器在解析 Bean 定义资源时为 BeanDefiniton 中设置的属性值
    PropertyValues pvs = mbd.getPropertyValues();
    //实例对象为 null
    if (bw == null) {
        //属性值不为空
        if (!pvs.isEmpty()) {
            throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Cannot apply property values to null
            instance");
        }
        else {
            //实例对象为 null，属性值也为空，不需要设置属性值，直接返回
            return;
        }
    }
    //在设置属性之前调用 Bean 的 PostProcessor 后置处理器
    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;
    }
    //依赖注入开始，首先处理 autowire 自动装配的注入
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
    mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        //对 autowire 自动装配的处理，根据 Bean 名称自动装配注入
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
         autowireByName(beanName, mbd, bw, newPvs);
        }
        //根据 Bean 类型自动装配注入
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
         autowireByType(beanName, mbd, bw, newPvs);
        }
        pvs = newPvs;
    }
    //检查容器是否持有用于处理单例模式 Bean 关闭时的后置处理器
    boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
    //Bean 实例对象没有依赖，即没有继承基类
    boolean needsDepCheck = (mbd.getDependencyCheck() !=
    RootBeanDefinition.DEPENDENCY_CHECK_NONE);
    if (hasInstAwareBpps || needsDepCheck) {
        //从实例对象中提取属性描述符
        PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw);
        if (hasInstAwareBpps) {
            for (BeanPostProcessor bp : getBeanPostProcessors()) {
                if (bp instanceof InstantiationAwareBeanPostProcessor) {
                     InstantiationAwareBeanPostProcessor ibp =
                        (InstantiationAwareBeanPostProcessor) bp;
                    //使用 BeanPostProcessor 处理器处理属性值
                    pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(),beanName);
                    if (pvs == null) {
                        return;
                    }
                }
            }
        }
        if (needsDepCheck) {
            //为要设置的属性进行依赖检查
            checkDependencies(beanName, mbd, filteredPds, pvs);
        }
    }
    //对属性进行注入
    applyPropertyValues(beanName, mbd, bw, pvs);
}
//解析并注入依赖属性的过程
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw,
PropertyValues pvs) {
    if (pvs == null || 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;
    }
    //创建一个 Bean 定义属性值解析器，将 Bean 定义中的属性值解析为 Bean 实例对象的实际值
    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();
            //转换属性值，例如将引用转换为 IOC 容器中实例化对象引用
            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);
    }
}

 
 
分析上述代码，我们可以看出，对属性的注入过程分以下两种情况：
 
 
 
  
(1).属性值类型不需要转换时，不需要解析属性值，直接准备进行依赖注入。
 (2).属性值需要进行类型转换时，如对其他对象的引用等，首先需要解析属性值，然后对解析后的属性 值进行依赖注入。
 
 
 
 
对属性值的解析是在 BeanDefinitionValueResolver 类中的 resolveValueIfNecessary 方法中进行的， 对属性值的依赖注入是通过 bw.setPropertyValues 方法实现的，在分析属性值的依赖注入之前，我们 先分析一下对属性值的解析过程。
 
 
7、BeanDefinitionValueResolver 解析属性值：
 
 
当容器在对属性进行依赖注入时，如果发现属性值需要进行类型转换，如属性值是容器中另一个 Bean 实例对象的引用，则容器首先需要根据属性值解析出所引用的对象，然后才能将该引用对象注入到目标 实例对象的属性上去，对属性进行解析的由 resolveValueIfNecessary 方法实现，其源码如下
 
 
//解析属性值，对注入类型进行转换
public Object resolveValueIfNecessary(Object argName, Object value) {
    //对引用类型的属性进行解析
    if (value instanceof RuntimeBeanReference) {
        RuntimeBeanReference ref = (RuntimeBeanReference) value;
        //调用引用类型属性的解析方法
        return resolveReference(argName, ref);
    }
    //对属性值是引用容器中另一个 Bean 名称的解析
    else if (value instanceof RuntimeBeanNameReference) {
        String refName = ((RuntimeBeanNameReference) value).getBeanName();
        refName = String.valueOf(evaluate(refName));
        //从容器中获取指定名称的 Bean
        if (!this.beanFactory.containsBean(refName)) {
        throw new BeanDefinitionStoreException(
        "Invalid bean name '" + refName + "' in bean reference for " + argName);
        }
        return refName;
    }
    //对 Bean 类型属性的解析，主要是 Bean 中的内部类
    else if (value instanceof BeanDefinitionHolder) {
        BeanDefinitionHolder bdHolder = (BeanDefinitionHolder) value;
        return resolveInnerBean(argName, bdHolder.getBeanName(), bdHolder.getBeanDefinition());
    }else if (value instanceof BeanDefinition) {
        BeanDefinition bd = (BeanDefinition) value;
        return resolveInnerBean(argName, "(inner bean)", bd);
    }
    //对集合数组类型的属性解析
    else if (value instanceof ManagedArray) {
        ManagedArray array = (ManagedArray) value;
        //获取数组的类型
        Class elementType = array.resolvedElementType;
        if (elementType == null) {
            //获取数组元素的类型
            String elementTypeName = array.getElementTypeName();
            if (StringUtils.hasText(elementTypeName)) {
                try {
                    //使用反射机制创建指定类型的对象
                    elementType = ClassUtils.forName(elementTypeName,
                    this.beanFactory.getBeanClassLoader());
                    array.resolvedElementType = elementType;
                }catch (Throwable ex) {
                    throw new BeanCreationException(
                    this.beanDefinition.getResourceDescription(), this.beanName,
                    "Error resolving array type for " + argName, ex);
                }
            }
            //没有获取到数组的类型，也没有获取到数组元素的类型
            //则直接设置数组的类型为 Object
            else {
             elementType = Object.class;
            }
        }
        //创建指定类型的数组
        return resolveManagedArray(argName, (List) value, elementType);
    }
    //解析 list 类型的属性值
    else if (value instanceof ManagedList) {
        return resolveManagedList(argName, (List) value);
    }
    //解析 set 类型的属性值
    else if (value instanceof ManagedSet) {
     return resolveManagedSet(argName, (Set) value);
    }
    //解析 map 类型的属性值
    else if (value instanceof ManagedMap) {
     return resolveManagedMap(argName, (Map) value);
    }
    //解析 props 类型的属性值，props 其实就是 key 和 value 均为字符串的 map
    else if (value instanceof ManagedProperties) {
        Properties original = (Properties) value;
        //创建一个拷贝，用于作为解析后的返回值
        Properties copy = new Properties();
        for (Map.Entry propEntry : original.entrySet()) {
            Object propKey = propEntry.getKey();
            Object propValue = propEntry.getValue();
            if (propKey instanceof TypedStringValue) {
                propKey = evaluate((TypedStringValue) propKey);
            }
            if (propValue instanceof TypedStringValue) {
                propValue = evaluate((TypedStringValue) propValue);
            }
            copy.put(propKey, propValue);
        }
        return copy;
    }
    //解析字符串类型的属性值
    else if (value instanceof TypedStringValue) {
        TypedStringValue typedStringValue = (TypedStringValue) value;
        Object valueObject = evaluate(typedStringValue);
        try {
            //获取属性的目标类型
            Class resolvedTargetType = resolveTargetType(typedStringValue);
            if (resolvedTargetType != null) {
            //对目标类型的属性进行解析，递归调用
            return this.typeConverter.convertIfNecessary(valueObject, resolvedTargetType);
            }
            //没有获取到属性的目标对象，则按 Object 类型返回
            else {
            return valueObject;
            }
        }catch (Throwable ex) {
            throw new BeanCreationException(
            this.beanDefinition.getResourceDescription(), this.beanName,
            "Error converting typed String value for " + argName, ex);
        }
    }else {
        return evaluate(value);
    }
}
//解析引用类型的属性值
private Object resolveReference(Object argName, RuntimeBeanReference ref) {
    try {
        //获取引用的 Bean 名称
        String refName = ref.getBeanName();
        refName = String.valueOf(evaluate(refName));
        //如果引用的对象在父类容器中，则从父类容器中获取指定的引用对象
        if (ref.isToParent()) {
            if (this.beanFactory.getParentBeanFactory() == null) {
                throw new BeanCreationException(
                this.beanDefinition.getResourceDescription(), this.beanName,
                "Can't resolve reference to bean '" + refName +
                "' in parent factory: no parent factory available");
            }
            return this.beanFactory.getParentBeanFactory().getBean(refName);
        }
        //从当前的容器中获取指定的引用 Bean 对象，如果指定的 Bean 没有被实例化
        //则会递归触发引用 Bean 的初始化和依赖注入
        else {
            Object bean = this.beanFactory.getBean(refName);
            //将当前实例化对象的依赖引用对象
            this.beanFactory.registerDependentBean(refName, this.beanName);
            return bean;
        }
    }catch (BeansException ex) {
        throw new BeanCreationException(
        this.beanDefinition.getResourceDescription(), this.beanName,
        "Cannot resolve reference to bean '" + ref.getBeanName() + "' while setting " +
        argName, ex);
   }
}
//解析 array 类型的属性
private Object resolveManagedArray(Object argName, List ml, Class elementType) {
    //创建一个指定类型的数组，用于存放和返回解析后的数组
    Object resolved = Array.newInstance(elementType, ml.size());
    for (int i = 0; i < ml.size(); i++) {
        //递归解析 array 的每一个元素，并将解析后的值设置到 resolved 数组中，索引为 i
        Array.set(resolved, i,
        resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));
        }
        return resolved;
}
//解析 list 类型的属性
private List resolveManagedList(Object argName, List ml) {
    List resolved = new ArrayList(ml.size());
    for (int i = 0; i < ml.size(); i++) {
        //递归解析 list 的每一个元素
        resolved.add(
        resolveValueIfNecessary(new KeyedArgName(argName, i), ml.get(i)));
    }
    return resolved;
}
//解析 set 类型的属性
private Set resolveManagedSet(Object argName, Set ms) {
    Set resolved = new LinkedHashSet(ms.size());
    int i = 0;
    //递归解析 set 的每一个元素
    for (Object m : ms) {
        resolved.add(resolveValueIfNecessary(new KeyedArgName(argName, i), m));
        i++;
    }
    return resolved;
}
//解析 map 类型的属性
private Map resolveManagedMap(Object argName, Map mm) {
    Map resolved = new LinkedHashMap(mm.size());
    //递归解析 map 中每一个元素的 key 和 value
    for (Map.Entry entry : mm.entrySet()) {
        Object resolvedKey = resolveValueIfNecessary(argName, entry.getKey());
        Object resolvedValue = resolveValueIfNecessary(
        new KeyedArgName(argName, entry.getKey()), entry.getValue());
        resolved.put(resolvedKey, resolvedValue);
    }
    return resolved;
}
 
 
通过上面的代码分析，我们明白了 Spring 是如何将引用类型，内部类以及集合类型等属性进行解析的， 属性值解析完成后就可以进行依赖注入了，依赖注入的过程就是 Bean 对象实例设置到它所依赖的 Bean 对象属性上去，在第 7 步中我们已经说过，依赖注入是通过 bw.setPropertyValues 方法实现的，该方 法也使用了委托模式，在 BeanWrapper 接口中至少定义了方法声明，依赖注入的具体实现交由其实现类 BeanWrapperImpl 来完成，下面我们就分析依 BeanWrapperImpl 中赖注入相关的源码。
 
 
8、BeanWrapperImpl 对 Bean 属性的依赖注入：
 
 
BeanWrapperImpl 类主要是对容器中完成初始化的 Bean 实例对象进行属性的依赖注入，即把 Bean 对象 设置到它所依赖的另一个 Bean 的属性中去，依赖注入的相关源码如下：
 
 
//实现属性依赖注入功能
private void setPropertyValue(PropertyTokenHolder tokens, PropertyValue pv) throws BeansException
{
    //PropertyTokenHolder 主要保存属性的名称、路径，以及集合的 size 等信息
    String propertyName = tokens.canonicalName;
    String actualName = tokens.actualName;
    //keys 是用来保存集合类型属性的 size
    if (tokens.keys != null) {
        //将属性信息拷贝
        PropertyTokenHolder getterTokens = new PropertyTokenHolder();
        getterTokens.canonicalName = tokens.canonicalName;
        getterTokens.actualName = tokens.actualName;
        getterTokens.keys = new String[tokens.keys.length - 1];
        System.arraycopy(tokens.keys, 0, getterTokens.keys, 0, tokens.keys.length - 1);
        Object propValue;
        try {
            //获取属性值，该方法内部使用 JDK 的内省( Introspector)机制
            //调用属性的 getter(readerMethod)方法，获取属性的值
            propValue = getPropertyValue(getterTokens);
        }
        catch (NotReadablePropertyException ex) {
            throw new NotWritablePropertyException(getRootClass(), this.nestedPath + propertyName,"Cannot access indexed value in property referenced " +
            "in indexed property path '" + propertyName + "'", ex);
        }
        //获取集合类型属性的长度
        String key = tokens.keys[tokens.keys.length - 1];
        if (propValue == null) {
            throw new NullValueInNestedPathException(getRootClass(), this.nestedPath +
            propertyName,
            "Cannot access indexed value in property referenced " +
            "in indexed property path '" + propertyName + "': returned null");
        }
        //注入 array 类型的属性值
        else if (propValue.getClass().isArray()) {
            //获取属性的描述符
            PropertyDescriptor pd =
            getCachedIntrospectionResults().getPropertyDescriptor(actualName);
            //获取数组的类型
            Class requiredType = propValue.getClass().getComponentType();
            //获取数组的长度
            int arrayIndex = Integer.parseInt(key);
            Object oldValue = null;
            try {
                //获取数组以前初始化的值
                if (isExtractOldValueForEditor()) {
                oldValue = Array.get(propValue, arrayIndex);
                }
                //将属性的值赋值给数组中的元素
                Object convertedValue = convertIfNecessary(propertyName, oldValue,                             pv.getValue(), requiredType,
                new PropertyTypeDescriptor(pd, new MethodParameter(pd.getReadMethod(),
                -1), requiredType));
                Array.set(propValue, arrayIndex, convertedValue);
            }
            catch (IndexOutOfBoundsException ex) {
                throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,"Invalid array index in property path '" + propertyName + "'", ex);
            }
    }
    //注入 list 类型的属性值
    else if (propValue instanceof List) {
        PropertyDescriptor pd =
        getCachedIntrospectionResults().getPropertyDescriptor(actualName);
        //获取 list 集合的类型
        Class requiredType = GenericCollectionTypeResolver.getCollectionReturnType(
        pd.getReadMethod(), tokens.keys.length);
        List list = (List) propValue;
        //获取 list 集合的 size
        int index = Integer.parseInt(key);
        Object oldValue = null;
        if (isExtractOldValueForEditor() && index < list.size()) {
             oldValue = list.get(index);
        }
        //获取 list 解析后的属性值
        Object convertedValue = convertIfNecessary(propertyName, oldValue, pv.getValue(),
        requiredType,
        new PropertyTypeDescriptor(pd, new MethodParameter(pd.getReadMethod(), -1),
        requiredType));
        if (index < list.size()) {
            //为 list 属性赋值
            list.set(index, convertedValue);
        }
        //如果 list 的长度大于属性值的长度，则多余的元素赋值为 null
        else if (index >= list.size()) {
            for (int i = list.size(); i < index; i++) {
                try {
                    list.add(null);
                }catch (NullPointerException ex) {
                    throw new InvalidPropertyException(getRootClass(), this.nestedPath +
                    propertyName,
                    "Cannot set element with index " + index + " in List of size " +
                    list.size() + ", accessed using property path '" + propertyName +
                    "': List does not support filling up gaps with null elements");
                    }
            }
            list.add(convertedValue);
        }
    }
    //注入 map 类型的属性值
    else if (propValue instanceof Map) {
        PropertyDescriptor pd =
        getCachedIntrospectionResults().getPropertyDescriptor(actualName);
        //获取 map 集合 key 的类型
        Class mapKeyType = GenericCollectionTypeResolver.getMapKeyReturnType(
        pd.getReadMethod(), tokens.keys.length);
        //获取 map 集合 value 的类型
        Class mapValueType = GenericCollectionTypeResolver.getMapValueReturnType(
        pd.getReadMethod(), tokens.keys.length);
        Map map = (Map) propValue;
        //解析 map 类型属性 key 值
        Object convertedMapKey = convertIfNecessary(null, null, key, mapKeyType,
        new PropertyTypeDescriptor(pd, new MethodParameter(pd.getReadMethod(), -1),
        mapKeyType));
        Object oldValue = null;
        if (isExtractOldValueForEditor()) {
            oldValue = map.get(convertedMapKey);
        }
        //解析 map 类型属性 value 值
        Object convertedMapValue = convertIfNecessary(
            propertyName, oldValue, pv.getValue(), mapValueType,
            new TypeDescriptor(new MethodParameter(pd.getReadMethod(), -1,
            tokens.keys.length + 1)));
        //将解析后的 key 和 value 值赋值给 map 集合属性
        map.put(convertedMapKey, convertedMapValue);
        }else {
            throw new InvalidPropertyException(getRootClass(), this.nestedPath + propertyName,
                "Property referenced in indexed property path '" + propertyName +
                "' is neither an array nor a List nor a Map; returned value was [" +                        pv.getValue() + "]");
        }
    }
    //对非集合类型的属性注入
    else {
        PropertyDescriptor pd = pv.resolvedDescriptor;
        if (pd == null || !pd.getWriteMethod().getDeclaringClass().isInstance(this.object)) {
            pd = getCachedIntrospectionResults().getPropertyDescriptor(actualName);
            //无法获取到属性名或者属性没有提供 setter(写方法)方法
            if (pd == null || pd.getWriteMethod() == null) {
                //如果属性值是可选的，即不是必须的，则忽略该属性值
                if (pv.isOptional()) {
                    logger.debug("Ignoring optional value for property '" + actualName +
                    "' - property not found on bean class [" + getRootClass().getName() +
                    "]");
                    return;
                }
                //如果属性值是必须的，则抛出无法给属性赋值，因为没提供 setter 方法异常
                else {
                    PropertyMatches matches = PropertyMatches.forProperty(propertyName,
                    getRootClass());
                    throw new NotWritablePropertyException(
                    getRootClass(), this.nestedPath + propertyName,
                    matches.buildErrorMessage(), matches.getPossibleMatches());
                 }
            }
            pv.getOriginalPropertyValue().resolvedDescriptor = pd;
        }
        Object oldValue = null;
        try {
            Object originalValue = pv.getValue();
            Object valueToApply = originalValue;
            if (!Boolean.FALSE.equals(pv.conversionNecessary)) {
                if (pv.isConverted()) {
                     valueToApply = pv.getConvertedValue();
                }
                else {
                    if (isExtractOldValueForEditor() && pd.getReadMethod() != null) {
                        //获取属性的 getter 方法(读方法)，JDK 内省机制
                        final Method readMethod = pd.getReadMethod();
                        //如果属性的 getter 方法不是 public 访问控制权限的，即访问控制权限比较严格，
                        //则使用 JDK 的反射机制强行访问非 public 的方法(暴力读取属性值)
                        if (!Modifier.isPublic(readMethod.getDeclaringClass().getModifiers()) &&
                        !readMethod.isAccessible()) {
                            if (System.getSecurityManager()!= null) {
                                //匿名内部类，根据权限修改属性的读取控制限制
                                AccessController.doPrivileged(new PrivilegedAction() {
                                    public Object run() {
                                    readMethod.setAccessible(true);
                                    return null;
                                    }
                                });
                            }
                            else {
                                readMethod.setAccessible(true);
                            }
                        }
                        try {
                            //属性没有提供 getter 方法时，调用潜在的读取属性值的方法，获取属性值
                            if (System.getSecurityManager() != null) {
                                oldValue = AccessController.doPrivileged(new
                                PrivilegedExceptionAction() {
                                    public Object run() throws Exception {
                                     return readMethod.invoke(object);
                                    }
                                }, acc);
                            }else {
                                oldValue = readMethod.invoke(object);
                            }
                        }
                        catch (Exception ex) {
                            if (ex instanceof PrivilegedActionException) {
                                ex = ((PrivilegedActionException) ex).getException();
                            }
                            if (logger.isDebugEnabled()) {
                                logger.debug("Could not read previous value of property '" +
                                this.nestedPath + propertyName + "'", ex);
                            }
                        }
                    }
                    //设置属性的注入值
                    valueToApply = convertForProperty(propertyName, oldValue, originalValue, pd);
                }
                pv.getOriginalPropertyValue().conversionNecessary = (valueToApply !=
            originalValue);
            }
            //根据 JDK 的内省机制，获取属性的 setter(写方法)方法
            final Method writeMethod = (pd instanceof GenericTypeAwarePropertyDescriptor ?
                ((GenericTypeAwarePropertyDescriptor) pd).getWriteMethodForActualAccess() :
                pd.getWriteMethod());
            //如果属性的 setter 方法是非 public，即访问控制权限比较严格，则使用 JDK 的反射机制，
            //强行设置 setter 方法可访问(暴力为属性赋值)
            if (!Modifier.isPublic(writeMethod.getDeclaringClass().getModifiers())
            && !writeMethod.isAccessible()) {
                //如果使用了 JDK 的安全机制，则需要权限验证
                if (System.getSecurityManager()!= null) {
                    AccessController.doPrivileged(new PrivilegedAction() {
                        public Object run() {
                            writeMethod.setAccessible(true);
                            return null;
                        }
                    });
                }else {
                     writeMethod.setAccessible(true);
                }
            }
            final Object value = valueToApply;
            if (System.getSecurityManager() != null) {
                try {
                //将属性值设置到属性上去
                AccessController.doPrivileged(new PrivilegedExceptionAction() {
                        public Object run() throws Exception {
                            writeMethod.invoke(object, value);
                            return null;
                        }
                    }, acc);
                }catch (PrivilegedActionException ex) {
                     throw ex.getException();
                }
            }else {
                writeMethod.invoke(this.object, value);
            }
        }catch (TypeMismatchException ex) {
            throw ex;
        }catch (InvocationTargetException ex) {
            PropertyChangeEvent propertyChangeEvent =
            new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName,
            oldValue, pv.getValue());
            if (ex.getTargetException() instanceof ClassCastException) {
                throw new TypeMismatchException(propertyChangeEvent, pd.getPropertyType(),
                    ex.getTargetException());
            }else {
                throw new MethodInvocationException(propertyChangeEvent,
                    ex.getTargetException());
            }
        }catch (Exception ex) {
            PropertyChangeEvent pce =
                new PropertyChangeEvent(this.rootObject, this.nestedPath + propertyName,
                oldValue, pv.getValue());
            throw new MethodInvocationException(pce, ex);
        }
    }
}
 
 
通过对上面注入依赖代码的分析，我们已经明白了 Spring IOC 容器是如何将属性的值注入到 Bean 实 例对象中去的：
 
 
 
  
(1).对于集合类型的属性，将其属性值解析为目标类型的集合后直接赋值给属性。
 (2).对于非集合类型的属性，大量使用了 JDK 的反射和内省机制，通过属性的 getter 方法 (reader method)获取指定属性注入以前的值，同时调用属性的 setter 方法(writer method)为属性 设置注入后的值。看到这里相信很多人都明白了 Spring 的 setter 注入原理。
 
 
 
 
至此 Spring IOC 容器对 Bean 定义资源文件的定位，载入、解析和依赖注入已经全部分析完毕，现在 Spring IOC 容器中管理了一系列靠依赖关系联系起来的 Bean，程序不需要应用自己手动创建所需的对 象，Spring IOC 容器会在我们使用的时候自动为我们创建，并且为我们注入好相关的依赖，这就是 Spring 核心功能的控制反转和依赖注入的相关功能。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(2018-05-05)

        

            

                
    
                    
  • 2018-05-05
                        听风小姐姐

                        
    好久没写文了，不知道忙点啥，天天是忙忙碌碌的，一天恨不得有48个小时来过，今天去寻访蜗牛了，孩子的科学作业。图片发自App在公园的树上，找到了蜗牛，捉了几只，带回家饲养。以前从来没有养过小动物，看来还得问问度娘怎么养蜗牛，陪孩子一起养吧，在这个世界上什么都有第一次，孩子的第一次也是我的第一次，一起探索吧
    
                    
    • 
                    
  • 2018-05-05
                        常庚_c041

                        
    姓名：林常庚（365期，乐观3组）单位：深圳市蔚蓝时代商业管理有限公司海南分公司。【日精进打卡第34天】【知～学习】《六项精进》2遍共91遍《大学》3遍共100遍【经典名句分享】付出不亚于任何人的努力【行～实践】一、修身：（对自己个人）二、齐家：（对家庭和家人）三、建功：（对工作）1，月度总结计划会。2.5月重点工作安排积善：发愿从2018年4月1日起日行一善事。今日1善，累计36善。【觉悟】偷懒
    
                    
    • 
                    
  • 2018-05-05
                        J0hn先生

                        
    201组别301期利他一组【日精进打卡第202天【知~学习】诵读《六项精进大纲》3遍，累计268遍；诵读《大学》3遍，累计268遍【经典名句分享比别人多思考一点，就能前进一步。比别人多做一点，就能更踏实。~实践一、修身：少做点无畏的事，多做点有意义的事。二、齐家：1.下班看到孩子咳嗽厉害，送孩子再去医院检查一下。三、建功：1.完成了国标会议的相关信息统计并汇报。2.组织调整了一个上限颜色的合格量产
    
                    
    • 
                    
  • 2018-05-05
                        又昂

                        
    （稻盛哲学学习会）打卡第68天姓名：王建凤部门：杭州安简组别：努力三组【知～学习】第五章：宇宙的意志促进森罗万象生生不息”【内容感悟分享】感谢、勤奋工作、率直之心、天天反省、不憎恨、不嫉忌，先后利人精神，这些善念和善行都是顺从宇宙意志的行为。这是决定人生和事业的成败！【行～实践】一、修身：坚持每天阅读六项精进和大学五遍。坚持看书，每天都要关心一下孩子和父母！坚持每天半小时做筋络操、相互监督！坚持要
    
                    
    • 
                    
  • 2018-05-05
                        syw桃子

                        
    那是周六的早上，路边草叶上挂满了水珠，在阳光下晶莹闪闪，我就近观察：那一颗晶莹闪闪的水珠，就像我妈妈脖子上带的珍珠项链，光华流动，像是在在草叶上跳舞，熠熠生辉。风吹过来，催促水珠快点落下滋润土地，可有的水珠偏偏很调皮，它不但不顺着片落下，还往草心里钻，而且，小草好像也特别欢迎小水珠，在风中稳住身子，抱紧水珠不给水珠跑掉。一只小蚂蚁顺着草杆向上爬，一直爬到小草的卷心处，在水珠边上停了好一会，我估计小
    
                    
    • 
                    
  • 2018-05-05学习小结 - 关于类的专题研究9
                        砾桫_Yvan

                        
    学习小结14.9点拨匿名类注意事项：a.使用匿名内部类，必须且只能继承一个类或实现一个接口；b.匿名内部类中不能定义构造函数；c.匿名内部类中不能存在任何静态成员变量和静态方法；d.匿名内部类为局部内部类；e.匿名内部类不能是抽象的，且必须实现继承类或者实现接口的所有抽象方法。static特点：a.一个是static属性或方法可以由类名称直接调用；b.另一个是static属性是一个共享属性。fin
    
                    
    • 
                    
  • 2018-05-05
                        商莹

                        
    关于瑜伽·理疗瑜伽来自于古老的印度，是一门生命科学，是古印度六大哲学派系之一，帕坦伽利的《瑜伽经》把瑜伽定义为：瑜伽是控制头脑的波动。瑜伽是通过身体的练习去提升自我的认知，从而更客观的去看待这个世界。图片发自App很多人都认为瑜伽是一种体育锻炼，但瑜伽并不是体育锻炼，瑜伽是在调整Prana能量，了解到一点是极其重要的，因为现在大多数人是把瑜伽当成体操来练习，每次看到一些人那么努力的去练习，感觉很干
    
                    
    • 
                    
  • 2018-05-05
                        ty活出真善美

                        
    2018年5月5号咖啡冥想ty活出真善美目标：2018年5月到2018年7月31号累计收入10万元！动机：原全天下所有女人都能获得美丽自信，家庭和谐，财务独立，健康休息，成就荣耀，人际关系，心灵和谐，学习成长，这八个方面都平衡发展！行动：1、早上起来就非常愉悦的给爸爸妈妈各自10块钱，非常感谢爸爸妈妈非常喜悦的接受，让我种下财富的种子！回向我的目标非常顺利轻松的达成，每天给父母更多的孝顺金，回向天
    
                    
    • 
                    
  • 2018-05-05
                        疼痛有爱

                        
    三叉神经痛止疼治疗的给药方式:口服、静脉给药、皮下给药、直肠给药、透皮给药等。滴耳给药、耳后窝沟涂药都是通过皮肤、微血管吸收的方式，近距离靶向给药，药物有效成分直接作用到三叉神经根，以及三叉神经的病变部位，药少力专、起效迅速、功效宏大，从而达到止疼快、恢复更彻底的无痛健康新状态！
    
                    
    • 
                    
  • 2018-05-05 新编《心太软》——黄爱华
                        赵雪奎

                        
    新编《心太软》——黄爱华你总是心太软，心太软。独自一个人讲课到铃响，你任劳任怨的分析着课文，可知道学生心里真勉强。你总是心太软，心太软，把所有问题都自己讲，教学总是简单，交流太难，不是你的，就不要多讲，铃响了，你还不想停，你还要讲几分钟吗？你这样讲解到底累不累？明知道学生心理在怨你，只不过想好好讲透课文，可惜学生无法给你满分，多余的牺牲，你不觉心痛，你应该不会只想做个“讲师”。奥！算了吧！就这样算
    
                    
    • 
                    
  • 股海周志——2018-05-05
                        禅中悟缠

                        
    节后三天的走势没有什么好大的变化，基本是按照节前所写的剧本在走。3110点还是没有被升破。上证指数自3568点下来，到3041点，5分钟走势图上完全可以看出，是一个30分钟级别的走势。看图：上证指数5分钟走势图：爱奇艺20180504sz5ft.png前面的短文中，多次讲到，短线操作，关键就是看这个30分钟级别走势是盘整类型还是趋势类型。目前仅仅就3041点后面的震荡走势，还不能判断出明确是否。下
    
                    
    • 
                    
  • 2018-05-05
                        南言

                        
    图片发自App今天录音结束了，三首。算是顺利。虽然有陪跑几十多遍的，但锅不在钢琴，所以血压没有升高，心率也不算太快。安然无事地度过了。我到现在都记得刚入行（？）时候老板讲的话：不要怕出错，不要想着有多少人看着你。这句话像警世恒言一样在我迷惑和自卑的时候闪闪发光，照亮我犹豫不决的前路。老板说，只有在平时练习的时候尽力做到一万分的熟悉，上台才不会出错。因为当你来到舞台，再多的心理建设都没有用，你唯一能
    
                    
    • 
                    
  • 最幸福的选择
                        清远_a429

                        
    最幸福的选择——林海峰作品2018-05-05林海峰作品幸福岛在阳光森林，健康，如同森林里的竹林一样，雨后春笋，自然生长，毫不费力，也无需人力！所以，只要愿意走入阳光森林，愿意好好进入课堂学习，实践，不急，给身体时间！不乱，允许身体修复需要的反应！给予均衡的营养、安宁的心境，释放不必要的压力，任何人都可以持续健康，远离疾病！那么剩下的人生题目，只有财富和生活品质，两个部分需要达成。赚钱，其实并不是
    
                    
    • 
                    
  • 2018-05-05
                        宁_79e3

                        
    六项精进打卡第13天姓名:沈一宁公司：扬州日发干燥设备工程有限公司【日精打卡第12天】【知~学习】《六项精进》1遍，《大学》1遍【经典名句分享】拼搏在当下这一刻【行~实践】一、修身（对自己个人）1、看书（活法）2、学专业知识3、散步二、齐家（对家人）1、无三、建功1、产品研发【积善】发原从2018年4月22日起一年365天日行1善，累计13善【省~觉悟】不要有感性的烦恼【感谢】感谢父母感谢同事【志
    
                    
    • 
                    
  • 2018-05-05
                        二白啊

                        
    我似乎忆起我第一次双手满捧着这些茉莉花，这些白的茉莉花的时候。我喜欢那日光，那天空，那绿色的大地;我听见那河水淙净的流声，在黑漆的中夜里传过来;我看见那秋天的夕阳，在荒野的路角，映照在我的身上，如新妇揭起她的面网迎接她的爱人。但我想起孩提时第一次捧在手里的白茉莉，心里还感着甜蜜的回忆。
    
                    
    • 
                    
  • 2018-05-05
                        沈竹

                        
    东篱把酒，两盏三杯，谁与共举杯遥望，落定尘埃，遥相送祝把酒东风，山河从容祝酩酊人间，从此不倥偬
    
                    
    • 
                    
  • 2018-05-05
                        毛粘粘的小可爱

                        
    我愿意化浮萍躺湖心只陪你泛岁月的涟漪我愿意化流沙躺湖堤只陪你恭候春夏的轮替――许嵩《山水之间》
    
                    
    • 
                    
  • 2018-05-05 胡老师北京分享会直播学习要点
                        陈艳芳_育儿及修行成长

                        
    1）去今日学堂如果仅想提升运动、提高英语能力，那么你的收获是有限的，敞开心，才会有更大的礼物，要看自己有没有能力接到；2）对于学堂的态度：希望到了学堂孩子一切都好，把责任都交给学堂，有时候没有进步，反而暴露一堆问题，我的问题：不想承担责任，抗力让自己痛苦；3）对学堂孩子鉴赏之心，而不是学习之心；送去学堂要想明白是否自己和孩子愿意成为老师那个样子的人；学习之心：真正的去成长，而不是假装破掉自己的观念
    
                    
    • 
                    
  • 2018-05-05
                        艾华艾悦妈妈

                        
    2018年5月5日星期六阴小雨亲子日记(160)今天没睡懒觉早上七点多出的门，带孩子吃的早餐，吃完去上围棋课。中午在姐妹花店吃的饭。天气断断续续的在下雨，下午继续在花店和姐妹聊天。小宝六点有围棋课，在姐妹花店吃了点东西，直接去上课了。晚饭我没吃，午饭吃的太饱了，在姐妹那吃饭每次都让我吃撑。生怕我吃不饱。我们娘三到了晚上八点多才进的家们，今天把我冻死了，冷早上出门有出太阳没看天气预报穿少了，还下雨了
    
                    
    • 
                    
  • 2018-05-05
                        海内存知己_bd9e

                        
    今天我和妈妈一起去，好像多玩看见天上快要下雨了，妈妈对我说，我们是回去还是好句好又多，我说还是去好伦哥吧，你妈妈就带我去了好多，我们再好好看看一个多小时后回家的时候，突然下大雨，我妈赶紧骑车带我回家，快到家了，妈妈在一个小商铺上，我帮他称转车，他就去买了守住妈妈座位挡住雨水，我已经把座位都弄干了，妈妈说要不是你把水都干弄干了，妈妈就得作诗的作业了，听到妈妈表扬我，我对妈妈说的英语是我应该的，妈妈说
    
                    
    • 
                    
  • 2018-05-05
                        失恋了的她

                        
    图片发自App第一次见面，我就对他一见钟情，这份心思藏在我的心里，或许表现得太明显，有一段时间他一在躲我。
    
                    
    • 
                    
  • 2018-05-05
                        TA76广新

                        
    今天和远在南宁的妹妹讨论孩子教育。关于学校霸凌。还是多从孩子身上找出一些没有教育到的地方。成年人的理解是：有人的地方就有江湖。我们教育孩子总是以善为出发点。当孩子所处的一个环境，不都是尽善尽美的。那么孩子学会要怎么做呢？应该是培养孩子怎样融入一个环境，适应一个环境。怎么学会让别的孩子接纳他，喜欢他。这是一个孩子情商的教育。另外培养孩子自信与勇敢也很重要。学校是个小环境，社会是个大环境。无论哪个环境
    
                    
    • 
                    
  • 2018-05-05
                        Eva不偷懒还不行吗

                        
    依然是读书笔记……假如我们把别人看中的价值观简单地拿过来单做自己的，那么，本来以我们的利益为中心的冲突就不会发生了。已婚男人如果爱上了另一个女人，他实际上就陷入了冲突之中。在他物理确定自己对婚姻的信念时，他便干脆选择阻力最小的路径，不去面对冲突。即使我们认识到了这样的冲突，我们必须愿意而且能够摈弃矛盾两方面中的一面。但极少有人能做到断然取舍，因为我们的感情和信念时混淆不清的。也许，说到底还是因为我
    
                    
    • 
                    
  • 2018-05-05 - 草稿
                        一二三四五文

                        
    培训感悟韩雪梅从四月份开始，一直到五月中旬，我们几个乡镇(大寨、留固、八里营、赵营、枣村乡)在留固一中进行了为期一个月的语文培训。从作文和散文的教学，微课及面试技巧方面，小说的教学等等方面进行学习，其间有困惑，有烦躁，但在结束回味的时候，更多的还是满满的收获，其中印象较深的是吴银霞老师的“教师面试小技巧"和王慧慧老师的散文教学。身处教师这个职业，面试讲课必不可少，怎样才能取得较好的成绩呢？吴老师从
    
                    
    • 
                    
  • 2018-05-05
                        乐乐仔仔妈妈

                        
    2018年5月5日星期六小雨亲子日记第109天孩子们期中考试已告一段落，昨天晚上两个孩子都要求放松一下不写作业了！女儿要听音乐，儿子想看动画片，最后姐弟俩商量好姐姐先听音乐半小时，接着弟弟看动画片，我也放松一下洗个澡，敷个面膜！嘴上说放松了，可心里给猫抓的似的，担心女儿成绩下滑，因为考完语文回来就说作文写的不好，考完英语说英语真难，可能没考好。当时就安慰孩子了，及时调整状态，不要被一场发挥失常而影
    
                    
    • 
                    
  • 2018-05-05
                        文森林木

                        
    你已经三十五岁了，而她只有二十二岁，你没有钱，你觉得你能驾驭她吗？他骨子里有些自卑对自己的感情缺乏自信。实际上在他心里答案是否定的。他看见别的男人和她一起的时候心生嫉妒，但他却畏惧不前，不敢勇于去追求，只是心有不甘，徒增烦恼而已。但在他心里他还是有一种隐隐约约的预感，觉得他和她是不会有什么结果的。不知这是不是他潜意识给自己的无能寻找的借口，好让自己好受点。
    
                    
    • 
                    
  • 2018-05-05
                        chenj_1511

                        
    练琴又逢星期六，去Y老师家练琴，这一周是小休，练得时间不多，视唱也唱不准，被“批评”看样子在所难免。Y坐在钢琴边，手指有力地在钢琴上飞舞，黑发里掺杂着几缕白色若隐若现，时不时抬头严厉地瞥我们一眼，有时落在我们身上。这周自己练得少，生怕老师停下来让我现场来上一段。心惊胆颤的，都不敢看老师一眼。Y下课对我们可好了。
    
                    
    • 
                    
  • 2018-05-05
                        顾倍嘉分水碶

                        
    （稻盛哲学学习会）打卡第56天姓名：顾倍嘉部门：分水碶组别:利他一组【知～学习】诵读《活着》第五章不必担心结果，因为因果必报【内容感悟】聪明人能看见暗藏因果，愚蠢之人只能看见表象。行善发自内心，行善当时的心情就是快乐的，就已经得到。后续的报答就让它顺其自然的发生不必过多期盼，做好自己即可。【行~实践】一、修身：背诵六项及大学五遍诵读心经三遍学习买手实务二、齐家：1打电话给爸妈2整理房间洗衣服三、建
    
                    
    • 
                    
  • 2018-05-05
                        comechen

                        
    比特币昨日强势上涨，连续突破9400,9600美元两大关口，并且超越之前反弹高点9750美元，触碰MA200日线均线回落，目前在9600美元附近盘整，以太坊突破下降通道线后，屡创新高，达到770美元的价位，比特现金三次突破箱体上沿失败后，下行压力剧增，EOS短期内仍处在调整周期，下跌风险较大，其他主流数字货币还处于震荡整理期，比特币强势上涨，多数山寨币上涨乏力，或者开始进入下跌调整周期，山寨币被比
    
                    
    • 
                    
  • 2018-05-05
                        天黑黑_e3af

                        
    姓名：王丽～南京天谜时装有限公司组别:第377期六项精进努力二组组员【日精进打卡第11天】【知－学习】诵读《大学》开篇3遍共18遍诵读《六项精进》大纲3遍共18遍【经典名句分享】读书是成功的唯一途径【行－实践】一、修身：减重10斤二、齐家，跟孩子老公视频聊天三、建功：店长沟通｛积善｝：今日1善，累计3善。【省－觉悟】1、不是所有人都能够站在你的高度思考问题，所以当问题发生后，先把自己的姿态摆正，不
    
                    
    • 
                                
  • Java开发中，spring mvc 的线程怎么调用？
                                    小麦麦子
springmvc
                                    
    今天逛知乎，看到最近很多人都在问spring mvc 的线程http://www.maiziedu.com/course/java/ 的启动问题，觉得挺有意思的，那哥们儿问的也听仔细，下面的回答也很详尽，分享出来，希望遇对遇到类似问题的Java开发程序猿有所帮助。 
 
问题： 
    在用spring mvc架构的网站上，设一线程在虚拟机启动时运行，线程里有一全局
    
                                
    • 
                                
  • maven依赖范围
                                    bitcarter
maven
                                    
    1.test 测试的时候才会依赖，编译和打包不依赖，如junit不被打包 
 
2.compile 只有编译和打包时才会依赖 
 
3.provided 编译和测试的时候依赖，打包不依赖，如：tomcat的一些公用jar包 
 
4.runtime 运行时依赖，编译不依赖 
 
5.默认compile 
 
依赖范围compile是支持传递的，test不支持传递 
 
1.传递的意思是项目A，引用
    
                                
    • 
                                
  • Jaxb org.xml.sax.saxparseexception : premature end of file
                                    darrenzhu
xmlprematureJAXB
                                    
    如果在使用JAXB把xml文件unmarshal成vo(XSD自动生成的vo)时碰到如下错误： 
org.xml.sax.saxparseexception : premature end of file 
很有可能时你直接读取文件为inputstream，然后将inputstream作为构建unmarshal需要的source参数。InputSource inputSource = new In
    
                                
    • 
                                
  • CSS Specificity
                                    周凡杨
html权重Specificitycss
                                    
      
有时候对于页面元素设置了样式，可为什么页面的显示没有匹配上呢？ because specificity   
CSS 的选择符是有权重的，当不同的选择符的样式设置有冲突时，浏览器会采用权重高的选择符设置的样式。   
    规则： 
  
  HTML标签的权重是1

  Class 的权重是10

  Id 的权重是100


    
                                
    • 
                                
  • java与servlet
                                    g21121
servlet
                                    
    servlet 搞java web开发的人一定不会陌生，而且大家还会时常用到它。 
下面是java官方网站上对servlet的介绍：  java官网对于servlet的解释 写道   
Java Servlet Technology Overview Servlets are the Java platform technology of choice for extending and enha
    
                                
    • 
                                
  • eclipse中安装maven插件
                                    510888780
eclipsemaven
                                    
    1.首先去官网下载 Maven： 
http://www.apache.org/dyn/closer.cgi/maven/binaries/apache-maven-3.2.3-bin.tar.gz 
下载完成之后将其解压， 
我将解压后的文件夹：apache-maven-3.2.3， 
并将它放在 D:\tools目录下， 
即 maven 最终的路径是：D:\tools\apache-mave
    
                                
    • 
                                
  • jpa@OneToOne关联关系
                                    布衣凌宇
jpa
                                    
    Nruser里的pruserid关联到Pruser的主键id，实现对一个表的增删改，另一个表的数据随之增删改。 
Nruser实体类 
//***************************************************************** 
@Entity 
@Table(name="nruser") 
@DynamicInsert @Dynam
    
                                
    • 
                                
  • 我的spring学习笔记11-Spring中关于声明式事务的配置
                                    aijuans
spring事务配置
                                    
    这两天学到事务管理这一块，结合到之前的terasoluna框架，觉得书本上讲的还是简单阿。我就把我从书本上学到的再结合实际的项目以及网上看到的一些内容，对声明式事务管理做个整理吧。我看得Spring in Action第二版中只提到了用TransactionProxyFactoryBean和<tx:advice/>,定义注释驱动这三种，我承认后两种的内容很好，很强大。但是实际的项目当中
    
                                
    • 
                                
  • java 动态代理简单实现
                                    antlove
javahandlerproxydynamicservice
                                    
    dynamicproxy.service.HelloService 
package dynamicproxy.service;

public interface HelloService {
	public void sayHello();
}
 
  
dynamicproxy.service.impl.HelloServiceImpl 
package dynamicp
    
                                
    • 
                                
  • JDBC连接数据库
                                    百合不是茶
JDBC编程JAVA操作oracle数据库
                                    
          
    如果我们要想连接oracle公司的数据库，就要首先下载oralce公司的驱动程序，将这个驱动程序的jar包导入到我们工程中; 
  
JDBC链接数据库的代码和固定写法; 
  
  
1,加载oracle数据库的驱动; 
    &nb
    
                                
    • 
                                
  • 单例模式中的多线程分析
                                    bijian1013
javathread多线程java多线程
                                    
    谈到单例模式，我们立马会想到饿汉式和懒汉式加载，所谓饿汉式就是在创建类时就创建好了实例，懒汉式在获取实例时才去创建实例，即延迟加载。 
饿汉式： 
package com.bijian.study;

public class Singleton {

	private Singleton() {
	}

	// 注意这是private 只供内部调用
	private static
    
                                
    • 
                                
  • javascript读取和修改原型特别需要注意原型的读写不具有对等性
                                    bijian1013
JavaScriptprototype
                                    
            对于从原型对象继承而来的成员，其读和写具有内在的不对等性。比如有一个对象A，假设它的原型对象是B，B的原型对象是null。如果我们需要读取A对象的name属性值，那么JS会优先在A中查找，如果找到了name属性那么就返回；如果A中没有name属性，那么就到原型B中查找name，如果找到了就返回；如果原型B中也没有
    
                                
    • 
                                
  • 【持久化框架MyBatis3六】MyBatis3集成第三方DataSource
                                    bit1129
dataSource
                                    
    MyBatis内置了数据源的支持，如： 
  
	<environments default="development">
		<environment id="development">
			<transactionManager type="JDBC" />
			<data
    
                                
    • 
                                
  • 我程序中用到的urldecode和base64decode,MD5
                                    bitcarter
cMD5base64decodeurldecode
                                    
    这里是base64decode和urldecode，Md5在附件中。因为我是在后台所以需要解码： 
 

string Base64Decode(const char* Data,int DataByte,int& OutByte)
{
    //解码表
    const char DecodeTable[] =
    {
        0, 0, 0, 0, 0, 0
    
                                
    • 
                                
  • 腾讯资深运维专家周小军：QQ与微信架构的惊天秘密
                                    ronin47

                                    
    社交领域一直是互联网创业的大热门，从PC到移动端，从OICQ、MSN到QQ。到了移动互联网时代，社交领域应用开始彻底爆发，直奔黄金期。腾讯在过去几年里，社交平台更是火到爆，QQ和微信坐拥几亿的粉丝，QQ空间和朋友圈各种刷屏，写心得，晒照片，秀视频，那么谁来为企鹅保驾护航呢？支撑QQ和微信海量数据背后的架构又有哪些惊天内幕呢？本期大讲堂的内容来自今年2月份ChinaUnix对腾讯社交网络运营服务中心
    
                                
    • 
                                
  • java-69-旋转数组的最小元素。把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素
                                    bylijinnan
java
                                    
    

public class MinOfShiftedArray {

	/**
	 * Q69 旋转数组的最小元素
	 * 把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个排好序的数组的一个旋转，输出旋转数组的最小元素。
	 * 例如数组{3, 4, 5, 1, 2}为{1, 2, 3, 4, 5}的一个旋转，该数组的最小值为1。
	 */
	publ
    
                                
    • 
                                
  • 看博客，应该是有方向的
                                    Cb123456
反省看博客
                                    
    看博客，应该是有方向的: 
 我现在就复习以前的，在补补以前不会的，现在还不会的，同时完善完善项目，也看看别人的博客. 
 我刚突然想到的: 
 1.应该看计算机组成原理，数据结构，一些算法，还有关于android,java的。 
 2.对于我，也快大四了，看一些职业规划的，以及一些学习的经验，看看别人的工作总结的. 
  
 为什么要写
    
                                
    • 
                                
  • [开源与商业]做开源项目的人生活上一定要朴素,尽量减少对官方和商业体系的依赖
                                    comsci
开源项目
                                    
     
 
     为什么这样说呢？  因为科学和技术的发展有时候需要一个平缓和长期的积累过程，但是行政和商业体系本身充满各种不稳定性和不确定性，如果你希望长期从事某个科研项目，但是却又必须依赖于某种行政和商业体系，那其中的过程必定充满各种风险。。。 
 
      所以，为避免这种不确定性风险，我
    
                                
    • 
                                
  • 一个 sql优化 （[精华] 一个查询优化的分析调整全过程！很值得一看 ）
                                    cwqcwqmax9
sql
                                    
    见   http://www.itpub.net/forum.php?mod=viewthread&tid=239011 
 
 
 
 
Web翻页优化实例 
 提交时间: 2004-6-18 15:37:49      回复    发消息  
 
 
环境： 
Linux ve
    
                                
    • 
                                
  • Hibernat and Ibatis
                                    dashuaifu
Hibernateibatis
                                    
    Hibernate  VS  iBATIS 简介 Hibernate 是当前最流行的O/R mapping框架，当前版本是3.05。它出身于sf.net，现在已经成为Jboss的一部分了 iBATIS 是另外一种优秀的O/R mapping框架，当前版本是2.0。目前属于apache的一个子项目了。 相对Hibernate“O/R”而言，iBATIS 是一种“Sql Mappi
    
                                
    • 
                                
  • 备份MYSQL脚本
                                    dcj3sjt126com
mysql
                                    
    #!/bin/sh
# this shell to backup mysql
#[email protected] (QQ:1413161683 DuChengJiu)

_dbDir=/var/lib/mysql/
_today=`date +%w`
_bakDir=/usr/backup/$_today
[ ! -d $_bakDir ] && mkdir -p 
    
                                
    • 
                                
  • iOS第三方开源库的吐槽和备忘
                                    dcj3sjt126com
ios
                                    
    转自 
ibireme的博客       做iOS开发总会接触到一些第三方库，这里整理一下，做一些吐槽。       目前比较活跃的社区仍旧是Github，除此以外也有一些不错的库散落在Google Code、SourceForge等地方。由于Github社区太过主流，这里主要介绍一下Github里面流行的iOS库。       首先整理了一份 
Github上排名靠
    
                                
    • 
                                
  • html wlwmanifest.xml
                                    eoems
htmlxml
                                    
    所谓优化wp_head()就是把从wp_head中移除不需要元素，同时也可以加快速度。 
 
步骤： 
 
加入到function.php 
 
remove_action('wp_head', 'wp_generator'); 
//wp-generator移除wordpress的版本号，本身blog的版本号没什么意义，但是如果让恶意玩家看到，可能会用官网公布的漏洞攻击blog 
 
remov
    
                                
    • 
                                
  • 浅谈Java定时器发展
                                    hacksin
java并发timer定时器
                                    
    java在jdk1.3中推出了定时器类Timer,而后在jdk1.5后由Dou Lea从新开发出了支持多线程的ScheduleThreadPoolExecutor，从后者的表现来看，可以考虑完全替代Timer了。 
Timer与ScheduleThreadPoolExecutor对比： 
1. 
  
 Timer始于jdk1.3,其原理是利用一个TimerTask数组当作队列
    
                                
    • 
                                
  • 移动端页面侧边导航滑入效果
                                    ini
jqueryWebhtml5cssjavascirpt
                                    
    效果体验：http://hovertree.com/texiao/mobile/2.htm可以使用移动设备浏览器查看效果。效果使用到jquery-2.1.4.min.js，该版本的jQuery库是用于支持HTML5的浏览器上，不再兼容IE8以前的浏览器，现在移动端浏览器一般都支持HTML5，所以使用该jQuery没问题。HTML文件代码： 
<!DOCTYPE html>
<h
    
                                
    • 
                                
  • AspectJ+Javasist记录日志
                                    kane_xie
aspectjjavasist
                                    
    在项目中碰到这样一个需求，对一个服务类的每一个方法，在方法开始和结束的时候分别记录一条日志，内容包括方法名，参数名+参数值以及方法执行的时间。 
  
@Override
public String get(String key) {
//	long start = System.currentTimeMillis();
//	System.out.println("Be
    
                                
    • 
                                
  • redis学习笔记
                                    MJC410621
redisNoSQL
                                    
    1)nosql数据库主要由以下特点：非关系型的、分布式的、开源的、水平可扩展的。 
1，处理超大量的数据 
2，运行在便宜的PC服务器集群上， 
3，击碎了性能瓶颈。 
1)对数据高并发读写。 
2)对海量数据的高效率存储和访问。 
3)对数据的高扩展性和高可用性。 
 
redis支持的类型： 
 
Sring 类型 
set name lijie 
get name lijie 
set na
    
                                
    • 
                                
  • 使用redis实现分布式锁
                                    qifeifei

                                    
    在多节点的系统中，如何实现分布式锁机制，其中用redis来实现是很好的方法之一，我们先来看一下jedis包中，有个类名BinaryJedis,它有个方法如下： 
  
public Long setnx(final byte[] key, final byte[] value) {
	checkIsInMulti();
	client.setnx(key, value);
	ret
    
                                
    • 
                                
  • BI并非万能，中层业务管理报表要另辟蹊径
                                    张老师的菜
大数据BI商业智能信息化
                                    
           BI是商业智能的缩写，是可以帮助企业做出明智的业务经营决策的工具，其数据来源于各个业务系统，如ERP、CRM、SCM、进销存、HER、OA等。 
       BI系统不同于传统的管理信息系统，他号称是一个整体应用的解决方案，是融入管理思想的强大系统：有着系统整体的设计思想，支持对所有
    
                                
    • 
                                
  • 安装rvm后出现rvm not a function 或者ruby -v后提示没安装ruby的问题
                                    wudixiaotie
function
                                    
    1.在~/.bashrc最后加入 
[[ -s "$HOME/.rvm/scripts/rvm" ]] && source "$HOME/.rvm/scripts/rvm" 
 2.重新启动terminal输入： 
  
rvm use ruby-2.2.1 --default 
 把当前安装的ruby版本设为默
    
                                
    •