spring bean加载--从缓存中获取bean

标签：spring源码学习

---

入口方法：getSingleton，在

Object sharedInstance = getSingleton(beanName);

@Override    public Object getSingleton(String beanName) {        return getSingleton(beanName, true);    }

真正的实现：

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);    }

spring单例在同一个spring容器中只创建一次，之后在获取bean的时候，会首先尝试从缓存加载bean，首先从singletonObjects中获取，singletonObjects中存储的是BeanName->Bean Instance, 如果缓存为空，但该bean正在创建过程中（isSingletonCurrentlyInCreation）则尝试从singletonFactories中获取。这是因为spring创建单例bean的时候，存在循环依赖的问题。比如创建bean a的时候发现bean a引用了bean b，此时会去创建bean b，但又发现bean b引用了bean c，所以此时会去创建bean c，在创建bean c的过程中发现bean c引用bean a。这三个bean就形成了一个环。为了解决循环依赖的问题，spring采取了一种将创建的bean实例提早暴露加入到缓存中，一旦下一个bean创建的时候需要依赖上个bean，则直接使用ObjectFactory来获取bean。提前暴露bean实例到缓存的时机是在bean实例创建（调用构造方法）之后，初始化bean实例（属性注入）之前。具体在AbstractAutowireCapableBeanFactory类的

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {...}

方法中。在该方法中调用了DefaultSingletonBeanRegistry类的

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

将允许提前暴露的单例bean提前加入singletonFactories中，这样就可以在创建依赖的时候避免循环依赖问题。

在从singletonFactories获取bean后，会将其存储到earlySingletonObjects中，然后从singletonFactories移除该bean，之后在要获取该bean就直接从earlySingletonObjects获取。这是因为从singletonFactories获取bean过程中需要调用singletonFactory.getObject()，这里还有一些操作，这样可以进一步提升性能。缓存思想用的很多。在java里面缓存大多都是指一个map结构，我想这应该是map的get和put操作都是O(1),适合用作缓存。
spring bean加载相关的缓存有以下这些：

/** Cache of singleton objects: bean name --> bean instance */    private final Map<String, Object> singletonObjects = new ConcurrentHashMap<String, Object>(256);    /** Cache of singleton factories: bean name --> ObjectFactory */    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<String, ObjectFactory<?>>(16);    /** Cache of early singleton objects: bean name --> bean instance */    private final Map<String, Object> earlySingletonObjects = new HashMap<String, Object>(16);

singletonObjects和earlySingletonObjects的区别主要在于earlySingletonObjects是为了解决循环依赖设置的，储存的是提前暴露的bean name –> bean instance，而singletonObjects存储的是完全实例化的bean name –> bean instance。

最后附上我看源码自己写的例子：首先定义了三个bean,

public class TestA {    private boolean beCallConstructor = false;    private TestB testB;    public TestA() {        beCallConstructor = true;    }    public String toString() {        StringBuilder builder = new StringBuilder();        builder.append("[TestB：").append(testB==null?"未初始化,":"已初始化,");        builder.append("是否调用完构造方法:").append(beCallConstructor?"是":"否").append("]");        return builder.toString();    }    public void setTestB(TestB testB) {        this.testB = testB;    }}

public class TestB {    private boolean beCallConstructor = false;    private TestC testC;    public TestB() {        beCallConstructor = true;    }    public String toString() {        StringBuilder builder = new StringBuilder();        builder.append("[testC：").append(testC==null?"未初始化,":"已初始化,");        builder.append("是否调用完构造方法:").append(beCallConstructor?"是":"否").append("]");        return builder.toString();    }    public void setTestC(TestC testC) {        this.testC = testC;    }}

public class TestC {    private boolean beCallConstructor = false;    private TestA testA;    public TestC() {        beCallConstructor = true;    }    public String toString() {        StringBuilder builder = new StringBuilder();        builder.append("[testA：").append(testA==null?"未初始化,":"已初始化,");        builder.append("是否调用完构造方法:").append(beCallConstructor?"是":"否").append("]");        return builder.toString();    }    public void setTestA(TestA testA) {        this.testA = testA;    }}

测试方法：

public class TestCircle {    @Test    public void testCircle(){        ApplicationContext bf = new ClassPathXmlApplicationContext("testCircle.xml");        System.out.println(bf.getBean("testA"));    }}

testA提前暴露在singletonFactories的快照

当testC引用了testA,此时直接从singletonFactories获取ObjectFactory，调用其getObject()方法获取提前暴露的testA,快照如下