毛子果
毛子果

2018-05-12

spring源码分析（四）

目录

五、spring源码分析
--5.5、IOC 容器的高级特性
----1、介绍
----2、Spring IOC 容器的 lazy-init 属性实现预实例化
------(1).refresh()
------(2).finishBeanFactoryInitialization 处理预实例化 Bean
------(3).DefaultListableBeanFactory 对配置 lazy-init 属性单态 Bean 的预实例化
----3、FactoryBean 的实现
------(1)FactoryBean的源码
------(2). AbstractBeanFactory 的 getBean 方法调用 FactoryBean
------(3).AbstractBeanFactory 生产 Bean 实例对象
------(4).工厂 Bean 的实现类 getObject 方法创建 Bean 实例对象
----4、BeanPostProcessor 后置处理器的实现
------(1).BeanPostProcessor 的源码
------(2).AbstractAutowireCapableBeanFactory 类对容器生成的 Bean 添加后置处理器
------(3).initializeBean 方法为容器产生的 Bean 实例对象添加 BeanPostProcessor 后置处理器
------(4).AdvisorAdapterRegistrationManager 在 Bean 对象初始化后注册通知适配器
----5、Spring IOC 容器 autowiring 实现原理
------(1). AbstractAutoWireCapableBeanFactory 对 Bean 实例进行属性依赖注入
------(2).Spring IOC 容器根据 Bean 名称或者类型进行 autowiring 自动依赖注入
------(3).DefaultSingletonBeanRegistry 的 registerDependentBean 方法对属性注入

五、spring源码分析

5.5、IOC 容器的高级特性

1、介绍

通过前面 4 节对 Spring IOC 容器的源码分析，我们已经基本上了解了 Spring IOC 容器对 Bean 定 义资源的定位、读入和解析过程，同时也清楚了当用户通过 getBean 方法向 IOC 容器获取被管理的 Bean 时，IOC 容器对 Bean 进行的初始化和依赖注入过程，这些是 Spring IOC 容器的基本功能特性。 Spring IOC 容器还有一些高级特性，如使用 lazy-init 属性对 Bean 预初始化、FactoryBean 产生或者 修饰 Bean 对象的生成、 IOC 容器初始化 Bean 过程中使用 BeanPostProcessor 后置处理器对 Bean 声明周 期事件管理和 IOC 容器的 autowiring 自动装配功能等。

2、Spring IOC 容器的 lazy-init 属性实现预实例化：

通过前面我们对 IOC 容器的实现和工作原理分析，我们知道 IOC 容器的初始化过程就是对 Bean 定义 资源的定位、载入和注册，此时容器对 Bean 的依赖注入并没有发生，依赖注入主要是在应用程序第一 次向容器索取 Bean 时，通过 getBean 方法的调用完成。

当 Bean 定义资源的元素中配置了 lazy-init 属性时，容器将会在初始化的时候对所配置的 Bean 进行预实例化，Bean 的依赖注入在容器初始化的时候就已经完成。这样，当应用程序第一次向容器索取 被管理的 Bean 时，就不用再初始化和对 Bean 进行依赖注入了，直接从容器中获取已经完成依赖注入的 现成 Bean，可以提高应用第一次向容器获取 Bean 的性能。

下面我们通过代码分析容器预实例化的实现过程：

(1).refresh()

先从 IOC 容器的初始会过程开始，通过前面文章分析，我们知道 IOC 容器读入已经定位的 Bean 定义资 源是从 refresh 方法开始的，我们首先从 AbstractApplicationContext 类的 refresh 方法入手分析， 源码如下：

//容器初始化的过程，读入 Bean 定义资源，并解析注册
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        //调用容器准备刷新的方法，获取容器的当时时间，同时给容器设置同步标识
        prepareRefresh();
        //告诉子类启动 refreshBeanFactory()方法，Bean 定义资源文件的载入从
        //子类的 refreshBeanFactory()方法启动
        ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();
        //为 BeanFactory 配置容器特性，例如类加载器、事件处理器等
        prepareBeanFactory(beanFactory);
        try {
            //为容器的某些子类指定特殊的 BeanPost 事件处理器
            postProcessBeanFactory(beanFactory);
            //调用所有注册的 BeanFactoryPostProcessor 的 Bean
            invokeBeanFactoryPostProcessors(beanFactory);
            //为 BeanFactory 注册 BeanPost 事件处理器.
            //BeanPostProcessor 是 Bean 后置处理器，用于监听容器触发的事件
            registerBeanPostProcessors(beanFactory);
            //初始化信息源，和国际化相关.
            initMessageSource();
            //初始化容器事件传播器.
            initApplicationEventMulticaster();
            //调用子类的某些特殊 Bean 初始化方法
            onRefresh();
            //为事件传播器注册事件监听器.
            registerListeners();
            //这里是对容器 lazy-init 属性进行处理的入口方法
            finishBeanFactoryInitialization(beanFactory);
            //初始化容器的生命周期事件处理器，并发布容器的生命周期事件
            finishRefresh();
        }catch (BeansException ex) {
            //销毁以创建的单态 Bean
            destroyBeans();
            //取消 refresh 操作，重置容器的同步标识.
            cancelRefresh(ex);
            throw ex;
        }
    }
}

在 refresh 方法中 ConfigurableListableBeanFactorybeanFactory = obtainFreshBeanFactory(); 启动了 Bean 定义资源的载入、注册过程，而 finishBeanFactoryInitialization 方法是对注册后的 Bean 定义中的预实例化(lazy-init=false，Spring 默认就是预实例化，即为 true)的 Bean 进行处理的地方。

(2).finishBeanFactoryInitialization 处理预实例化 Bean：

当Bean定义资源被载入IOC容器之后，容器将Bean定义资源解析为容器内部的数据结构BeanDefinition 注册到容器中， AbstractApplicationContext 类中的 finishBeanFactoryInitialization 方法对配置了 预实例化属性的 Bean 进行预初始化过程，源码如下：

//对配置了 lazy-init 属性的 Bean 进行预实例化处理
protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    //这是 Spring3 以后新加的代码，为容器指定一个转换服务(ConversionService)
    //在对某些 Bean 属性进行转换时使用
    if (beanFactory.containsBean(CONVERSION_SERVICE_BEAN_NAME) &&
    beanFactory.isTypeMatch(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class)) {
        beanFactory.setConversionService(
            beanFactory.getBean(CONVERSION_SERVICE_BEAN_NAME, ConversionService.class));
    }
    //为了类型匹配，停止使用临时的类加载器
    beanFactory.setTempClassLoader(null);
    //缓存容器中所有注册的 BeanDefinition 元数据，以防被修改
    beanFactory.freezeConfiguration();
    //对配置了 lazy-init 属性的单态模式 Bean 进行预实例化处理
    beanFactory.preInstantiateSingletons();
}

ConfigurableListableBeanFactory 是一个接口，其 preInstantiateSingletons 方法由其子类 DefaultListableBeanFactory 提供。

(3).DefaultListableBeanFactory 对配置 lazy-init 属性单态 Bean 的预实例化：

public void preInstantiateSingletons() throws BeansException {
    if (this.logger.isInfoEnabled()) {
     this.logger.info("Pre-instantiating singletons in " + this);
    }
    //在对配置 lazy-init 属性单态 Bean 的预实例化过程中，必须多线程同步，以确保数据一致性
    synchronized (this.beanDefinitionMap) {
        for (String beanName : this.beanDefinitionNames) {
            //获取指定名称的 Bean 定义
            RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
            //Bean 不是抽象的，是单态模式的，且 lazy-init 属性配置为 false
                if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
                    //如果指定名称的 bean 是创建容器的 Bean
                    if (isFactoryBean(beanName)) {
                    //FACTORY_BEAN_PREFIX=”&”，当 Bean 名称前面加”&”符号
                    //时，获取的是产生容器对象本身，而不是容器产生的 Bean.
                    //调用 getBean 方法，触发容器对 Bean 实例化和依赖注入过程
                    final FactoryBean factory = (FactoryBean) getBean(FACTORY_BEAN_PREFIX +
                    beanName);
                    //标识是否需要预实例化
                    boolean isEagerInit;
                    if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean){
                        //一个匿名内部类
                        isEagerInit = AccessController.doPrivileged(new
                            PrivilegedAction() {
                                public Boolean run() {
                                    return ((SmartFactoryBean) factory).isEagerInit();
                                }
                            }, getAccessControlContext());
                    }else {
                        isEagerInit = factory instanceof SmartFactoryBean && ((SmartFactoryBean)
                        factory).isEagerInit();
                    }
                    if (isEagerInit) {
                        //调用 getBean 方法，触发容器对 Bean 实例化和依赖注入过程
                        getBean(beanName);
                    }
                }else {
                    //调用 getBean 方法，触发容器对 Bean 实例化和依赖注入过程
                    getBean(beanName);
                }
            }
        }
    }
}

