测试狗一枚
测试狗一枚

Spring框架—SpringBean加载过程

原文作者：RunAlgorithm

原文地址：图文并茂，揭秘 Spring 的 Bean 的加载过程

 

1. 概述

Spring 作为 Ioc 框架，实现了依赖注入，由一个中心化的 Bean 工厂来负责各个 Bean 的实例化和依赖管理。各个 Bean 可以不需要关心各自的复杂的创建过程，达到了很好的解耦效果。我们对 Spring 的工作流进行一个粗略的概括，主要为两大环节：

  • 解析：读 xml 配置，扫描类文件，从配置或者注解中获取 Bean 的定义信息，注册一些扩展功能。
  • 加载：通过解析完的定义信息获取 Bean 实例。
Spring框架—SpringBean加载过程_第1张图片 Spring总体流程

 

我们假设所有的配置和扩展类都已经装载到了 ApplicationContext 中，然后具体的分析一下 Bean 的加载流程。思考一个问题，抛开 Spring 框架的实现，假设我们手头上已经有一套完整的 Bean Definition Map，然后指定一个 beanName 要进行实例化，需要关心什么？即使我们没有 Spring 框架，也需要了解这两方面的知识：

  • 作用域：单例作用域或者原型作用域，单例的话需要全局实例化一次，原型每次创建都需要重新实例化。
  • 依赖关系：一个 Bean 如果有依赖，我们需要初始化依赖，然后进行关联。如果多个 Bean 之间存在着循环依赖，A 依赖 B，B 依赖 C，C 又依赖 A，需要解这种循环依赖问题。

Spring 进行了抽象和封装，使得作用域和依赖关系的配置对开发者透明，我们只需要知道当初在配置里已经明确指定了它的生命周期和依赖了谁，至于是怎么实现的，依赖如何注入，托付给了 Spring 工厂来管理。Spring 只暴露了很简单的接口给调用者，比如 getBean ：

ApplicationContext context = new ClassPathXmlApplicationContext("hello.xml");
HelloBean helloBean = (HelloBean) context.getBean("hello");
helloBean.sayHello();

那我们就从 getBean 方法作为入口，去理解 Spring 加载的流程是怎样的，以及内部对创建信息、作用域、依赖关系等等的处理细节。

2. 总体流程

 

Spring框架—SpringBean加载过程_第2张图片 Bean 加载流程图

上面是跟踪了 getBean 的调用链创建的流程图，为了能够很好地理解 Bean 加载流程，省略一些异常、日志和分支处理和一些特殊条件的判断。从上面的流程图中，可以看到一个 Bean 加载会经历这么几个阶段（用绿色标记）：

  • 获取 BeanName：对传入的 name 进行解析，转化为可以从 Map 中获取到 BeanDefinition 的 bean name。
  • 合并 Bean 定义：对父类的定义进行合并和覆盖，如果父类还有父类，会进行递归合并，以获取完整的 Bean 定义信息。
  • 实例化：使用构造或者工厂方法创建 Bean 实例。
  • 属性填充：寻找并且注入依赖，依赖的 Bean 还会递归调用 getBean 方法获取。
  • 初始化：调用自定义的初始化方法。
  • 获取最终的 Bean：如果是 FactoryBean 需要调用 getObject 方法，如果需要类型转换调用 TypeConverter 进行转化。

整个流程最为复杂的是对循环依赖的解决方案，后续会进行重点分析。

3. 细节分析

3.1. 转化 BeanName

而在我们解析完配置后创建的 Map，使用的是 beanName 作为 key。见 DefaultListableBeanFactory：

/** Map of bean definition objects, keyed by bean name */
private final Map beanDefinitionMap = new ConcurrentHashMap(256);

BeanFactory.getBean 中传入的 name，有可能是这几种情况：

  • bean name：可以直接获取到定义 BeanDefinition。
  • alias name：别名，需要转化。
  • factorybean name： 带 & 前缀，通过它获取 BeanDefinition 的时候需要去除 & 前缀。

为了能够获取到正确的 BeanDefinition，需要先对 name 做一个转换，得到 beanName。

Spring框架—SpringBean加载过程_第3张图片 name转beanName

 

 

见 AbstractBeanFactory.doGetBean：

protected  T doGetBean ... {
    ...
    
    // 转化工作 
    final String beanName = transformedBeanName(name);
    ...
}

如果是 alias name，在解析阶段，alias name 和 bean name 的映射关系被注册到 SimpleAliasRegistry 中。从该注册器中取到 beanName。见 SimpleAliasRegistry.canonicalName：

public String canonicalName(String name) {
    ...
    resolvedName = this.aliasMap.get(canonicalName);
    ...
}

如果是 factorybean name，表示这是个工厂 bean，有携带前缀修饰符 & 的，直接把前缀去掉。见 BeanFactoryUtils.transformedBeanName :

public static String transformedBeanName(String name) {
    Assert.notNull(name, "'name' must not be null");
    String beanName = name;
    while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
        beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
    }
    return beanName;
}

3.2. 合并 RootBeanDefinition

我们从配置文件读取到的 BeanDefinition 是 GenericBeanDefinition。它记录了一些当前类声明的属性或构造参数，但是对于父类只用了一个 parentName 来记录。

public class GenericBeanDefinition extends AbstractBeanDefinition {
    ...
    private String parentName;
    ...
}

接下来会发现一个问题，在后续实例化 Bean 的时候，使用的 BeanDefinition 是 RootBeanDefinition 类型而非 GenericBeanDefinition。这是为什么？答案很明显，GenericBeanDefinition 在有继承关系的情况下，定义的信息不足：

  • 如果不存在继承关系，GenericBeanDefinition 存储的信息是完整的，可以直接转化为 RootBeanDefinition。
  • 如果存在继承关系，GenericBeanDefinition 存储的是 增量信息 而不是 全量信息。

为了能够正确初始化对象，需要完整的信息才行。需要递归 合并父类的定义：

Spring框架—SpringBean加载过程_第4张图片 合并BeanDefinition

 

见 AbstractBeanFactory.doGetBean ：

protected  T doGetBean ... {
    ...
    
    // 合并父类定义
    final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        
    ...
        
    // 使用合并后的定义进行实例化
    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
        
    ...
}

在判断 parentName 存在的情况下，说明存在父类定义，启动合并。如果父类还有父类怎么办？递归调用，继续合并。见AbstractBeanFactory.getMergedBeanDefinition 方法：

    protected RootBeanDefinition getMergedBeanDefinition(
            String beanName, BeanDefinition bd, BeanDefinition containingBd)
            throws BeanDefinitionStoreException {

        ...
        
        String parentBeanName = transformedBeanName(bd.getParentName());

        ...
        
        // 递归调用，继续合并父类定义
        pbd = getMergedBeanDefinition(parentBeanName);
        
        ...

        // 使用合并后的完整定义，创建 RootBeanDefinition
        mbd = new RootBeanDefinition(pbd);
        
        // 使用当前定义，对 RootBeanDefinition 进行覆盖
        mbd.overrideFrom(bd);

        ...
        return mbd;
    
    }

每次合并完父类定义后，都会调用 RootBeanDefinition.overrideFrom 对父类的定义进行覆盖，获取到当前类能够正确实例化的 全量信息。

3.3. 处理循环依赖

什么是循环依赖？举个例子，这里有三个类 A、B、C，然后 A 关联 B，B 关联 C，C 又关联 A，这就形成了一个循环依赖。如果是方法调用是不算循环依赖的，循环依赖必须要持有引用。

Spring框架—SpringBean加载过程_第5张图片 循环依赖

 

