5.4 获取单例

5.4  获取单例

 

之前我们讲解了从缓存中获取单例的过程，那么，如果缓存中不存在已经加载的单例bean就需要从头开始bean的加载过程了，而Spring中使用getSingleton的重载方法实现bean的加载过程。

 

DefaultSingletonBeanRegistry.java

 

 

/**
     * Return the (raw) singleton object registered under the given name, creating and
     * registering a new one if none registered yet.
     * 
     * @param beanName the name of the bean
     * @param singletonFactory the ObjectFactory to lazily create the singleton with, if
     *        necessary
     * @return the registered singleton object
     */
    public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
        Assert.notNull(beanName, "'beanName' must not be null");
        // 全局变量需要同步
        synchronized (this.singletonObjects) {
            // 首先检查对应的bean是否已经加载过，因为singleton模式其实就是复用以创建的bean，所以这一步是必须的
            Object singletonObject = this.singletonObjects.get(beanName);
            // 如果为空才可以进行singleto的bean的初始化
            if (singletonObject == null) {
                if (this.singletonsCurrentlyInDestruction) {
                    throw new BeanCreationNotAllowedException(
                            beanName,
                            "Singleton bean creation not allowed while the singletons of this factory are in destruction "
                                    + "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
                }
                if (logger.isDebugEnabled()) {
                    logger.debug("Creating shared instance of singleton bean '"
                            + beanName + "'");
                }

                // 记录加载状态，也就是通过this.singletonsCurrentlyIn
                // Creation.add(beanName)将当前正要创建的bean记录在缓存中，这样便可以对循环依赖进行检测。
                beforeSingletonCreation(beanName);
                boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
                if (recordSuppressedExceptions) {
                    this.suppressedExceptions = new LinkedHashSet<Exception>();
                }
                try {
                    // 初始化bean
                    singletonObject = singletonFactory.getObject();
                }
                catch (BeanCreationException ex) {
                    if (recordSuppressedExceptions) {
                        for (Exception suppressedException : this.suppressedExceptions) {
                            ex.addRelatedCause(suppressedException);
                        }
                    }
                    throw ex;
                }
                finally {
                    if (recordSuppressedExceptions) {
                        this.suppressedExceptions = null;
                    }
                    // 同 beforeSingletonCreation
                    // 的记录加载状态相似，当bean加载结束后需要移除缓存中对该bean的正在加载状态的记录。
                    afterSingletonCreation(beanName);
                }
                // 将结果记录至缓存并删除加载bean过程中所记录的各种辅助状态。
                addSingleton(beanName, singletonObject);
            }
            return (singletonObject != NULL_OBJECT ? singletonObject : null);
        }
    }

 

 

 

 

 

上述代码中其实是使用了回调方法，使得程序可以在单例创建的前后做一些准备及处理操作，而真正的获取单例bean的方法其实并不是在此方法中实现的，其实现逻辑是在ObjectFactory类型的实例singletonFactory中实现的。而这些准备及处理操作包括如下内容。

（1）检查缓存是否已经加载过。

（2）若没有加载，则记录beanName的正在加载状态。

（3）加载单例前记录加载状态。

可能你会觉得beforeSingletonCreation方法是个空实现，里面没有任何逻辑，但其实不是，这个函数中做了一个很重要的操作：记录加载状态，也就是通过this.singletonsCurrentlyIn Creation.add(beanName)将当前正要创建的bean记录在缓存中，这样便可以对循环依赖进行检测。

 

/**
     * Callback before singleton creation.
     * <p>
     * The default implementation register the singleton as currently in creation.
     * 
     * @param beanName the name of the singleton about to be created
     * @see #isSingletonCurrentlyInCreation
     */
    // 记录加载状态，也就是通过this.singletonsCurrentlyIn
    // Creation.add(beanName)将当前正要创建的bean记录在缓存中，这样便可以对循环依赖进行检测。
    protected void beforeSingletonCreation(String beanName) {
        if (!this.inCreationCheckExclusions.contains(beanName)
                && !this.singletonsCurrentlyInCreation.add(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
    }

 

（4）通过调用参数传入的ObjectFactory的getObject方法实例化bean。

（5）加载单例后的处理方法调用。

同步骤（3）的记录加载状态相似，当bean加载结束后需要移除缓存中对该bean的正在加载状态的记录。

 

/**
     * Callback after singleton creation.
     * <p>
     * The default implementation marks the singleton as not in creation anymore.
     * 
     * @param beanName the name of the singleton that has been created
     * @see #isSingletonCurrentlyInCreation
     */
    // 同 beforeSingletonCreation
    // 的记录加载状态相似，当bean加载结束后需要移除缓存中对该bean的正在加载状态的记录。
    protected void afterSingletonCreation(String beanName) {
        if (!this.inCreationCheckExclusions.contains(beanName)
                && !this.singletonsCurrentlyInCreation.remove(beanName)) {
            throw new IllegalStateException("Singleton '" + beanName
                    + "' isn't currently in creation");
        }
    }

 

 

 

（6）将结果记录至缓存并删除加载bean过程中所记录的各种辅助状态。

 

 

/**
     * Add the given singleton object to the singleton cache of this factory.
     * <p>
     * To be called for eager registration of singletons.
     * 
     * @param beanName the name of the bean
     * @param singletonObject the singleton object
     */
    // 将结果记录至缓存并删除加载bean过程中所记录的各种辅助状态。
    protected void addSingleton(String beanName, Object singletonObject) {
        synchronized (this.singletonObjects) {
            this.singletonObjects.put(beanName,
                    (singletonObject != null ? singletonObject : NULL_OBJECT));
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }

 

（7）返回处理结果。

虽然我们已经从外部了解了加载bean的逻辑架构，但现在我们还并没有开始对bean加载功能的探索，之前提到过，bean的加载逻辑其实是在传入的ObjectFactory类型的参数singletonFactory中定义的，我们反推参数的获取，得到如下代码：

 

/**
     * Add the given singleton factory for building the specified singleton if necessary.
     * <p>
     * To be called for eager registration of singletons, e.g. to be able to resolve
     * circular references.
     * 
     * @param beanName the name of the bean
     * @param singletonFactory the factory for the singleton object
     */
    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);
            }
        }
    }

 AbstractBeanFactory.doGetBean

 

// 实例化依赖的bean后便可以实例化mbd本身了
                // Create bean instance.
                if (mbd.isSingleton()) {// singleton模式的创建
                    sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {

                        @Override
                        public Object getObject() throws BeansException {
                            try {
                                return createBean(beanName, mbd, args);
                            }
                            catch (BeansException ex) {
                                // Explicitly remove instance from singleton cache: It
                                // might have been put there
                                // eagerly by the creation process, to allow for circular
                                // reference resolution.
                                // Also remove any beans that received a temporary
                                // reference to the bean.
                                destroySingleton(beanName);
                                throw ex;
                            }
                        }
                    });
                    bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
                }

 

 

ObjectFactory的核心部分其实只是调用了createBean的方法，所以我们还需要到createBean方法中追寻真理。