通过对 lazy-init 处理源码的分析，我们可以看出，如果设置了 lazy-init 属性，则容器在完成 Bean 定义的注册之后，会通过 getBean 方法，触发对指定 Bean 的初始化和依赖注入过程，这样当应用第一 次向容器索取所需的 Bean 时，容器不再需要对 Bean 进行初始化和依赖注入，直接从已经完成实例化和 依赖注入的 Bean 中取一个现成的 Bean，这样就提高了第一次获取 Bean 的性能。

3、FactoryBean 的实现：

在 Spring 中，有两个很容易混淆的类：BeanFactory 和 FactoryBean。

BeanFactory：Bean 工厂，是一个工厂(Factory)，我们 Spring IOC 容器的最顶层接口就是这个 BeanFactory，它的作用是管理 Bean，即实例化、定位、配置应用程序中的对象及建立这些对象间的依 赖。

FactoryBean：工厂 Bean，是一个 Bean，作用是产生其他 bean 实例。通常情况下，这种 bean 没有什么 特别的要求，仅需要提供一个工厂方法，该方法用来返回其他 bean 实例。通常情况下，bean 无须自己 实现工厂模式，Spring 容器担任工厂角色；但少数情况下，容器中的 bean 本身就是工厂，其作用是产 生其它 bean 实例。

当用户使用容器本身时，可以使用转义字符”&”来得到 FactoryBean 本身，以区别通过 FactoryBean 产生的实例对象和 FactoryBean 对象本身。在 BeanFactory 中通过如下代码定义了该转义字符：

StringFACTORY_BEAN_PREFIX = "&";

如果 myJndiObject 是一个 FactoryBean，则使用&myJndiObject 得到的是 myJndiObject 对象，而不是 myJndiObject 产生出来的对象。

(1).FactoryBean 的源码：

//工厂 Bean，用于产生其他对象
public interface FactoryBean {
    //获取容器管理的对象实例
    T getObject() throws Exception;
    //获取 Bean 工厂创建的对象的类型
    Class getObjectType();
    //Bean 工厂创建的对象是否是单态模式，如果是单态模式，则整个容器中只有一个实例
    //对象，每次请求都返回同一个实例对象
    boolean isSingleton();
}

(2). AbstractBeanFactory 的 getBean 方法调用 FactoryBean：

在前面我们分析 Spring IOC 容器实例化 Bean 并进行依赖注入过程的源码时，提到在 getBean 方法触 发容器实例化 Bean 的时候会调用 AbstractBeanFactory 的 doGetBean 方法来进行实例化的过程，源码 如下：

//真正实现向 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 的相关处理
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    ……
}
//获取给定 Bean 的实例对象，主要是完成 FactoryBean 的相关处理
protected Object getObjectForBeanInstance(
Object beanInstance, String name, String beanName, RootBeanDefinition mbd) {
    //容器已经得到了 Bean 实例对象，这个实例对象可能是一个普通的 Bean，
    //也可能是一个工厂 Bean，如果是一个工厂 Bean，则使用它创建一个 Bean 实例对象，
    //如果调用本身就想获得一个容器的引用，则指定返回这个工厂 Bean 实例对象
    //如果指定的名称是容器的解引用(dereference，即是对象本身而非内存地址)，
    //且 Bean 实例也不是创建 Bean 实例对象的工厂 Bean
    if (BeanFactoryUtils.isFactoryDereference(name) && !(beanInstance instanceof FactoryBean)) {
        throw new BeanIsNotAFactoryException(transformedBeanName(name),
            beanInstance.getClass());
    }
    //如果 Bean 实例不是工厂 Bean，或者指定名称是容器的解引用，
    //调用者向获取对容器的引用，则直接返回当前的 Bean 实例
    if (!(beanInstance instanceof FactoryBean) || BeanFactoryUtils.isFactoryDereference(name)) {
     return beanInstance;
    }
    //处理指定名称不是容器的解引用，或者根据名称获取的 Bean 实例对象是一个工厂 Bean
    //使用工厂 Bean 创建一个 Bean 的实例对象
    Object object = null;
    if (mbd == null) {
        //从 Bean 工厂缓存中获取给定名称的 Bean 实例对象
        object = getCachedObjectForFactoryBean(beanName);
    }
    //让 Bean 工厂生产给定名称的 Bean 对象实例
    if (object == null) {
        FactoryBean factory = (FactoryBean) beanInstance;
        //如果从 Bean 工厂生产的 Bean 是单态模式的，则缓存
        if (mbd == null && containsBeanDefinition(beanName)) {
            //从容器中获取指定名称的 Bean 定义，如果继承基类，则合并基类相关属性
            mbd = getMergedLocalBeanDefinition(beanName);
        }
        //如果从容器得到 Bean 定义信息，并且 Bean 定义信息不是虚构的，
        //则让工厂 Bean 生产 Bean 实例对象
        boolean synthetic = (mbd != null && mbd.isSynthetic());
        //调用 FactoryBeanRegistrySupport 类的 getObjectFromFactoryBean 方法，
        //实现工厂 Bean 生产 Bean 对象实例的过程
        object = getObjectFromFactoryBean(factory, beanName, !synthetic);
    }
    return object;
}

在上面获取给定 Bean 的实例对象的 getObjectForBeanInstance 方法中，会调用 FactoryBeanRegistrySupport 类的 getObjectFromFactoryBean 方法，该方法实现了 Bean 工厂生产 Bean 实例对象。

Dereference(解引用)：一个在 C/C++中应用比较多的术语，在 C++中，”*”是解引用符号，而”&”是 引用符号，解引用是指变量指向的是所引用对象的本身数据，而不是引用对象的内存地址。

(3).AbstractBeanFactory 生产 Bean 实例对象：

AbstractBeanFactory 类中生产 Bean 实例对象的主要源码如下