循环依赖根据注入的时机分成两种类型：

  • 构造器循环依赖：依赖的对象是通过构造器传入的，发生在实例化 Bean 的时候。这种依赖本质上是无法解决的。比如我们准调用 A 的构造器，发现依赖 B，于是去调用 B 的构造器进行实例化，发现又依赖 C，于是调用 C 的构造器去初始化，结果依赖 A，整个形成一个死结，导致 A 无法创建。
  • 设值循环依赖：依赖的对象是通过 setter 方法传入的，对象已经实例化，发生属性填充和依赖注入的时候。Spring 框架只支持单例下的设值循环依赖。Spring 通过对还在创建过程中的单例，缓存并提前暴露该单例，使得其他实例可以引用该依赖。

3.3.1. 原型模式的循环依赖

Spring 不支持原型模式的任何循环依赖。检测到循环依赖会直接抛出 BeanCurrentlyInCreationException 异常。使用了一个 ThreadLocal 变量 prototypesCurrentlyInCreation 来记录当前线程正在创建中的 Bean 对象，见 AbtractBeanFactory#prototypesCurrentlyInCreation：

/** Names of beans that are currently in creation */
private final ThreadLocal prototypesCurrentlyInCreation =
            new NamedThreadLocal("Prototype beans currently in creation");
 
  
在 Bean 创建前进行记录，在 Bean 创建后删除记录。见 AbstractBeanFactory.doGetBean：
 
  
...
if (mbd.isPrototype()) {
    // It's a prototype -> create a new instance.
    Object prototypeInstance = null;
    try {
    
        // 添加记录
        beforePrototypeCreation(beanName);
        prototypeInstance = createBean(beanName, mbd, args);
    }
    finally {
        // 删除记录
        afterPrototypeCreation(beanName);
    }
    bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
}
...     

 
  
见 AbtractBeanFactory.beforePrototypeCreation 的记录操作：
 
  
    protected void beforePrototypeCreation(String beanName) {
        Object curVal = this.prototypesCurrentlyInCreation.get();
        if (curVal == null) {
            this.prototypesCurrentlyInCreation.set(beanName);
        }
        else if (curVal instanceof String) {
            Set beanNameSet = new HashSet(2);
            beanNameSet.add((String) curVal);
            beanNameSet.add(beanName);
            this.prototypesCurrentlyInCreation.set(beanNameSet);
        }
        else {
            Set beanNameSet = (Set) curVal;
            beanNameSet.add(beanName);
        }
    }

 
  
见 AbtractBeanFactory.beforePrototypeCreation 的删除操作：
 
  
    protected void afterPrototypeCreation(String beanName) {
        Object curVal = this.prototypesCurrentlyInCreation.get();
        if (curVal instanceof String) {
            this.prototypesCurrentlyInCreation.remove();
        }
        else if (curVal instanceof Set) {
            Set beanNameSet = (Set) curVal;
            beanNameSet.remove(beanName);
            if (beanNameSet.isEmpty()) {
                this.prototypesCurrentlyInCreation.remove();
            }
        }
    }

 
  
为了节省内存空间，在单个元素时 prototypesCurrentlyInCreation 只记录 String 对象，在多个依赖元素后改用 Set 集合。这里是 Spring 使用的一个节约内存的小技巧。了解了记录的写入和删除过程好了，再来看看读取以及判断循环的方式。这里要分两种情况讨论。
 
  
     
   
  • 构造函数循环依赖。
    •  
   
  • 设置循环依赖。
    •  
  
 
  
这两个地方的实现略有不同。如果是构造函数依赖的，比如 A 的构造函数依赖了 B，会有这样的情况。实例化 A 的阶段中，匹配到要使用的构造函数，发现构造函数有参数 B，会使用 BeanDefinitionValueResolver 来检索 B 的实例。见 BeanDefinitionValueResolver.resolveReference：
 
  
private Object resolveReference(Object argName, RuntimeBeanReference ref) {

    ...
    Object bean = this.beanFactory.getBean(refName);
    ...
}

 
  
我们发现这里继续调用 beanFactory.getBean 去加载 B。如果是设值循环依赖的的，比如我们这里不提供构造函数，并且使用了 @Autowire 的方式注解依赖（还有其他方式不举例了）：
 
  
public class A {
    @Autowired
    private B b;
    ...
}

 
  
加载过程中，找到无参数构造函数，不需要检索构造参数的引用，实例化成功。接着执行下去，进入到属性填充阶段 AbtractBeanFactory.populateBean ，在这里会进行 B 的依赖注入。为了能够获取到 B 的实例化后的引用，最终会通过检索类 DependencyDescriptor 中去把依赖读取出来，见 DependencyDescriptor.resolveCandidate ：
 
  
public Object resolveCandidate(String beanName, Class requiredType, BeanFactory beanFactory)
            throws BeansException {
    return beanFactory.getBean(beanName, requiredType);
}

 
  
发现 beanFactory.getBean 方法又被调用到了。在这里，两种循环依赖达成了同一。无论是构造函数的循环依赖还是设置循环依赖，在需要注入依赖的对象时，会继续调用 beanFactory.getBean 去加载对象，形成一个递归操作。而每次调用 beanFactory.getBean 进行实例化前后，都使用了 prototypesCurrentlyInCreation 这个变量做记录。按照这里的思路走，整体效果等同于 建立依赖对象的构造链。prototypesCurrentlyInCreation 中的值的变化如下：
 
  Spring框架—SpringBean加载过程_第6张图片 原型模式的循环依赖 
  
 
 
  
调用判定的地方在 AbstractBeanFactory.doGetBean 中，所有对象的实例化均会从这里启动。
 
  
// Fail if we're already creating this bean instance:
// We're assumably within a circular reference.
if (isPrototypeCurrentlyInCreation(beanName)) {
    throw new BeanCurrentlyInCreationException(beanName);
}

 
  
判定的实现方法为 AbstractBeanFactory.isPrototypeCurrentlyInCreation ：
 
  
protected boolean isPrototypeCurrentlyInCreation(String beanName) {
    Object curVal = this.prototypesCurrentlyInCreation.get();
    return (curVal != null &&
        (curVal.equals(beanName) || (curVal instanceof Set && ((Set) curVal).contains(beanName))));
}

 
  
所以在原型模式下，构造函数循环依赖和设值循环依赖，本质上使用同一种方式检测出来。Spring 无法解决，直接抛出 BeanCurrentlyInCreationException 异常。
 
  
3.3.2. 单例模式的构造循环依赖
 
  
Spring 也不支持单例模式的构造循环依赖。检测到构造循环依赖也会抛出 BeanCurrentlyInCreationException 异常。和原型模式相似，单例模式也用了一个数据结构来记录正在创建中的 beanName。见 DefaultSingletonBeanRegistry:
 
  
/** Names of beans that are currently in creation */
private final Set singletonsCurrentlyInCreation =
            Collections.newSetFromMap(new ConcurrentHashMap(16));

 
  
会在创建前进行记录，创建化后删除记录。见 DefaultSingletonBeanRegistry.getSingleton
 
  
public Object getSingleton(String beanName, ObjectFactory singletonFactory) {
        ...
        
        // 记录正在加载中的 beanName
        beforeSingletonCreation(beanName);
        ...
        // 通过 singletonFactory 创建 bean
        singletonObject = singletonFactory.getObject();
        ...
        // 删除正在加载中的 beanName
        afterSingletonCreation(beanName);
        
}

 
  
记录和判定的方式见 DefaultSingletonBeanRegistry.beforeSingletonCreation ：
 
  
    protected void beforeSingletonCreation(String beanName) {
        if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

 
  
这里会尝试往 singletonsCurrentlyInCreation 记录当前实例化的 bean。我们知道 singletonsCurrentlyInCreation 的数据结构是 Set，是不允许重复元素的，所以一旦前面记录了，这里的 add 操作将会返回失败。比如加载 A 的单例，和原型模式类似，单例模式也会调用匹配到要使用的构造函数，发现构造函数有参数 B，然后使用 BeanDefinitionValueResolver 来检索 B 的实例，根据上面的分析，继续调用 beanFactory.getBean 方法。所以拿 A，B，C 的例子来举例 singletonsCurrentlyInCreation 的变化，这里可以看到和原型模式的循环依赖判断方式的算法是一样：
 
  Spring框架—SpringBean加载过程_第7张图片 单例模式的构造循环依赖 
  
 
 
  
     
   
  • 加载 A。记录 singletonsCurrentlyInCreation = [a]，构造依赖 B，开始加载 B。
    •  
   
  • 加载 B，记录 singletonsCurrentlyInCreation = [a, b]，构造依赖 C，开始加载 C。
    •  
   
  • 加载 C，记录 singletonsCurrentlyInCreation = [a, b, c]，构造依赖 A，又开始加载 A。
    •  
   
  • 加载 A，执行到 DefaultSingletonBeanRegistry.beforeSingletonCreation ，singletonsCurrentlyInCreation 中 a 已经存在了，检测到构造循环依赖，直接抛出异常结束操作。
    •  
  
 
  
3.3.3. 单例模式的设值循环依赖
 
  
单例模式下，构造函数的循环依赖无法解决，但设值循环依赖是可以解决的。这里有一个重要的设计：提前暴露创建中的单例。我们理解一下为什么要这么做。还是拿上面的 A、B、C 的的设值依赖做分析，
 
  
     
   
  • => 1. A 创建 -> A 构造完成，开始注入属性，发现依赖 B，启动 B 的实例化
    •  
   
  • => 2. B 创建 -> B 构造完成，开始注入属性，发现依赖 C，启动 C 的实例化
    •  
   
  • => 3. C 创建 -> C 构造完成，开始注入属性，发现依赖 A
    •  
  
 
  
重点来了，在我们的阶段 1中， A 已经构造完成，Bean 对象在堆中也分配好内存了，即使后续往 A 中填充属性（比如填充依赖的 B 对象），也不会修改到 A 的引用地址。所以，这个时候是否可以 提前拿 A 实例的引用来先注入到 C ，去完成 C 的实例化，于是流程变成这样。
 
  
     
   
  • => 3. C 创建 -> C 构造完成，开始注入依赖，发现依赖 A，发现 A 已经构造完成，直接引用，完成 C 的实例化。
    •  
   
  • => 4. C 完成实例化后，B 注入 C 也完成实例化，A 注入 B 也完成实例化。
    •  
  
 
  
这就是 Spring 解决单例模式设值循环依赖应用的技巧。流程图为：
 
  Spring框架—SpringBean加载过程_第8张图片 单例模式创建流程 
  
 
 
  
为了能够实现单例的提前暴露。Spring 使用了三级缓存，见 DefaultSingletonBeanRegistry：
 
  
/** Cache of singleton objects: bean name --> bean instance */
private final Map singletonObjects = new ConcurrentHashMap(256);

/** Cache of singleton factories: bean name --> ObjectFactory */
private final Map> singletonFactories = new HashMap>(16);

/** Cache of early singleton objects: bean name --> bean instance */
private final Map earlySingletonObjects = new HashMap(16);

 
  
这三个缓存的区别如下：
 
  
     
   
  • singletonObjects，单例缓存，存储已经实例化完成的单例。
    •  
   
  • singletonFactories，生产单例的工厂的缓存，存储工厂。
    •  
   
  • earlySingletonObjects，提前暴露的单例缓存，这时候的单例刚刚创建完，但还会注入依赖。
    •  
  
 
  
从 getBean("a") 开始，添加的 SingletonFactory 具体实现如下：
 
  
protected Object doCreateBean ...  {

    ...
    addSingletonFactory(beanName, new ObjectFactory() {
        @Override
        public Object getObject() throws BeansException {
            return getEarlyBeanReference(beanName, mbd, bean);
        }
    });
    ...
}
 
  
可以看到如果使用该 SingletonFactory 获取实例，使用的是 getEarlyBeanReference 方法，返回一个未初始化的引用。读取缓存的地方见 DefaultSingletonBeanRegistry :
 
  
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        synchronized (this.singletonObjects) {
            singletonObject = this.earlySingletonObjects.get(beanName);
            if (singletonObject == null && allowEarlyReference) {
                ObjectFactory singletonFactory = this.singletonFactories.get(beanName);
                if (singletonFactory != null) {
                    singletonObject = singletonFactory.getObject();
                    this.earlySingletonObjects.put(beanName, singletonObject);
                    this.singletonFactories.remove(beanName);
                }
            }
        }
    }
    return (singletonObject != NULL_OBJECT ? singletonObject : null);
}

 
  
先尝试从 singletonObjects 和 singletonFactory 读取，没有数据，然后尝试 singletonFactories 读取 singletonFactory，执行 getEarlyBeanReference 获取到引用后，存储到 earlySingletonObjects 中。这个 earlySingletonObjects 的好处是，如果此时又有其他地方尝试获取未初始化的单例，可以从 earlySingletonObjects 直接取出而不需要再调用 getEarlyBeanReference。从流程图上看，实际上注入 C 的 A 实例，还在填充属性阶段，并没有完全地初始化。等递归回溯回去，A 顺利拿到依赖 B，才会真实地完成 A 的加载。
 
  
3.4. 创建实例
 
  
获取到完整的 RootBeanDefintion 后，就可以拿这份定义信息来实例具体的 Bean。具体实例创建见 AbstractAutowireCapableBeanFactory.createBeanInstance ，返回 Bean 的包装类 BeanWrapper，一共有三种策略：
 
  
     
   
  • 使用工厂方法创建，instantiateUsingFactoryMethod 。
    •  
   
  • 使用有参构造函数创建，autowireConstructor。
    •  
   
  • 使用无参构造函数创建，instantiateBean。
    •  
  
 
  
使用工厂方法创建，会先使用 getBean 获取工厂类，然后通过参数找到匹配的工厂方法，调用实例化方法实现实例化，具体见ConstructorResolver.instantiateUsingFactoryMethod ：
 
  
public BeanWrapper instantiateUsingFactoryMethod ... (
    ...
    String factoryBeanName = mbd.getFactoryBeanName();
    ...
    factoryBean = this.beanFactory.getBean(factoryBeanName);
    ...
    // 匹配正确的工厂方法
    ...
    beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(...);
    ...
    bw.setBeanInstance(beanInstance);
    return bw;
}

 
  
使用有参构造函数创建，整个过程比较复杂，涉及到参数和构造器的匹配。为了找到匹配的构造器，Spring 花了大量的工作，见 ConstructorResolver.autowireConstructor ：
 
  
public BeanWrapper autowireConstructor ... {
    ...
    Constructor constructorToUse = null;
    ...
    // 匹配构造函数的过程
    ...
    beanInstance = this.beanFactory.getInstantiationStrategy().instantiate(...);
    ...
    bw.setBeanInstance(beanInstance);
    return bw;
}           

 
  
使用无参构造函数创建是最简单的方式，见 AbstractAutowireCapableBeanFactory.instantiateBean:
 
  
protected BeanWrapper instantiateBean ... {
    ...
    beanInstance = getInstantiationStrategy().instantiate(...);
    ...
    BeanWrapper bw = new BeanWrapperImpl(beanInstance);
    initBeanWrapper(bw);
    return bw;
    ...
}

 
  
我们发现这三个实例化方式，最后都会走 getInstantiationStrategy().instantiate(...)，见实现类 SimpleInstantiationStrategy.instantiate：
 
  
public Object instantiate ... {
    if (bd.getMethodOverrides().isEmpty()) {
        ...
        return BeanUtils.instantiateClass(constructorToUse);
    }
    else {
        // Must generate CGLIB subclass.
        return instantiateWithMethodInjection(bd, beanName, owner);
    }
}

 
  
虽然拿到了构造函数，并没有立即实例化。因为用户使用了 replace 和 lookup 的配置方法，用到了动态代理加入对应的逻辑。如果没有的话，直接使用反射来创建实例。创建实例后，就可以开始注入属性和初始化等操作。但这里的 Bean 还不是最终的 Bean。返回给调用方使用时，如果是 FactoryBean 的话需要使用 getObject 方法来创建实例。见 AbstractBeanFactory.getObjectFromBeanInstance ，会执行到 doGetObjectFromFactoryBean ：
 
  
private Object doGetObjectFromFactoryBean ... {
    ...
    object = factory.getObject();
    ...
    return object;
}

 
  