//Bean 工厂生产 Bean 实例对象
protected Object getObjectFromFactoryBean(FactoryBean factory, String beanName, boolean
shouldPostProcess) {
    //Bean 工厂是单态模式，并且 Bean 工厂缓存中存在指定名称的 Bean 实例对象
    if (factory.isSingleton() && containsSingleton(beanName)) {
        //多线程同步，以防止数据不一致
        synchronized (getSingletonMutex()) {
            //直接从 Bean 工厂缓存中获取指定名称的 Bean 实例对象
            Object object = this.factoryBeanObjectCache.get(beanName);
            //Bean 工厂缓存中没有指定名称的实例对象，则生产该实例对象
            if (object == null) {
                //调用 Bean 工厂的 getObject 方法生产指定 Bean 的实例对象
                object = doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
                //将生产的实例对象添加到 Bean 工厂缓存中
                this.factoryBeanObjectCache.put(beanName, (object != null ? object : NULL_OBJECT));
            }
            return (object != NULL_OBJECT ? object : null);
        }
    }
    //调用 Bean 工厂的 getObject 方法生产指定 Bean 的实例对象
    else {
        return doGetObjectFromFactoryBean(factory, beanName, shouldPostProcess);
    }
}
//调用 Bean 工厂的 getObject 方法生产指定 Bean 的实例对象
private Object doGetObjectFromFactoryBean(
final FactoryBean factory, final String beanName, final boolean shouldPostProcess)
throws BeanCreationException {
    Object object;
    try {
        if (System.getSecurityManager() != null) {
            AccessControlContext acc = getAccessControlContext();
            try {
                //实现 PrivilegedExceptionAction 接口的匿名内置类
                //根据 JVM 检查权限，然后决定 BeanFactory 创建实例对象
                object = AccessController.doPrivileged(new PrivilegedExceptionAction() {
                    public Object run() throws Exception {
                        //调用 BeanFactory 接口实现类的创建对象方法
                        return factory.getObject();
                    }}, acc);
            }catch (PrivilegedActionException pae) {
                throw pae.getException();
            }
        }else {
            //调用 BeanFactory 接口实现类的创建对象方法
            object = factory.getObject();
        }
    }catch (FactoryBeanNotInitializedException ex) {
        throw new BeanCurrentlyInCreationException(beanName, ex.toString());
    }
    catch (Throwable ex) {
        throw new BeanCreationException(beanName, "FactoryBean threw exception on object creation",ex);
    }
    //创建出来的实例对象为 null，或者因为单态对象正在创建而返回 null
    if (object == null && isSingletonCurrentlyInCreation(beanName)) {
        throw new BeanCurrentlyInCreationException(
        beanName, "FactoryBean which is currently in creation returned null from getObject");
    }
    //为创建出来的 Bean 实例对象添加 BeanPostProcessor 后置处理器
    if (object != null && shouldPostProcess) {
        try {
            object = postProcessObjectFromFactoryBean(object, beanName);
        }catch (Throwable ex) {
            throw new BeanCreationException(beanName, "Post-processing of the FactoryBean's object
            failed", ex);
        }
    }
    return object;
}
 
 
从上面的源码分析中，我们可以看出， BeanFactory 接口调用其实现类的 getObject 方法来实现创建 Bean 实例对象的功能。
 
 
(4).工厂 Bean 的实现类 getObject 方法创建 Bean 实例对象：
 
 
FactoryBean的实现类有非常多，比如： Proxy、 RMI、 JNDI、 ServletContextFactoryBean 等等， FactoryBean 接口为 Spring 容器提供了一个很好的封装机制，具体的 getObject 有不同的实现类根据不同的实现策 略来具体提供，我们分析一个最简单的 AnnotationTestFactoryBean 的实现源码：
 
 
public class AnnotationTestBeanFactory implements FactoryBean {

    private final FactoryCreatedAnnotationTestBean instance = new
            FactoryCreatedAnnotationTestBean();

    public AnnotationTestBeanFactory() {
        this.instance.setName("FACTORY");
    }
    //AnnotationTestBeanFactory 产生 Bean 实例对象的实现
    public IJmxTestBean getObject() throws Exception {
         return this.instance;
    }
    public Class getObjectType() {
        return FactoryCreatedAnnotationTestBean.class;
    }
    public boolean isSingleton() {
         return true;
    }
}

 
 
其他的 Proxy，RMI，JNDI 等等，都是根据相应的策略提供 getObject 的实现。这里不做一一分析，这 已经不是 Spring 的核心功能，有需要的时候再去深入研究。
 
 
4、BeanPostProcessor 后置处理器的实现：
 
 
BeanPostProcessor 后置处理器是 Spring IOC 容器经常使用到的一个特性，这个 Bean 后置处理器是一 个监听器，可以监听容器触发的 Bean 声明周期事件。后置处理器向容器注册以后，容器中管理的 Bean 就具备了接收 IOC 容器事件回调的能力。
 
 
BeanPostProcessor 的使用非常简单，只需要提供一个实现接口 BeanPostProcessor 的实现类，然后在 Bean 的配置文件中设置即可。
 
 
(1).BeanPostProcessor 的源码：
 
 
package org.springframework.beans.factory.config;
import org.springframework.beans.BeansException;
public interface BeanPostProcessor {
    //为在 Bean 的初始化前提供回调入口
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;
    //为在 Bean 的初始化之后提供回调入口
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;
}

 
 
这两个回调的入口都是和容器管理的 Bean 的生命周期事件紧密相关，可以为用户提供在 Spring IOC 容器初始化 Bean 过程中自定义的处理操作。
 
 
(2).AbstractAutowireCapableBeanFactory 类对容器生成的 Bean 添加后置处理器：
 
 
BeanPostProcessor后置处理器的调用发生在Spring IOC容器完成对Bean实例对象的创建和属性的依 赖注入完成之后，在对 Spring 依赖注入的源码分析过程中我们知道，当应用程序第一次调用 getBean 方法(lazy-init 预实例化除外)向 Spring IOC 容器索取指定 Bean 时触发 Spring IOC 容器创建 Bean 实例对象并进行依赖注入的过程，其中真正实现创建 Bean 对象并进行依赖注入的方法是 AbstractAutowireCapableBeanFactory 类的 doCreateBean 方法，主要源码如下
 
 
//真正创建 Bean 的方法
protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    //创建 Bean 实例对象
    ……
    try {
        //对 Bean 属性进行依赖注入
        populateBean(beanName, mbd, instanceWrapper);
        if (exposedObject != null) {
            //在对 Bean 实例对象生成和依赖注入完成以后，开始对 Bean 实例对象
            //进行初始化 ，为 Bean 实例对象应用 BeanPostProcessor 后置处理器
            exposedObject = initializeBean(beanName, exposedObject, mbd);
        }
    }catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException)
        ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
    ……
    //为应用返回所需要的实例对象
    return exposedObject;
}

 
 
从上面的代码中我们知道，为 Bean 实例对象添加 BeanPostProcessor 后置处理器的入口的是 initializeBean 方法。
 
 
(3).initializeBean 方法为容器产生的 Bean 实例对象添加 BeanPostProcessor 后置处理器：
 
 
同样在 AbstractAutowireCapableBeanFactory 类中， initializeBean 方法实现为容器创建的 Bean 实例 对象添加 BeanPostProcessor 后置处理器，源码如下：
 
 
//初始容器创建的 Bean 实例对象，为其添加 BeanPostProcessor 后置处理器
protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd){
    //JDK 的安全机制验证权限
    if (System.getSecurityManager() != null) {
        //实现 PrivilegedAction 接口的匿名内部类
        AccessController.doPrivileged(new PrivilegedAction() {
            public Object run() {
                invokeAwareMethods(beanName, bean);
                return null;
            }
        }, getAccessControlContext());
    }else {
        //为 Bean 实例对象包装相关属性，如名称，类加载器，所属容器等信息
        invokeAwareMethods(beanName, bean);
    }
    Object wrappedBean = bean;
    //对 BeanPostProcessor 后置处理器的 postProcessBeforeInitialization
    //回调方法的调用，为 Bean 实例初始化前做一些处理
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    //调用 Bean 实例对象初始化的方法，这个初始化方法是在 Spring Bean 定义配置
    //文件中通过 init-method 属性指定的
    try {
        invokeInitMethods(beanName, wrappedBean, mbd);
    }catch (Throwable ex) {
        throw new BeanCreationException(
            (mbd != null ? mbd.getResourceDescription() : null),
            beanName, "Invocation of init method failed", ex);
    }
    //对 BeanPostProcessor 后置处理器的 postProcessAfterInitialization
    //回调方法的调用，为 Bean 实例初始化之后做一些处理
    if (mbd == null || !mbd.isSynthetic()) {
        wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
}
//调用 BeanPostProcessor 后置处理器实例对象初始化之前的处理方法
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {
    Object result = existingBean;
    //遍历容器为所创建的 Bean 添加的所有 BeanPostProcessor 后置处理器
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        //调用 Bean 实例所有的后置处理中的初始化前处理方法，为 Bean 实例对象在
        //初始化之前做一些自定义的处理操作
        result = beanProcessor.postProcessBeforeInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}
//调用 BeanPostProcessor 后置处理器实例对象初始化之后的处理方法
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
throws BeansException {
    Object result = existingBean;
    //遍历容器为所创建的 Bean 添加的所有 BeanPostProcessor 后置处理器
    for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
        //调用 Bean 实例所有的后置处理中的初始化后处理方法，为 Bean 实例对象在
        //初始化之后做一些自定义的处理操作
        result = beanProcessor.postProcessAfterInitialization(result, beanName);
        if (result == null) {
            return result;
        }
    }
    return result;
}
 
 
BeanPostProcessor 是一个接口，其初始化前的操作方法和初始化后的操作方法均委托其实现子类来实 现，在 Spring 中，BeanPostProcessor 的实现子类非常的多，分别完成不同的操作，如：AOP 面向切面编程的注册通知适配器、Bean 对象的数据校验、Bean 继承属性/方法的合并等等，我们以最简单的 AOP 切面织入来简单了解其主要的功能。
 
 
(4).AdvisorAdapterRegistrationManager 在 Bean 对象初始化后注册通知适配器：
 
 
AdvisorAdapterRegistrationManager 是 BeanPostProcessor 的一个实现类，其主要的作用为容器中管 理的 Bean 注册一个面向切面编程的通知适配器，以便在 Spring 容器为所管理的 Bean 进行面向切面编 程时提供方便，其源码如下：
 
 
//为容器中管理的 Bean 注册一个面向切面编程的通知适配器
public class AdvisorAdapterRegistrationManager implements BeanPostProcessor {
    //容器中负责管理切面通知适配器注册的对象
    private AdvisorAdapterRegistry advisorAdapterRegistry =
        GlobalAdvisorAdapterRegistry.getInstance();
    