3.5. 注入属性
 
  
实例创建完后开始进行属性的注入，如果涉及到外部依赖的实例，会自动检索并关联到该当前实例。Ioc 思想体现出来了。正是有了这一步操作，Spring 降低了各个类之间的耦合。属性填充的入口方法在AbstractAutowireCapableBeanFactory.populateBean。
 
  
protected void populateBean ... {
    PropertyValues pvs = mbd.getPropertyValues();
    
    ...
    // InstantiationAwareBeanPostProcessor 前处理
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                continueWithPropertyPopulation = false;
                break;
            }
        }
    }
    ...
    
    // 根据名称注入
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {
        autowireByName(beanName, mbd, bw, newPvs);
    }

    // 根据类型注入
    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {
        autowireByType(beanName, mbd, bw, newPvs);
    }

    ... 
    // InstantiationAwareBeanPostProcessor 后处理
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof InstantiationAwareBeanPostProcessor) {
            InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
            pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvs == null) {
                return;
            }
        }
    }
    
    ...
    
    // 应用属性值
    applyPropertyValues(beanName, mbd, bw, pvs);
}

 
  
可以看到主要的处理环节有：
 
  
     
   
  • 应用 InstantiationAwareBeanPostProcessor 处理器，在属性注入前后进行处理。假设我们使用了 @Autowire 注解，这里会调用到 AutowiredAnnotationBeanPostProcessor 来对依赖的实例进行检索和注入的，它是 InstantiationAwareBeanPostProcessor 的子类。
    •  
   
  • 根据名称或者类型进行自动注入，存储结果到 PropertyValues 中。
    •  
   
  • 应用 PropertyValues，填充到 BeanWrapper。这里在检索依赖实例的引用的时候，会递归调用 BeanFactory.getBean 来获得。
    •  
  
 
  
3.6. 初始化
 
  
3.6.1. 触发 Aware
 
  
如果我们的 Bean 需要容器的一些资源该怎么办？比如需要获取到 BeanFactory、ApplicationContext 等等。Spring 提供了 Aware 系列接口来解决这个问题。比如有这样的 Aware：
 
  
     
   
  • BeanFactoryAware，用来获取 BeanFactory。
    •  
   
  • ApplicationContextAware，用来获取 ApplicationContext。
    •  
   
  • ResourceLoaderAware，用来获取 ResourceLoaderAware。
    •  
   
  • ServletContextAware，用来获取 ServletContext。
    •  
  
 
  
Spring 在初始化阶段，如果判断 Bean 实现了这几个接口之一，就会往 Bean 中注入它关心的资源。见 AbstractAutowireCapableBeanFactory.invokeAwareMethos :
 
  
private void invokeAwareMethods(final String beanName, final Object bean) {
    if (bean instanceof Aware) {
        if (bean instanceof BeanNameAware) {
            ((BeanNameAware) bean).setBeanName(beanName);
        }
        if (bean instanceof BeanClassLoaderAware) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
        }
        if (bean instanceof BeanFactoryAware) {
            ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
        }
    }
}

 
  
3.6.2. 触发 BeanPostProcessor
 
  
在 Bean 的初始化前或者初始化后，我们如果需要进行一些增强操作怎么办？这些增强操作比如打日志、做校验、属性修改、耗时检测等等。Spring 框架提供了 BeanPostProcessor 来达成这个目标。比如我们使用注解 @Autowire 来声明依赖，就是使用 AutowiredAnnotationBeanPostProcessor 来实现依赖的查询和注入的。接口定义如下：
 
  
public interface BeanPostProcessor {

    // 初始化前调用
    Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException;

    // 初始化后调用
    Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException;

}

 
  
实现该接口的 Bean 都会被 Spring 注册到 beanPostProcessors 中，见 AbstractBeanFactory :
 
  
/** BeanPostProcessors to apply in createBean */
private final List beanPostProcessors = new ArrayList();

 
  
只要 Bean 实现了 BeanPostProcessor 接口，加载的时候会被 Spring 自动识别这些 Bean，自动注册，非常方便。然后在 Bean 实例化前后，Spring 会去调用我们已经注册的 beanPostProcessors 把处理器都执行一遍。
 
  
public abstract class AbstractAutowireCapableBeanFactory ... {
        
    ...
    
    @Override
    public Object applyBeanPostProcessorsBeforeInitialization ... {

        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessBeforeInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }

    @Override
    public Object applyBeanPostProcessorsAfterInitialization ... {

        Object result = existingBean;
        for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
            result = beanProcessor.postProcessAfterInitialization(result, beanName);
            if (result == null) {
                return result;
            }
        }
        return result;
    }
    
    ...
}

 
  
这里使用了责任链模式，Bean 会在处理器链中进行传递和处理。当我们调用 BeanFactory.getBean 的后，执行到 Bean 的初始化方法 AbstractAutowireCapableBeanFactory.initializeBean 会启动这些处理器。
 
  
protected Object initializeBean ... {   
    ...
    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    ...
    // 触发自定义 init 方法
    invokeInitMethods(beanName, wrappedBean, mbd);
    ...
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    ...
}

 
  
3.6.3. 触发自定义 init
 
  
自定义初始化有两种方式可以选择：
 
  
     
   
  • 实现 InitializingBean。提供了一个很好的机会，在属性设置完成后再加入自己的初始化逻辑。
    •  
   
  • 定义 init 方法。自定义的初始化逻辑。
    •  
  
 
  
见 AbstractAutowireCapableBeanFactory.invokeInitMethods ：
 
  
    protected void invokeInitMethods ... {

        boolean isInitializingBean = (bean instanceof InitializingBean);
        if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
            ...
            
            ((InitializingBean) bean).afterPropertiesSet();
            ...
        }

        if (mbd != null) {
            String initMethodName = mbd.getInitMethodName();
            if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
                    !mbd.isExternallyManagedInitMethod(initMethodName)) {
                invokeCustomInitMethod(beanName, bean, mbd);
            }
        }
    }

 
  
3.7. 类型转换
 
  
Bean 已经加载完毕，属性也填充好了，初始化也完成了。在返回给调用者之前，还留有一个机会对 Bean 实例进行类型的转换。见 AbstractBeanFactory.doGetBean ：
 
  
protected  T doGetBean ... {
    ...
    if (requiredType != null && bean != null && !requiredType.isInstance(bean)) {
        ...
        return getTypeConverter().convertIfNecessary(bean, requiredType);
        ...
    }
    return (T) bean;
}


 
  
4. 总结
 
  
抛开一些细节处理和扩展功能，一个 Bean 的创建过程无非是：获取完整定义 -> 实例化 -> 依赖注入 -> 初始化 -> 类型转换。
 
  
作为一个完善的框架，Spring 需要考虑到各种可能性，还需要考虑到接入的扩展性。所以有了复杂的循环依赖的解决，复杂的有参数构造器的匹配过程，有了 BeanPostProcessor 来对实例化或初始化的 Bean 进行扩展修改。
 
  
先有个整体设计的思维，再逐步击破针对这些特殊场景的设计，整个 Bean 加载流程迎刃而解。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

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

        

            

                
    
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • SpringBoot整合ES搜索引擎 实现网站热搜词及热度计算
                        码踏云端
springbootElasticsearchspringbootelasticsearch后端热搜词热度计算java
                        
    博主简介：历代文学网（PC端可以访问：https://literature.sinhy.com/#/literature?__c=1000，移动端可微信小程序搜索“历代文学”）总架构师，15年工作经验，精通Java编程，高并发设计，Springboot和微服务，熟悉Linux，ESXI虚拟化以及云原生Docker和K8s，热衷于探索科技的边界，并将理论知识转化为实际应用。保持对新技术的好奇心，乐于
    
                    
    • 
                    
  • 品读 Java 经典巨著《Effective Java》90条编程法则，第4条：通过私有构造器强化不可实例化的能力
                        @赵士杰