    public void setAdvisorAdapterRegistry(AdvisorAdapterRegistry advisorAdapterRegistry) {
         this.advisorAdapterRegistry = advisorAdapterRegistry;
    }
    //BeanPostProcessor 在 Bean 对象初始化前的操作
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException
    {
        //没有做任何操作，直接返回容器创建的 Bean 对象
        return bean;
    }
    //BeanPostProcessor 在 Bean 对象初始化后的操作
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException
    {
        if (bean instanceof AdvisorAdapter){
            //如果容器创建的 Bean 实例对象是一个切面通知适配器，则向容器的注册
            this.advisorAdapterRegistry.registerAdvisorAdapter((AdvisorAdapter) bean);
        }
        return bean;
    }
}

 
 
其他的 BeanPostProcessor 接口实现类的也类似，都是对 Bean 对象使用到的一些特性进行处理，或者 向 IOC 容器中注册，为创建的 Bean 实例对象做一些自定义的功能增加，这些操作是容器初始化 Bean 时 自动触发的，不需要认为的干预。
 
 
5、Spring IOC 容器 autowiring 实现原理：
 
 
 
  
Spring IOC 容器提供了两种管理 Bean 依赖关系的方式：
 
  
a.显式管理：通过 BeanDefinition 的属性值和构造方法实现 Bean 依赖关系管理。
 
  
b.autowiring：Spring IOC 容器的依赖自动装配功能，不需要对 Bean 属性的依赖关系做显式的声明， 只需要在配置好 autowiring 属性，IOC 容器会自动使用反射查找属性的类型和名称，然后基于属性的类 型或者名称来自动匹配容器中管理的 Bean，从而自动地完成依赖注入。
 
 
 
 
通过对 autowiring 自动装配特性的理解，我们知道容器对 Bean 的自动装配发生在容器对 Bean 依赖注 入的过程中。在前面对 Spring IOC 容器的依赖注入过程源码分析中，我们已经知道了容器对 Bean 实 例对象的属性注入的处理发生在 AbstractAutoWireCapableBeanFactory 类中的 populateBean 方法中， 我们通过程序流程分析 autowiring 的实现原理：
 
 
(1). AbstractAutoWireCapableBeanFactory 对 Bean 实例进行属性依赖注入：
 
 
应用第一次通过 getBean 方法(配置了 lazy-init 预实例化属性的除外)向 IoC 容器索取 Bean 时，容器 创建 Bean 实例对象，并且对 Bean 实例对象进行属性依赖注入，AbstractAutoWireCapableBeanFactory 的 populateBean 方法就是实现 Bean 属性依赖注入的功能，其主要源码如下：
 
 
protected void populateBean(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw) {
    //获取 Bean 定义的属性值，并对属性值进行处理
    PropertyValues pvs = mbd.getPropertyValues();
    ……
    //对依赖注入处理，首先处理 autowiring 自动装配的依赖注入
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||
     mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
        MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
        //根据 Bean 名称进行 autowiring 自动装配处理
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
        }
        //根据 Bean 类型进行 autowiring 自动装配处理
        if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
        }
    }
    //对非 autowiring 的属性进行依赖注入处理
    ……
}

 
 
(2).Spring IOC 容器根据 Bean 名称或者类型进行 autowiring 自动依赖注入：
 
 
//根据名称对属性进行自动依赖注入
protected void autowireByName(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs){
    //对 Bean 对象中非简单属性(不是简单继承的对象，如 8 中原始类型，字符串，URL 等都是简单属性)进行处理
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        //如果 Spring IOC 容器中包含指定名称的 Bean
        if (containsBean(propertyName)) {
            //调用 getBean 方法向 IoC 容器索取指定名称的 Bean 实例，迭代触发属性的初始化和依赖注入
            Object bean = getBean(propertyName);
            //为指定名称的属性赋予属性值
            pvs.add(propertyName, bean);
            //指定名称属性注册依赖 Bean 名称，进行属性依赖注入
            registerDependentBean(propertyName, beanName);
            if (logger.isDebugEnabled()) {
                logger.debug("Added autowiring by name from bean name '" + beanName +
                "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
            }
        }else {
            if (logger.isTraceEnabled()) {
                logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName + "' by name: no matching bean found");
            }
        }
    }
}
//根据类型对属性进行自动依赖注入
protected void autowireByType(
String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)
{
    //获取用户定义的类型转换器
    TypeConverter converter = getCustomTypeConverter();
    if (converter == null) {
         converter = bw;
    }
    //存放解析的要注入的属性
    Set autowiredBeanNames = new LinkedHashSet(4);
    //对 Bean 对象中非简单属性(不是简单继承的对象，如 8 中原始类型，字符
    //URL 等都是简单属性)进行处理
    String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
    for (String propertyName : propertyNames) {
        try {
            //获取指定属性名称的属性描述器
            PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
            //不对 Object 类型的属性进行 autowiring 自动依赖注入
            if (!Object.class.equals(pd.getPropertyType())) {
                //获取属性的 setter 方法
                MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
                //检查指定类型是否可以被转换为目标对象的类型
                boolean eager = !PriorityOrdered.class.isAssignableFrom(bw.getWrappedClass());
                //创建一个要被注入的依赖描述
                DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam,
                eager);
                //根据容器的 Bean 定义解析依赖关系，返回所有要被注入的 Bean 对象
                Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames,
                converter);
                if (autowiredArgument != null) {
                    //为属性赋值所引用的对象
                    pvs.add(propertyName, autowiredArgument);
                }
                for (String autowiredBeanName : autowiredBeanNames) {
                //指定名称属性注册依赖 Bean 名称，进行属性依赖注入
                    registerDependentBean(autowiredBeanName, beanName);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Autowiring by type from bean name '" + beanName + "' via
                        property '" +
                        propertyName + "' to bean named '" + autowiredBeanName + "'");
                    }
                }
                //释放已自动注入的属性
                autowiredBeanNames.clear();
            }
        }catch (BeansException ex) {
            throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName,
             propertyName, ex);
        }
    }
}

 
 