品读《EffectiveJava》java开发语言EffectiveJava
                        
    文章目录【前言】欢迎订阅【品读《EffectiveJava》】系列专栏java.lang.Math类的设计经验总结【前言】欢迎订阅【品读《EffectiveJava》】系列专栏《EffectiveJava》是Java开发领域的经典著作，作者JoshuaBloch以丰富的经验和深入的知识，全面探讨了Java编程中的最佳实践。这本书被公认为Java开发者的必读经典，对提升编码技巧和代码质量具有重要意义
    
                    
    • 
                    
  • Java初级学习路线概要~
                        艾伦~耶格尔
Java初级java学习开发语言intellij-ideajdk
                        
    前言如果你刚刚开始学习Java，掌握基础知识是关键。本文将提供一个详细的Java初级学习路线，帮助各位看官从基础开始，逐步掌握Java编程语言的核心概念。1.Java语言基础1.1Java简介-**Java介绍**：Java是一种广泛使用的编程语言，以其跨平台特性和面向对象设计而著名。-**应用场景**：Web应用、桌面应用、移动应用等。1.2环境搭建**安装JDK**：从[Oracle官网](h
    
                    
    • 
                    
  • 如何避免 Java 学习中误用 break 和 continue？
                        Itmastergo
学习
                        
    在Java编程学习过程中，许多初学者经常会误用break和continue语句。这种情况不仅影响代码的可读性，还可能导致逻辑错误，从而使程序无法按预期工作。一、break和continue的基本概念1.1break语句break语句在Java中用于立即终止循环或者switch语句。当程序遇到break时，控制权将跳出当前的循环体或switch块，并且不再执行该结构中的剩余代码。通常情况下，brea
    
                    
    • 
                    
  • Java 学习中使用文件、网络连接等资源时，未正确关闭资源，导致资源泄漏应该怎么办？
                        Itmastergo
java学习数据库
                        
    在Java编程中，处理文件、网络连接、数据库连接等资源时，如果没有正确关闭资源，就会发生资源泄漏。资源泄漏会导致系统性能下降、内存占用增加，甚至可能导致程序崩溃，特别是在高负载的系统中。一、什么是资源泄漏？资源泄漏（ResourceLeak）是指程序在使用完某些资源（如文件、数据库连接、网络连接等）后，未能正确地释放这些资源，导致资源在不被使用的情况下依然占用系统的资源。这些未释放的资源会消耗内存
    
                    
    • 
                    
  • Java 学习路线：适合小白的超细学习路线及实例代码
                        Dreams°123
后端javaeclipsejvmspringtomcatideintellij-idea
                        
    Java学习路线：适合小白的超细学习路线及实例代码一、入门基础1.1、Java基础语法1.2、面向对象编程(OOP)二、核心Java编程2.1、数据结构和算法基础2.2、输入输出(I/O)三、进阶Java编程3.1、多线程编程3.2、网络编程四、高级应用4.1、数据库编程4.2、Web开发4.3、框架与库五、实践项目与进阶学习（留作业啦）5.1、实践项目5.2、持续学习一、入门基础1.1、Java
    
                    
    • 
                    
  • JDBC理解
                        迷糊银儿

                        
    DBC：databaseconnection这是数据库连接，JDBC是java编程语言支持的数据库连接。SUM公司提供了一些接口供各个数据库厂商实现，因为很多数据库的操作都是共用的，所以以接口的方式提供出来，由个大厂商实现。如在eclipse中引入的java-mysql-connector的jar包就实现了这些接口。数据库驱动：驱动就是两个设备之间沟通的桥梁，所以在使用数据库之前必须进行“加载驱动
    
                    
    • 
                    
  • 什么是JVM
                        GG编程
jvm
                        
    1.基本概念：JVM（JavaVirtualMachine，Java虚拟机）是一个用于运行Java程序的虚拟机。它是Java编程语言的核心部分，负责将Java字节码（bytecode）解释或编译成计算机可以执行的机器码，从而实现Java程序的跨平台特性。2.主要功能：(1).加载字节码：JVM将编译后的Java字节码文件（.class文件）加载到内存中。(2).字节码验证：验证字节码的正确性和安全
    
                    
    • 
                    
  • java 接口创建对象
                        专注API从业者
经验分享电商平台API接口java开发语言大数据数据库数据挖掘
                        
    Java接口创建对象：深度解析与示例在Java编程中，接口是一种非常重要的概念。它不仅为不同类之间的交互提供了规范，也促进了代码的重用和解耦。本文将深入探讨如何在Java中使用接口创建对象，带您理解这一关键特性。什么是接口？接口（Interface）是一种特殊的抽象类，定义了一组方法的声明，但不提供具体的实现。接口允许我们定义类的方法，而不需要指定它们是什么。这使得接口在Java中成为实现多态性、
    
                    
    • 
                    
  • Java面试题--JVM大厂篇之深入解析JVM运行时数据区：Java开发者必读
                        青云交
Java大厂面试题Java技术栈Java虚拟机（JVM）专栏javaJava虚拟机的运行时数据区JVM运行时数据区程序计数器Java虚拟机栈本地方法栈堆（Heap）方法区或元空间
                        
    引言：Java虚拟机（JVM）是Java编程语言的重要组件，它不仅实现了Java程序的跨平台特性，还高度关注内存管理和性能优化。在JVM的体系结构中，运行时数据区是实现这些特性的关键部分。本文将详细介绍JVM的运行时数据区及其各部分的作用，以帮助开发者更好地理解和优化Java程序。正文：在Java虚拟机（JVM）的运行时数据区中，主要分为若干内存区域，这些区域各自承担着不同的职责。了解这些区域及其
    
                    
    • 
                    
  • Java多线程：深入探索与详细解析
                        m0_63550220
java开发语言
                        
    1.基础概念与重要性在Java编程中，多线程是并发编程的基石，它允许应用程序同时执行多个任务。这种能力不仅提高了程序的执行效率，还增强了其响应性和用户界面的流畅性。随着现代计算机系统的多核化趋势，多线程编程变得越来越重要，因为它能够充分利用硬件资源，提升程序的总体性能。线程（Thread）：作为Java中的基本执行单元，线程是轻量级的进程，由线程ID、程序计数器、Java虚拟机栈、本地方法栈、和线
    
                    
    • 
                    
  • java编程题——八皇后问题
                        sdg_advance
java算法排序算法数据结构
                        
    背景及问题介绍：八皇后问题（英文：Eightqueens），是由国际象棋棋手马克斯·贝瑟尔于1848年提出的问题，是回溯算法的典型案例。问题表述为：在8×8格的国际象棋上摆放8个皇后，使其不能互相攻击，即任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。高斯认为有76种方案。1854年在柏林的象棋杂志上不同的作者发表了40种不同的解，后来有人用图论的方法解出92种结果。如果经过±9
    
                    
    • 
                    
  • 空指针异常 (NullPointerException)怎么办
                        Itmastergo
开发语言java
                        
    在Java编程中，空指针异常（NullPointerException，简称NPE）是最常见且困扰开发人员的异常之一。尽管Java是一种强类型语言，设计上提供了类型安全的特性，但空指针问题依然是开发过程中最常见的运行时异常之一。理解NullPointerException的产生原因及其预防措施对于编写健壮和安全的代码至关重要。一、什么是NullPointerException？NullPointe
    
                    
    • 
                    
  • 如何处理忘记实现接口所有方法
                        Itmastergo
java学习开发语言
                        
    在Java编程中，当你声明一个类实现了某个接口时，但没有实现接口中的所有方法，编译器会报错。这是因为接口规定了必须由实现类提供的功能，任何没有实现的接口方法，都会被认为是实现不完整的，导致编译失败。一、Java接口的基本概念1.1什么是接口接口（Interface）是Java中一种特殊的类型，它是抽象类的一种更彻底的形式。接口可以看作是一组方法的声明，任何实现这个接口的类必须提供具体的实现。接口的
    
                    
    • 
                    
  • java邮箱服务器如何配置？java怎么发邮件？
                        danplus
EDM邮件营销邮件营销服务器SMTP服务器API接口触发式邮件营销邮件
                        
    Java邮箱发送服务如何设置？怎么使用Java实现发邮件？通过Java编程语言，我们可以高效地配置和管理邮箱服务器，实现邮件的发送和接收功能。AokSend将详细介绍如何使用Java配置邮箱服务器的过程，并深入探讨一些常见问题的解决方案。java邮箱：安装软件需要确保服务器上已经安装了Java运行环境。然后，根据java邮箱服务器软件的官方文档，下载并解压安装包，按照步骤进行安装。安装过程中，可能
    
                    
    • 
                    
  • 《Effective Java》读书笔记-1
                        洵乙
《EffectiveJava》读书笔记java开发语言
                        
    第一章引言书里写道：“本书不是针对初学者的，而是假设读者已经熟悉Java编程语言”本书大部分内容不讨论性能，而是关心如何编写出清晰、正确、可用、健壮、灵活和可维护的程序。第二章创建和销毁对象第1条【用静态工厂方法代替构造器】举例：有一个类People，当我们需要一个People的对象时，一般会用Peoplepeople=newPeople();本书建议在People类中添加一个静态方法：publi
    
                    
    • 
                    
  • Java的Base64加密解密详解
                        微赚淘客系统开发者
java开发语言
                        
    Java的Base64加密解密详解大家好，我是免费搭建查券返利机器人赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！在当今数字化时代，数据的安全性和可传递性变得尤为重要。Java编程语言提供了Base64编码和解码的工具，成为保障数据传输和存储安全性的一项重要技术。让我们深入探讨Java中Base64加密解密的原理及应用。什么是Base64？Base64是一种基于64个
    
                    
    • 
                    
  • 第十六节 Java String类
                        程序猿小D
java开发语言jdkjava-eejvmeclipseintellij-idea
                        
    字符串广泛应用在Java编程中，在Java中字符串属于对象，Java提供了String类来创建和操作字符串。创建字符串创建字符串最简单的方式如下:Stringgreeting="Helloworld!";在代码中遇到字符串常量时，这里的值是"Helloworld!"，编译器会使用该值创建一个String对象。和其它对象一样，可以使用关键字和构造方法来创建String对象。String类有11种构造
    
                    
    • 
                    
  • 探索Java设计模式：模板方法模式
                        放码过来_
设计模式java设计模式模板方法模式
                        
    探索Java设计模式：深入理解与实践模板方法模式模板方法模式（TemplateMethodPattern）是一种行为型设计模式，它定义了一个算法的框架，并允许子类在不改变算法整体结构的情况下重定义某些步骤。在Java编程中，模板方法模式常用于封装重复的行为模式，实现算法的可扩展性。本文将通过简要介绍、实现示例及实际运用等模块，帮助读者全面掌握模板方法模式及其在Java环境下的应用。一、简要介绍模板
    
                    
    • 
                    
  • 入门Java编程的知识点—＞重写（day10）
                        小星袁
Java基础知识点javapythonlinux
                        
    重点掌握重写的适用性？重写的语法?重点掌握多态是什么？多态-向上造型的语法?多态的意义?重点掌握接口是什么?接口如何语法如何定义?重点掌握引用类型转换有哪些？instanceOf关键字如何用?回顾在昨天的ExtendsDemo测试类中,我们如果想要表示多个学生对象,多个老师对象,多个医生对象,则需要使用数组来完成Student[]students=newStudent[3];students[0]
    
                    
    • 
                    
  • 2022年最新阿里Java高级岗200+面试题，掌握80%进阿里没问题
                        繁华哟
面试学习路线阿里巴巴android前端后端
                        
    2022年更新的阿里集团Java岗JD标准，信息来源于阿里集团的招聘专场，包括天猫、蚂蚁金服、中间件团队的高级Java、技术专家岗位。文末随附BATJTMD等一线互联网企业的Java高级研发岗位的面试题目及答案。以下面试题能答出百分之八十你就可以去试试01阿里集团各大事业部Java岗JD标准阿里巴巴天猫1.高级JAVA工程师要求3年以上JEE开发经验；2.扎实的Java编程基础，熟悉各种设计模式3
    
                    
    • 
                    
  • JAVA Web学习(22)___第16章Hibernate技术
                        岁月静好浅笑安然

                        
    第16章Hibernate技术16.1初识Hibernate16.1.1理解ORM原理16.1.2Hibernate简介Hibernate是一款免费开源的持久层框架，它对JDBC进行了轻量级的对象封装，将对象与数据库表建立了映射关系，使Java编程人员可以随心所欲地使用面向对象的编程思想操作数据库。Hibernate具有简单易用、灵活性强、扩展性强等特点，大大提高了程序的开发效率。使用传统的JDB
    
                    
    • 
                    
  • Java编程开发新手学习：数组方法的应用猜字母游戏
                        Java小辰

                        
    Java是一种可以撰写跨平台应用软件的面向对象的程序设计语言。Java技术具有卓越的通用性、高效性、平台移植性和安全性，广泛应用于PC、数据中心、游戏控制台、科学超级计算机、移动电话和互联网，同时拥有全球最大的开发者专业社群。给你学习路线：html-css-js-jq-javase-数据库-jsp-servlet-Struts2-hibernate-mybatis-spring4-springmv
    
                    
    • 
                    
  • Java垃圾回收器的工作原理
                        java菜

                        
    上课，老师照本宣科，实在难以理解，干脆就看书里的Java书，正好看了Java的垃圾回收器是如何工作的，觉得有必要记录一下。参考于Java编程思想第四版（ThinkinginJava）1.垃圾回收器对于提高对象的创建速度，有明显的效果问题来了，垃圾回收是释放对象，而关创建对象什么事？首先了解一下Java是如何在堆上分配内存的，Java使用“堆指针”，每分配一个对象，指针就往后移一位，类似于堆栈，这样
    
                    
    • 
                    
  • Java 进阶篇之try-catch-finally语句与自定义异常
                        code2cat
Java进阶java开发语言ideintellij-idea
                        
    引言在前面的文章中，我们介绍了创建、使用和导入包（Java进阶篇之异常处理的概念和种类），在Java编程中，异常处理是确保程序健壮性和稳定性的重要机制。通过异常处理，程序可以应对运行时错误，避免崩溃并提供友好的错误信息。本篇文章将详细介绍Java中的try-catch-finally语句及其使用方式，并深入探讨如何创建和使用自定义异常。通过本文，你将掌握异常处理的基本原则与高级技巧，写出更加健壮的
    
                    
    • 
                    
  • Kotlin内联类、内部类、嵌套类
                        维特or卡顿

                        
    Kotlin内联类、内部类、嵌套类在开始介绍Kotlin内联类、内部类、嵌套类之前，先简要回顾一下java中的内部类java中的内部类可以将一个类的定义放在另一个类的定义内部，这就是内部类——《Java编程思想》概述在java中，内部类有一中非常有用的特性，它允许将一些逻辑相关的类组织在一起，并控制位于内部的类的可见性。java内部类拥有其外围类所有元素的访问权，不需要特殊条件就可以访问外围类的所
    
                    
    • 
                    
  • equalsIgnoreCase方法详解
                        微赚淘客系统开发者
开发语言java
                        
    equalsIgnoreCase方法详解大家好，我是免费搭建查券返利机器人赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！在Java编程的世界中，有一款强大而实用的字符串比较方法备受程序员们的关注——那就是equalsIgnoreCase()方法。今天，让我们一同深入探讨这个方法的详细用法，为你揭示在字符串比较中如何巧妙地应用equalsIgnoreCase()。1.什
    
                    
    • 
                    
  • Java必知必会-基础篇
                        探索星辰大海
Java必知必会java开发语言
                        
    说明：《Java必知必会》是一档专为Java学习者设计的专栏，旨在帮助读者系统地掌握Java编程语言的核心知识，从基础语法到高级特性，从理论应用到实战演练，一站式解决你的Java学习难题。可在我的专栏里订阅，该专栏一共有15篇，本篇是第二篇。会先教会大家如何使用，并给出相应的练习题示例作业习题是帮助大家巩固所学内容，需要大家独立完成学完入门篇和基础篇就算掌握Java的常用基础知识了，下一篇开始学习
    
                    
    • 
                    
  • Java 编程中的无参构造函数：为何建议自定义？
                        需要重新演唱
Java基础java开发语言
                        
    Java编程中的无参构造函数：为何建议自定义？在Java编程中，构造函数是用于初始化对象的特殊方法。Java提供了默认的无参构造函数，但在某些情况下，建议自定义一个无参构造函数。本文将深入探讨这一建议背后的原因，并通过丰富的代码示例和详细的解释，帮助你全面理解无参构造函数的必要性及实际应用。前置知识在深入探讨之前，我们需要了解一些基本概念：构造函数：构造函数是用于初始化对象的特殊方法，与类同名，没
    
                    
    • 
                                
  • ios内付费
                                    374016526
ios内付费
                                    
    近年来写了很多IOS的程序，内付费也用到不少，使用IOS的内付费实现起来比较麻烦，这里我写了一个简单的内付费包，希望对大家有帮助。 
  
具体使用如下: 
这里的sender其实就是调用者，这里主要是为了回调使用。 
[KuroStoreApi kuroStoreProductId:@"产品ID" storeSender:self storeFinishCallBa
    
                                
    • 
                                
  • 20 款优秀的 Linux 终端仿真器
                                    brotherlamp
linuxlinux视频linux资料linux自学linux教程
                                    
      
终端仿真器是一款用其它显示架构重现可视终端的计算机程序。换句话说就是终端仿真器能使哑终端看似像一台连接上了服务器的客户机。终端仿真器允许最终用户用文本用户界面和命令行来访问控制台和应用程序。（LCTT 译注：终端仿真器原意指对大型机-哑终端方式的模拟，不过在当今的 Linux 环境中，常指通过远程或本地方式连接的伪终端，俗称“终端”。） 
你能从开源世界中找到大量的终端仿真器，它们
    
                                
    • 
                                
  • Solr Deep Paging(solr 深分页)
                                    eksliang
solr深分页solr分页性能问题
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2148370 
作者：eksliang(ickes) blg:http://eksliang.iteye.com/ 概述 
长期以来，我们一直有一个深分页问题。如果直接跳到很靠后的页数，查询速度会比较慢。这是因为Solr的需要为查询从开始遍历所有数据。直到Solr的4.7这个问题一直没有一个很好的解决方案。直到solr
    
                                
    • 
                                
  • 数据库面试题
                                    18289753290
面试题 数据库
                                    
    1.union ,union all 
网络搜索出的最佳答案： 
union和union all的区别是,union会自动压缩多个结果集合中的重复结果，而union all则将所有的结果全部显示出来，不管是不是重复。 
Union：对两个结果集进行并集操作，不包括重复行，同时进行默认规则的排序； 
Union All：对两个结果集进行并集操作，包括重复行，不进行排序； 
2.索引有哪些分类？作用是
    
                                
    • 
                                
  • Android TV屏幕适配
                                    酷的飞上天空
android
                                    
    先说下现在市面上TV分辨率的大概情况 
两种分辨率为主 
1.720标清，分辨率为1280x720. 
屏幕尺寸以32寸为主，部分电视为42寸 
2.1080p全高清，分辨率为1920x1080 
屏幕尺寸以42寸为主，此分辨率电视屏幕从32寸到50寸都有 
  
适配遇到问题，已1080p尺寸为例： 
分辨率固定不变，屏幕尺寸变化较大。 
如：效果图尺寸为1920x1080，如果使用d
    
                                
    • 
                                
  • Timer定时器与ActionListener联合应用
                                    永夜-极光
java
                                    
    功能:在控制台每秒输出一次 
  
代码: 
package Main;
import javax.swing.Timer;
 import java.awt.event.*;

 public class T {
    private static int count = 0; 

    public static void main(String[] args){

    
                                
    • 
                                
  • Ubuntu14.04系统Tab键不能自动补全问题解决
                                    随便小屋
Ubuntu 14.04
                                    
    Unbuntu 14.4安装之后就在终端中使用Tab键不能自动补全，解决办法如下： 
  
1、利用vi编辑器打开/etc/bash.bashrc文件（需要root权限） 
sudo vi /etc/bash.bashrc 
 接下来会提示输入密码 
2、找到文件中的下列代码 
#enable bash completion in interactive shells
#if
    
                                
    • 
                                
  • 学会人际关系三招 轻松走职场
                                    aijuans
职场
                                    
    要想成功，仅有专业能力是不够的，处理好与老板、同事及下属的人际关系也是门大学问。如何才能在职场如鱼得水、游刃有余呢？在此，教您简单实用的三个窍门。 
　　第一，多汇报 
 最近，管理学又提出了一个新名词“追随力”。它告诉我们，做下属最关键的就是要多请示汇报，让上司随时了解你的工作进度，有了新想法也要及时建议。不知不觉，你就有了“追随力”，上司会越来越了解和信任你。 
　　第二，勤沟通 
 团队的力
    
                                
    • 
                                
  • 《O2O：移动互联网时代的商业革命》读书笔记
                                    aoyouzi
读书笔记
                                    
    移动互联网的未来：碎片化内容+碎片化渠道=各式精准、互动的新型社会化营销。 
  
O2O：Online to OffLine 线上线下活动 
O2O就是在移动互联网时代，生活消费领域通过线上和线下互动的一种新型商业模式。 
  
手机二维码本质：O2O商务行为从线下现实世界到线上虚拟世界的入口。 
  
线上虚拟世界创造的本意是打破信息鸿沟，让不同地域、不同需求的人
    
                                
    • 
                                
  • js实现图片随鼠标滚动的效果
                                    百合不是茶
JavaScript滚动属性的获取图片滚动属性获取页面加载
                                    
    1,获取样式属性值 
top  与顶部的距离
left  与左边的距离
right 与右边的距离
bottom 与下边的距离
zIndex 层叠层次 
  
  例子:获取左边的宽度,当css写在body标签中时 
<div id="adver" style="position:absolute;top:50px;left:1000p
    
                                
    • 
                                
  • ajax同步异步参数async
                                    bijian1013
jqueryAjaxasync
                                    
            开发项目开发过程中，需要将ajax的返回值赋到全局变量中，然后在该页面其他地方引用，因为ajax异步的原因一直无法成功，需将async:false，使其变成同步的。 
        格式： 
$.ajax({ type: 'POST', ur
    
                                
    • 
                                
  • Webx3框架（1）
                                    Bill_chen
eclipsespringmaven框架ibatis
                                    
    Webx是淘宝开发的一套Web开发框架，Webx3是其第三个升级版本；采用Eclipse的开发环境，现在支持java开发； 
采用turbine原型的MVC框架，扩展了Spring容器，利用Maven进行项目的构建管理，灵活的ibatis持久层支持，总的来说，还是一套很不错的Web框架。 
Webx3遵循turbine风格，velocity的模板被分为layout/screen/control三部
    
                                
    • 
                                
  • 【MongoDB学习笔记五】MongoDB概述
                                    bit1129
mongodb
                                    
    MongoDB是面向文档的NoSQL数据库，尽量业界还对MongoDB存在一些质疑的声音，比如性能尤其是查询性能、数据一致性的支持没有想象的那么好，但是MongoDB用户群确实已经够多。MongoDB的亮点不在于它的性能，而是它处理非结构化数据的能力以及内置对分布式的支持(复制、分片达到的高可用、高可伸缩)，同时它提供的近似于SQL的查询能力，也是在做NoSQL技术选型时，考虑的一个重要因素。Mo
    
                                
    • 
                                
  • spring/hibernate/struts2常见异常总结
                                    白糖_
Hibernate
                                    
     
 Spring 
 
①ClassNotFoundException: org.aspectj.weaver.reflect.ReflectionWorld$ReflectionWorldException 
缺少aspectjweaver.jar，该jar包常用于spring aop中 
  
②java.lang.ClassNotFoundException: org.sprin
    
                                
    • 
                                
  • jquery easyui表单重置(reset)扩展思路
                                    bozch
formjquery easyuireset
                                    
    在jquery easyui表单中 尚未提供表单重置的功能，这就需要自己对其进行扩展。 
扩展的时候要考虑的控件有： 
 combo,combobox,combogrid,combotree,datebox,datetimebox 
需要对其添加reset方法，reset方法就是把初始化的值赋值给当前的组件，这就需要在组件的初始化时将值保存下来。 
在所有的reset方法添加完毕之后，就需要对fo
    
                                
    • 
                                
  • 编程之美-烙饼排序
                                    bylijinnan
编程之美
                                    
    
package beautyOfCoding;

import java.util.Arrays;

/*
 *《编程之美》的思路是：搜索+剪枝。有点像是写下棋程序：当前情况下，把所有可能的下一步都做一遍；在这每一遍操作里面，计算出如果按这一步走的话，能不能赢（得出最优结果）。
 *《编程之美》上代码有很多错误，且每个变量的含义令人费解。因此我按我的理解写了以下代码：
 */

    
                                
    • 
                                
  • Struts1.X 源码分析之ActionForm赋值原理
                                    chenbowen00
struts
                                    
    struts1在处理请求参数之前，首先会根据配置文件action节点的name属性创建对应的ActionForm。如果配置了name属性，却找不到对应的ActionForm类也不会报错，只是不会处理本次请求的请求参数。 
 
如果找到了对应的ActionForm类，则先判断是否已经存在ActionForm的实例，如果不存在则创建实例，并将其存放在对应的作用域中。作用域由配置文件action节点的s
    
                                
    • 
                                
  • [空天防御与经济]在获得充足的外部资源之前,太空投资需有限度
                                    comsci
资源
                                    
     
      这里有一个常识性的问题: 
 
      地球的资源,人类的资金是有限的,而太空是无限的..... 
 
      就算全人类联合起来,要在太空中修建大型空间站,也不一定能够成功,因为资源和资金,技术有客观的限制.... 
 
&
    
                                
    • 
                                
  • ORACLE临时表—ON COMMIT PRESERVE ROWS
                                    daizj
oracle临时表
                                    
    ORACLE临时表 转 
临时表：像普通表一样，有结构，但是对数据的管理上不一样，临时表存储事务或会话的中间结果集，临时表中保存的数据只对当前 
会话可见，所有会话都看不到其他会话的数据，即使其他会话提交了，也看不到。临时表不存在并发行为，因为他们对于当前会话都是独立的。 
创建临时表时，ORACLE只创建了表的结构（在数据字典中定义），并没有初始化内存空间，当某一会话使用临时表时，ORALCE会
    
                                
    • 
                                
  • 基于Nginx XSendfile+SpringMVC进行文件下载
                                    denger
应用服务器Webnginx网络应用lighttpd
                                    
        在平常我们实现文件下载通常是通过普通 read-write方式，如下代码所示。 
 
   @RequestMapping("/courseware/{id}") 
   public void download(@PathVariable("id") String courseID, HttpServletResp
    
                                
    • 
                                
  • scanf接受char类型的字符
                                    dcj3sjt126com
c
                                    
    /*
	2013年3月11日22:35:54
	目的：学习char只接受一个字符
*/
# include <stdio.h>

int main(void)
{
	int i;
	char ch;

	scanf("%d", &i);
	printf("i = %d\n", i);
	scanf("%
    
                                
    • 
                                
  • 学编程的价值
                                    dcj3sjt126com
编程
                                    
    发一个人会编程, 想想以后可以教儿女, 是多么美好的事啊, 不管儿女将来从事什么样的职业, 教一教, 对他思维的开拓大有帮助 
  
像这位朋友学习:   
http://blog.sina.com.cn/s/articlelist_2584320772_0_1.html 
  
 
  VirtualGS教程 (By @林泰前): 几十年的老程序员，资深的
    
                                
    • 
                                
  • 二维数组（矩阵）对角线输出
                                    飞天奔月
二维数组
                                    
    今天在BBS里面看到这样的面试题目, 
  
1，二维数组（N*N），沿对角线方向，从右上角打印到左下角如N=4： 4*4二维数组  
{ 1 2 3 4 }
{ 5 6 7 8 }
{ 9 10 11 12 }
{13 14 15 16 } 
打印顺序  
4
3 8
2 7 12
1 6 11 16
5 10 15
9 14
13 
要
    
                                
    • 
                                
  • Ehcache（08）——可阻塞的Cache——BlockingCache
                                    234390216
并发ehcacheBlockingCache阻塞
                                    
    可阻塞的Cache—BlockingCache 
  
       在上一节我们提到了显示使用Ehcache锁的问题，其实我们还可以隐式的来使用Ehcache的锁，那就是通过BlockingCache。BlockingCache是Ehcache的一个封装类，可以让我们对Ehcache进行并发操作。其内部的锁机制是使用的net.
    
                                
    • 
                                
  • mysqldiff对数据库间进行差异比较
                                    jackyrong
mysqld
                                    
      mysqldiff该工具是官方mysql-utilities工具集的一个脚本，可以用来对比不同数据库之间的表结构，或者同个数据库间的表结构 
   如果在windows下，直接下载mysql-utilities安装就可以了，然后运行后，会跑到命令行下： 
 
1） 基本用法 
   mysqldiff --server1=admin:12345
    
                                
    • 
                                
  • spring data jpa 方法中可用的关键字
                                    lawrence.li
javaspring
                                    
    spring data jpa 支持以方法名进行查询/删除/统计。 
查询的关键字为find 
删除的关键字为delete/remove (>=1.7.x) 
统计的关键字为count (>=1.7.x) 
  
修改需要使用@Modifying注解 
@Modifying
@Query("update User u set u.firstna
    
                                
    • 
                                
  • Spring的ModelAndView类
                                    nicegege
spring
                                    
    项目中controller的方法跳转的到ModelAndView类，一直很好奇spring怎么实现的？ 
/*
 * Copyright 2002-2010 the original author or authors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * yo
    
                                
    • 
                                
  • 搭建 CentOS 6 服务器(13) - rsync、Amanda
                                    rensanning
centos
                                    
    （一）rsync 
 
Server端 
 
# yum install rsync
# vi /etc/xinetd.d/rsync
    service rsync
    {
        disable = no
        flags           = IPv6
        socket_type     = stream
        wait    
    
                                
    • 
                                
  • Learn Nodejs 02
                                    toknowme
nodejs
                                    
    （1）npm是什么   
npm is the package manager for node 
官方网站：https://www.npmjs.com/ 
npm上有很多优秀的nodejs包，来解决常见的一些问题，比如用node-mysql，就可以方便通过nodejs链接到mysql，进行数据库的操作 
在开发过程往往会需要用到其他的包，使用npm就可以下载这些包来供程序调用 
&nb
    
                                
    • 
                                
  • Spring MVC 拦截器
                                    xp9802
spring mvc
                                    
    Controller层的拦截器继承于HandlerInterceptorAdapter 
 
 HandlerInterceptorAdapter.java   1  public   abstract   class  HandlerInterceptorAdapter  implements  HandlerIntercep
    
                                
    •