通过上面的源码分析，我们可以看出来通过属性名进行自动依赖注入的相对比通过属性类型进行自动依 赖注入要稍微简单一些，但是真正实现属性注入的是 DefaultSingletonBeanRegistry 类的 registerDependentBean 方法。
 
 
(3).DefaultSingletonBeanRegistry 的 registerDependentBean 方法对属性注入：
 
 
//为指定的 Bean 注入依赖的 Bean
public void registerDependentBean(String beanName, String dependentBeanName) {
    //处理 Bean 名称，将别名转换为规范的 Bean 名称
    String canonicalName = canonicalName(beanName);
    //多线程同步，保证容器内数据的一致性
    //先从容器中：bean 名称-->全部依赖 Bean 名称集合找查找给定名称 Bean 的依赖 Bean
    synchronized (this.dependentBeanMap) {
        //获取给定名称 Bean 的所有依赖 Bean 名称
        Set dependentBeans = this.dependentBeanMap.get(canonicalName);
        if (dependentBeans == null) {
            //为 Bean 设置依赖 Bean 信息
            dependentBeans = new LinkedHashSet(8);
            this.dependentBeanMap.put(canonicalName, dependentBeans);
        }
        //向容器中：bean 名称-->全部依赖 Bean 名称集合添加 Bean 的依赖信息
        //即，将 Bean 所依赖的 Bean 添加到容器的集合中
        dependentBeans.add(dependentBeanName);
    }
    //从容器中：bean 名称-->指定名称 Bean 的依赖 Bean 集合找查找给定名称 Bean 的依赖 Bean
    synchronized (this.dependenciesForBeanMap) {
        Set dependenciesForBean = this.dependenciesForBeanMap.get(dependentBeanName);
        if (dependenciesForBean == null) {
            dependenciesForBean = new LinkedHashSet(8);
            this.dependenciesForBeanMap.put(dependentBeanName, dependenciesForBean);
        }
        //向容器中：bean 名称-->指定 Bean 的依赖 Bean 名称集合添加 Bean 的依赖信息
        //即，将 Bean 所依赖的 Bean 添加到容器的集合中
        dependenciesForBean.add(canonicalName);
    }
}

 
 
通过对 autowiring 的源码分析，我们可以看出，autowiring 的实现过程：
 
 
 
  
a.对 Bean 的属性代调用 getBean 方法，完成依赖 Bean 的初始化和依赖注入。
 
  
b.将依赖 Bean 的属性引用设置到被依赖的 Bean 属性上。
 
  
c.将依赖 Bean 的名称和被依赖 Bean 的名称存储在 IOC 容器的集合中。
 
 
 
 
Spring IOC 容器的 autowiring 属性自动依赖注入是一个很方便的特性，可以简化开发时的配置，但是凡是都有两面性， 自动属性依赖注入也有不足，首先，Bean 的依赖关系在配置文件中无法很清楚地看出来，对于维护造成一定困难。其 次，由于自动依赖注入是 Spring 容器自动执行的，容器是不会智能判断的，如果配置不当，将会带来无法预料的后果， 所以自动依赖注入特性在使用时还是综合考虑。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • 2018-05-12
                        段智耀

                        
    今天妈妈日记的时候，我正愁没有的说，突然外面哗哗的下起了大雨，而且还打雷，真是吓死宝宝了，不一会儿，刚刚出去散步的叔叔，一个个的都跑回来了，头发都淋湿了。他们都说，外面下大雨了。幸好这场雨没有感到我们春游的时候下，要不然就糟了。唉呀！下吧下吧。就当给小花小草浇浇水吧。但是，小雨啊你慢点。别把那些好看的小花小草打坏了，他们都是有生命的啊！
    
                    
    • 
                    
  • 2018-05-12
                        叶陌风

                        
    图片发自App大学毕业之际，同学录传的哪里都是，同学们也都是该表白的表白该分手的分手。她看看他，那个她暗恋了四年的人。他长得很好看，皮肤白嫩的像个女生，眨眼睛时睫毛扑闪的像蝴蝶的翅膀。此刻他周围围了许多女生，大多都是递同学录的，还有个别递的是情书，他都没有理睬。她犹豫了很久，最后拿着同学录走到他的座位旁。他没有说话，只是接过后快速写完后又还给她。当她满怀希望的掀开那一页时，她哭了。因为他的留言。一
    
                    
    • 
                    
  • 2018-05-12
                        正心正德

                        
    未来5年，叫做千条江河归大海，无论你是从事什么行业，都得归到健康上来。无论你是谁，你一定会健康养生这个行业扯上关系！要么你是经营者，要么你是消费者！健康家人，惠及他人。掰着指头想想，身边的亲人、同事和朋友有多少是腰腿疼，乳腺增生、子宫肌瘤，颈椎病、肩周炎、腰间盘突出，股骨头坏死，前列腺炎、糖尿病、高血压、心脑血管、肺气肿，老慢支气管炎等！疾病越来越年轻化、现在不懂养生，以后养医生，善待自己，养生固
    
                    
    • 
                    
  • 2018-05-12
                        CindyWellin

                        
    2018-05-13CindyWellin祝新华（稻盛哲学学习会）打卡第38天姓名：祝新华部门：业务部组别：待定【知～学习】第五章，与其追求开悟，不如运用理性和良心去磨砺心志【内容感悟分享】“首先磨去最外层的知性到达感性，感性磨去之后到达本能，再磨掉本能.......直到最后整我完全展露，这种从外向内彻底的心灵磨炼即为修行。所谓开悟，就是指磨炼心志到达真我的状态。”遵循发自真我及灵魂的理性与良心，
    
                    
    • 
                    
  • 2018-05-12
                        京心达宁威

                        
    今日体验，今天给宝马五系做保养，发现气门室盖漏油，发动机抖动，发动机支撑垫有问题！建议客户更换，由于车不是他的，只能上报请示！核心，发现问题，第一时间和客户沟通！
    
                    
    • 
                    
  • 2018-05-12金刚书院王海娟《智慧天天见》共修第6天
                        whj夏日心情

                        
    作业:今天看手机减少到2次，打接电话除外和正常工作除外，继续找减压的方式！☞如何有意识种下让别人放松的种子的方式！今天看手机超过了2次，下午在店里忙完工作，等着接孩子的时间感觉无聊，没有控制住，打开微信看信息，不过时间很短暂，意识到以后，马上退出，然后帮洪娟哄孩子，跟周姐一起插花！图片发自App感恩母亲给予我生命！感恩冯老师智慧引领！感恩回向我的目标年底之前达成！祈愿我的目标达成把种子的践行智慧经
    
                    
    • 
                    
  • 2018-05-12
                        嗯撸

                        
    ＊今日新增1、plus领自营汽车用品50-25券，5.12-5.14领券:http://t.cn/R3q1qJF用券:http://t.cn/R3q1qXM2、10点抢新款叮咚智能音箱299-220券，5.12-5.18领券:http://t.cn/R3q1xNn用券:http://t.cn/R3q1x9X＊目前有效1、三只松鼠、良品铺子等199-120券，有效期7天领券:http://t.cn/
    
                    
    • 
                    
  • 2018-05-12星期六 亲子日记70
                        拾一片光阴

                        
    上午的家长会如期举行,黄老师和胡老师做了这一段时间的总结,这次考试诺数学还行,语文成绩很是不理想,满试卷的大红错号,说过不看重分数,只分析原因,问了诺什么原因,说还是不仔细,审题不认真.昨天接依霏妈妈通知,家长会对亲子日记的坚持做简短总结,有点紧张,有点语无伦次,不过结果还好,哈哈哈,大家不嫌弃,亲自日记团每人都授予了大红花图片发自App从最开始的记流水账到现在也坚持了七十篇日记了，每次翻看之前的
    
                    
    • 
                    
  • 2018-05-12
                        78c55d3eee28

                        
    为人父母:你们还有什么脸活在世上？刁民2009-05-1214:13我闭嘴整整一年了，我就说过我要为汶川地震中死难的孩子们默哀一年。一年里，我的心滴血的一年，数以万计死去的孩子们白死了(为什么死的都是学生娃啊？)，那些建学校的不法奸商、被学生视为父母的校领导、还有验收学校的贪官没有得到一丝的惩罚。天灾我们没有办法，但人祸为什么就没有引起人们注意啊！如果犯罪的成本这么底，谁都可以不顾别人的死活捞一把
    
                    
    • 
                    
  • 2018-05-12
                        晓妖菁

                        
    姓名：王晓菁公司：海南蔚蓝时代实业有限公司378期反省一组塾生【日精进打卡第12天】【经典诵读】《六项精进》大纲4遍,共30遍《大学》0遍,共13遍【名句分享】积善之家，必有余庆。一、修身：吃了早餐，喝了牛奶。二、齐家：陪小朋友吃饭、睡觉，整理衣柜，捐赠了3袋衣服。三、建功：1、参加人才市场招聘会，意向录用一个录单员、一个商场领班、一个商场营业员，储备一个行政人事专员。2、其他日常工作。【省~悟】
    
                    
    • 
                    
  • 2018-05-12
                        哲妈学习成长之路

                        
    2018.5.7幸福日记第10篇今天值得我开心的事有：孩子坚持去补课了，虽然早上起床让我内心承受了很大的煎熬，甚至还难过的流下了眼泪，但由于我在房间静静写《青少年祈祷》等待孩子起床，七点半多一点孩子起床了，吃了早餐，我们在七点四十从家里出发了，刚走时，我给数学老师发了信息，我说孩子可能会迟到15分钟左右，希望老师多多包涵。很快老师回答没关系。他理解！多么通情达理的老师，多么有爱的老师，上次让老师等
    
                    
    • 
                    
  • 2018-05-12 星期六 晴
                        小鱼家的幸福生活

                        
    音乐一直伴随着我们家，这不午饭后，我们一起听“国乐大典”节目，鑫田看到二胡的表演，禁不住找来两根塑料棍坐在沙饭上动情地模仿起来。这个动作一下子勾起了我对鑫田儿时的记忆。大概在她两岁左右时，她偶尔看到二胡表演后，便跑到厨房拿来两根筷子，然后坐在小板凳上，左手拿着一根筷子竖在左腿上，右手拿着另一根筷子在左边的筷子上做出来回拉锯的动作。那时候，鑫田还让全家一起用筷子模仿各种乐器的演奏，拉小提琴，打架子鼓
    
                    
    • 
                    
  • 2018-05-12 Caffe Makefile.config
                        七点水Plus

                        
    Makefile.configCUDA9.1cuDNN7.1.3OpenCV3.3.0Python2.7##Refertohttp://caffe.berkeleyvision.org/installation.html#Contributionssimplifyingandimprovingourbuildsystemarewelcome!#cuDNNaccelerationswitch(unc
    
                    
    • 
                    
  • 2018-05-12
                        82向日葵

                        
    冯丽焦点网络中级七期息县坚持分享第334天这个世界就是一面镜子，你展现了什么面貌给它，他就会用什么样的面貌来还给你。当你看到别人的好，其实你自己也具有这方面的特点，同样，你看到别人的不好，就去投掷负面能量给他，那么这个负面能量也会反射回到自己身上。所以，当我们想去批判别人的时候，就要注意这一点了。面有心生，其实就是你看到的时常都是好的，正向的，那内心就更加的平和安静，不仅利于身体健康，面相也更加的
    
                    
    • 
                    
  • 2018-05-12修改博文
                        陈艳芳_育儿及修行成长

                        
    前几句：这封信，本质上就是古代的“策论”。（用大众不太了解的词汇。1引发读者的好奇，期望往下继续看。2凸显文章的重要价值。从而引起读者对作者和文章的重视。）如同“隆中对”一样，是对国家未来局势的判断和谋划。（以诸葛亮自比为后面做铺垫。1虽然自己是被动方，希望得到帮助，但不失尊严——不是我要求你，是你需要我。2用暗示的方法让潜在的帮助者产生一种荣幸——所帮的人不简单。）这封信的内容，将影响一大批人的
    
                    
    • 
                    
  • 2018-05-12
                        乾立风中

                        
    今日看到大家热衷学习，喜欢学习，并且公司给了我们学习进步的机会，要做好细节工作，让客户满意，让自己进步。图片发自App
    
                    
    • 
                    
  • 2018-05-12
                        xiebo

                        
    今日体验：梳理好库房工作流程，注重细节！好的流程会让工作更加轻松，也不容易出错！核心：干好库房，总结流程很重要！
    
                    
    • 
                    
  • 2018-05-12
                        灼灼2015

                        
    听一晚的怀旧歌却不知道怀念谁十年过往缺了好长一段像是一夜无梦的觉和你从白天聊到晚上谈理想也谈家常秒回不算是默契跳跃的输入框写不出内心灯光闪烁照亮黑的夜但不管在哪里请和我联络
    
                    
    • 
                    
  • 2018-05-12注意力在自己能力成长
                        法雲

                        
    有空发现别人不好，说明你的注意力应该放在提升能力上。见不得别人好——见不得别人的好。盲目情绪讨厌——注意到优缺点，选择学习和避免。见不得别人好会形成思考习惯。永远盲目，讨厌别人成功，你不好我好的状态，杀死元认知。如何达到你好我也好的状态？心平气和的看待别人的好？不仅是心态。核心市自己能力达到某普遍承认程度后才会。所以，要看到别人的好，心平气和欣赏他人，达到你好我好世界美好，的境界。你需要提升自己。
    
                    
    • 
                    
  • 2018-05-12感恩日记
                        Mr玉民

                        
    12天，好像走了很久，从一个决定离开，到一个决定开始，一去一来，自己安静了很多。回想了最近的路，也梳理了很长一段时间的路，与自己进行了一次全面分享和对话，感受到了人生最难的其实是：认识你自己。幸运的是我并不孤单，因为有一群内心纯粹的人围绕在我的周围，他们懂得付出、懂得自省，在你感觉累的时候，总是能够以不同的方式启发和温暖你。投降、接受、听话、照做，仿佛指引我又到了一个崭新的天地。我感受到了一盏明灯
    
                    
    • 
                    
  • 2018-05-12
                        躲在房间里的一缕阳光

                        
    刚打开新概念英语3的书。第一课就有不认识的单词心情顿时沉重了起来还想着上外突然觉得离梦想又远了一些……
    
                    
    • 
                    
  • 2018-05-12
                        薛定谔的甲壳虫

                        
    1、曾经的我们，年少轻狂，指点江山，对3-5k的月薪嗤之以鼻，对10w以内的车不屑一顾。总觉的不久的将来，自己会有惊天动地的举动，创造不可企及的成就。随着岁月的磨炼，渐渐的步入社会，经过自己的兢兢业业工作，勤勤恳恳的努力，终于活成了自己当初讨厌的那一类人，活成了那个当初最不想成为的自己。2、经常听到一句话:别把平台当做你的能力。对于这句话的正确与否，暂不评论。但同样学识，背景，能力的两个人却因在不
    
                    
    • 
                    
  • 2018-05-12
                        汪熙宸

                        
    图片发自App早上一起户外瑜伽，大家都很棒哦，就是有点晒！感觉非常好。店长说今天自由要资源，上午还好紧张的，努力了一下午庆幸自己还是完成了！晚上集合的时候店长居然给我们准备了母亲节礼物，这是我第一次收到母亲节礼物！太贴心了，店长、谢谢，爱你么么哒图片发自App
    
                    
    • 
                    
  • 2018-05-12
                        数豆者m

                        
    “低调做人”，是指为人要谦逊，心态要平和，不张扬、不炫耀，进退有度。所谓“木秀于林，风必摧之”，在树林里，一棵树长得太突出了，远远高于其它的树木，那么大风刮来时，必定是最容易折断的。一个人有才能却不懂得收敛，恃才傲物、我行我素的话，也最容易招致他人的嫉妒和指责。
    
                    
    • 
                    
  • 2018-05-12
                        清秋致远

                        
    母亲节投稿原创首发渴望作者/清秋致远小时候妈妈就不在了听说妈妈去了很远很远的地方那时还不知道很远有多远一颗幻想的心豁然开朗想去很远的地方看一看妈妈的模样爸爸说妈妈去了天堂我就想天堂一定在天上妈妈和星星月亮在一起一定很高尚我不记得妈妈长什么样只是在梦里晃动着一首歌谣那歌谣的曲调是妈妈的目光我在目光里奔跑被枕着的河流绊倒我离开了妈妈的视线从此就再也没有看见那双烟雨迷蒙的眼
    
                    
    • 
                    
  • 2018-05-12
                        成就最好的自己

                        
    肖伟【日精进打卡第21天】【知～学习】《六项精进》读背3遍，共53遍《大学》开篇读背5遍，共49遍《大学》第二节读0遍，共1遍。《大学》第三四节读1遍，共1遍。••••••【经典名句分享】苟日新，日日新，有日新。【行～实践】一、修身：晨跑2公里二、齐家：和家人视频，聆听妻子两天学习的收获，帮她分析自己的收获。三、积善：发愿从2018年4月22日起，10年，日行1善。今日1善，累计27善。【省～觉悟
    
                    
    • 
                    
  • 2018-05-12 spinner dropdown
                        Mylovesunshine

                        
    //说明android:spinnerMode="dropdown"android:overlapAnchor="false"设置下拉在下边//ArrayAdapteradapter=newArrayAdapter(this,R.layout.simple_spinner_item,status);布局adapter.setDropDownViewResource(R.layout.simple_
    
                    
    • 
                    
  • 2018-05-12
                        我心依旧_79e2

                        
    2018-5-12姓名：陈岗企业名称：上海孚因流体动力设备股份有限公司打卡第20天【知~学习】《六项精进》3遍,共60遍《大学》3遍，共60遍【经典名句分】诚实是块板子，坦率是另一块板子，这两块板子可以夹的你很直。【行~实践】一、修身：（对自己个人）1每天坚持诵读《六项精进》和《大学》。2学会宽恕他人，同时从错误中吸取教训。二、齐家：（对家庭和家人）1经常和家人沟通。{积善}：发愿从2018年4月
    
                    
    • 
                    
  • 2018-05-12
                        英子丫头

                        
    在憎恨之处播种爱,在伤痛之处播种宽恕,在怀疑之处播种信任,在绝望之处播种希望,在黑暗之处播种光明,在悲伤之处播种喜悦.我不企求人的安慰,但求安慰他人,我不企求他人的谅解,只求谅解他人;我不企求他人爱护,只求爱护他人;因为;在给予他人时,我们便得到施予;在宽恕他人时,我们便获得赦免.
    
                    
    • 
                    
  • 2018-05-12
                        如果没有明天会怎样

                        
    仔细想了想，这么多年一个人无知无畏的扛了这么多年，不懂事的时候也明白自己过得辛苦，一直强压和忽视自己内心的感受，宽慰自己：再扛扛，说不定前面有美好的事情等着我，到现在，也许是等太久心灰意冷了，也许是自己变脆弱了，我觉得我可能注定是个悲剧的主角，不会有美好的人或者事物等着我了，可能等我死了，这本书就结尾了，也算功德圆满了
    
                    
    • 
                                
  • sql统计相同项个数并按名次显示
                                    朱辉辉33
javaoracle
                                    
    现在有如下这样一个表： 
A表 
ID Name time 
------------------------------ 
0001 aaa 2006-11-18 
0002 ccc 2006-11-18 
0003 eee 2006-11-18 
0004 aaa 2006-11-18 
0005 eee 2006-11-18 
0004 aaa 2006-11-18 
0002 ccc 20
    
                                
    • 
                                
  • Android+Jquery Mobile学习系列-目录
                                    白糖_
JQuery Mobile
                                    
    最近在研究学习基于Android的移动应用开发，准备给家里人做一个应用程序用用。向公司手机移动团队咨询了下，觉得使用Android的WebView上手最快，因为WebView等于是一个内置浏览器，可以基于html页面开发，不用去学习Android自带的七七八八的控件。然后加上Jquery mobile的样式渲染和事件等，就能非常方便的做动态应用了。 
  
从现在起，往后一段时间，我打算
    
                                
    • 
                                
  • 如何给线程池命名
                                    daysinsun
线程池
                                    
            在系统运行后，在线程快照里总是看到线程池的名字为pool-xx，这样导致很不好定位，怎么给线程池一个有意义的名字呢。参照ThreadPoolExecutor类的ThreadFactory，自己实现ThreadFactory接口，重写newThread方法即可。参考代码如下： 
    
public class Named
    
                                
    • 
                                
  • IE 中"HTML Parsing Error:Unable to modify the parent container element before the
                                    周凡杨
html解析errorreadyState
                                    
      
错误：  IE   中"HTML Parsing Error:Unable to modify the parent container element before the child element is closed"      
  
  
现象：  同事之间几个IE 测试情况下，有的报这个错，有的不报。经查询资料后，可归纳以下原因。
    
                                
    • 
                                
  • java上传
                                    g21121
java
                                    
    我们在做web项目中通常会遇到上传文件的情况，用struts等框架的会直接用的自带的标签和组件，今天说的是利用servlet来完成上传。 
我们这里利用到commons-fileupload组件，相关jar包可以取apache官网下载：http://commons.apache.org/ 
下面是servlet的代码： 
//定义一个磁盘文件工厂
DiskFileItemFactory fact
    
                                
    • 
                                
  • SpringMVC配置学习
                                    510888780
springmvc
                                    
    spring MVC配置详解 
现在主流的Web MVC框架除了Struts这个主力 外，其次就是Spring MVC了，因此这也是作为一名程序员需要掌握的主流框架，框架选择多了，应对多变的需求和业务时，可实行的方案自然就多了。不过要想灵活运用Spring MVC来应对大多数的Web开发，就必须要掌握它的配置及原理。 
 
　　一、Spring MVC环境搭建：（Spring 2.5.6 + Hi
    
                                
    • 
                                
  • spring mvc-jfreeChart 柱图(1)
                                    布衣凌宇
jfreechart
                                    
    第一步：下载jfreeChart包，注意是jfreeChart文件lib目录下的，jcommon-1.0.23.jar和jfreechart-1.0.19.jar两个包即可； 
第二步：配置web.xml; 
web.xml代码如下 
<servlet> 
    <servlet-name>jfreechart</servlet-nam
    
                                
    • 
                                
  • 我的spring学习笔记13-容器扩展点之PropertyPlaceholderConfigurer
                                    aijuans
Spring3
                                    
    PropertyPlaceholderConfigurer是个bean工厂后置处理器的实现，也就是BeanFactoryPostProcessor接口的一个实现。关于BeanFactoryPostProcessor和BeanPostProcessor类似。我会在其他地方介绍。PropertyPlaceholderConfigurer可以将上下文（配置文件）中的属性值放在另一个单独的标准java P
    
                                
    • 
                                
  • java 线程池使用 Runnable&Callable&Future
                                    antlove
javathreadRunnablecallablefuture
                                    
    1. 创建线程池 
ExecutorService executorService = Executors.newCachedThreadPool(); 
  
2. 执行一次线程，调用Runnable接口实现 
Future<?> future = executorService.submit(new DefaultRunnable());
System.out.prin
    
                                
    • 
                                
  • XML语法元素结构的总结
                                    百合不是茶
xml树结构
                                    
    1.XML介绍1969年   gml (主要目的是要在不同的机器进行通信的数据规范)1985年   sgml  standard generralized markup language1993年   html(www网)1998年  xml   extensible markup language
    
                                
    • 
                                
  • 改变eclipse编码格式
                                    bijian1013
eclipse编码格式
                                    
    1.改变整个工作空间的编码格式 
        改变整个工作空间的编码格式，这样以后新建的文件也是新设置的编码格式。 
        Eclipse->window->preferences->General->workspace-
    
                                
    • 
                                
  • javascript中return的设计缺陷
                                    bijian1013
JavaScriptAngularJS
                                    
    代码1： 
<script>
var gisService = (function(window) 
{ 

    return
    {
        name:function ()
        {
            alert(1);
        }
    };

})(this);

gisService.name();
&l
    
                                
    • 
                                
  • 【持久化框架MyBatis3八】Spring集成MyBatis3
                                    bit1129
Mybatis3
                                    
    pom.xml配置 
Maven的pom中主要包括： 
 
 MyBatis 
 MyBatis-Spring 
 Spring 
 MySQL-Connector-Java 
 Druid 
 applicationContext.xml配置     
<?xml version="1.0" encoding="UTF-8"?>
&
    
                                
    • 
                                
  • java web项目启动时自动加载自定义properties文件
                                    bitray
javaWeb监听器相对路径
                                    
    创建一个类 
public class ContextInitListener implements ServletContextListener 
使得该类成为一个监听器。用于监听整个容器生命周期的，主要是初始化和销毁的。 
 
类创建后要在web.xml配置文件中增加一个简单的监听器配置，即刚才我们定义的类。 
 

    <listener>
        <des
    
                                
    • 
                                
  • 用nginx区分文件大小做出不同响应
                                    ronin47

                                    
    昨晚和前21v的同事聊天，说到我离职后一些技术上的更新。其中有个给某大客户(游戏下载类)的特殊需求设计，因为文件大小差距很大——估计是大版本和补丁的区别——又走的是同一个域名，而squid在响应比较大的文件时，尤其是初次下载的时候，性能比较差，所以拆成两组服务器，squid服务于较小的文件，通过pull方式从peer层获取，nginx服务于较大的文件，通过push方式由peer层分发同步。外部发布
    
                                
    • 
                                
  • java-67-扑克牌的顺子.从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的.2-10为数字本身，A为1，J为11，Q为12，K为13，而大
                                    bylijinnan
java
                                    
    package com.ljn.base;

import java.util.Arrays;
import java.util.Random;

public class ContinuousPoker {

    /**
     * Q67 扑克牌的顺子 从扑克牌中随机抽5张牌，判断是不是一个顺子，即这5张牌是不是连续的。
     * 2-10为数字本身，A为1，J为1
    
                                
    • 
                                
  • 翟鸿燊老师语录
                                    ccii
翟鸿燊
                                    
    一、国学应用智慧TAT之亮剑精神A 
1. 角色就是人格 
    就像你一回家的时候，你一进屋里面，你已经是儿子，是姑娘啦，给老爸老妈倒怀水吧，你还觉得你是老总呢？还拿派呢？就像今天一样，你们往这儿一坐，你们之间是什么，同学，是朋友。 
    还有下属最忌讳的就是领导向他询问情况的时候，什么我不知道，我不清楚，该你知道的你凭什么不知道
    
                                
    • 
                                
  • [光速与宇宙]进行光速飞行的一些问题
                                    comsci
问题
                                    
     
 
     在人类整体进入宇宙时代，即将开展深空宇宙探索之前，我有几个猜想想告诉大家 
    仅仅是猜想。。。未经官方证实 
 
 
     1：要在宇宙中进行光速飞行，必须首先获得宇宙中的航行通行证，而这个航行通行证并不是我们平常认为的那种带钢印的证书，是什么呢？ 下面我来告诉
    
                                
    • 
                                
  • oracle undo解析
                                    cwqcwqmax9
oracle
                                    
    oracle undo解析2012-09-24 09:02:01     我来说两句       作者：虫师收藏    我要投稿 
 
Undo是干嘛用的？         &nb
    
                                
    • 
                                
  • java中各种集合的详细介绍
                                    dashuaifu
java集合
                                    
    一，java中各种集合的关系图 Collection       接口的接口     对象的集合  ├ List           子接口   &n
    
                                
    • 
                                
  • 卸载windows服务的方法
                                    dcj3sjt126com
windowsservice
                                    
    卸载Windows服务的方法 
在Windows中，有一类程序称为服务，在操作系统内核加载完成后就开始加载。这里程序往往运行在操作系统的底层，因此资源占用比较大、执行效率比较高，比较有代表性的就是杀毒软件。但是一旦因为特殊原因不能正确卸载这些程序了，其加载在Windows内的服务就不容易删除了。即便是删除注册表中的相 应项目，虽然不启动了，但是系统中仍然存在此项服务，只是没有加载而已。如果安装其他
    
                                
    • 
                                
  • Warning: The Copy Bundle Resources build phase contains this target's Info.plist
                                    dcj3sjt126com
iosxcode
                                    
           
      
http://developer.apple.com/iphone/library/qa/qa2009/qa1649.html 
Excerpt: 
 
 You are getting this warning because you probably added your Info.plist file to your Copy Bundle 
    
                                
    • 
                                
  • 2014之C++学习笔记（一）
                                    Etwo
C++EtwoEtwoiterator迭代器
                                    
            已经有很长一段时间没有写博客了，可能大家已经淡忘了Etwo这个人的存在，这一年多以来，本人从事了AS的相关开发工作，但最近一段时间，AS在天朝的没落，相信有很多码农也都清楚，现在的页游基本上达到饱和，手机上的游戏基本被unity3D与cocos占据，AS基本没有容身之处。so。。。最近我并不打算直接转型
    
                                
    • 
                                
  • js跨越获取数据问题记录
                                    haifengwuch
jsonpjsonAjax
                                    
    js的跨越问题，普通的ajax无法获取服务器返回的值。 
 
  第一种解决方案，通过getson，后台配合方式，实现。 
Java后台代码： 
protected void doPost(HttpServletRequest req, HttpServletResponse resp) 
throws ServletException, IOException { 
String ca
    
                                
    • 
                                
  • 蓝色jQuery导航条
                                    ini
JavaScripthtmljqueryWebhtml5
                                    
    效果体验：http://keleyi.com/keleyi/phtml/jqtexiao/39.htmHTML文件代码： 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>jQuery鼠标悬停上下滑动导航条 - 柯乐义<
    
                                
    • 
                                
  • linux部署jdk,tomcat,mysql
                                    kerryg
jdktomcatlinuxmysql
                                    
    1、安装java环境jdk: 
    一般系统都会默认自带的JDK,但是不太好用，都会卸载了，然后重新安装。 
   1.1）、卸载： 
     （rpm -qa :查询已经安装哪些软件包； 
       rmp -q 软件包：查询指定包是否已
    
                                
    • 
                                
  • DOMContentLoaded VS onload VS onreadystatechange
                                    mutongwu
jqueryjs
                                    
    1. DOMContentLoaded 在页面html、script、style加载完毕即可触发，无需等待所有资源（image/iframe）加载完毕。（IE9+） 
 
2. onload是最早支持的事件，要求所有资源加载完毕触发。 
 
3. onreadystatechange 开始在IE引入，后来其它浏览器也有一定的实现。涉及以下 document , applet, embed, fra
    
                                
    • 
                                
  • sql批量插入数据
                                    qifeifei
批量插入
                                    
    hi， 
  自己在做工程的时候，遇到批量插入数据的数据修复场景。我的思路是在插入前准备一个临时表，临时表的整理就看当时的选择条件了，临时表就是要插入的数据集，最后再批量插入到数据库中。 
   
WITH tempT AS (
SELECT
item_id AS combo_id,
item_id,
now() AS create_date
FROM
a
    
                                
    • 
                                
  • log4j打印日志文件 如何实现相对路径到 项目工程下
                                    thinkfreer
Weblog4j应用服务器日志
                                    
    最近为了实现统计一个网站的访问量，记录用户的登录信息，以方便站长实时了解自己网站的访问情况，选择了Apache 的log4j,但是在选择相对路径那块 卡主了，X度了好多方法(其实大多都是一样的内用，还一个字都不差的)，都没有能解决问题，无奈搞了2天终于解决了，与大家分享一下 
 
 
需求： 
用户登录该网站时，把用户的登录名,ip,时间。统计到一个txt文档里，以方便其他系统调用此txt。项目名
    
                                
    • 
                                
  • linux下mysql-5.6.23.tar.gz安装与配置
                                    笑我痴狂
mysqllinuxunix
                                    
    1.卸载系统默认的mysql 
 
[root@localhost ~]# rpm -qa | grep mysql 
mysql-libs-5.1.66-2.el6_3.x86_64
mysql-devel-5.1.66-2.el6_3.x86_64
mysql-5.1.66-2.el6_3.x86_64
[root@localhost ~]# rpm -e mysql-libs-5.1
    
                                
    •