Spring的单例模式底层实现学习笔记

单例模式也属于创建型模式，所谓单例，顾名思义，所指的就是单个实例，也就是说要保证一个类仅有一个实例。
单例模式有以下的特点：
①
单例类只能有一个实例
②
单例类必须自己创建自己的唯一实例
③
单例类必须给所有其他对象提供这一实例

下面我们就来写一个简单的单例模式的例子

package spring;

public class SingletonWW {
    private static final SingletonWW instance=new SingletonWW();
    //私有的默认构造函数
    private SingletonWW(){}
    //静态工厂方法
    public static SingletonWW getInstance(){
        return instance;
    }
}

大家可以看出来，在这个类被加载时，静态变量instance会被初始化，此时该类的私有构造函数被调用，这时候，单例类的唯一实例就被创建出来了

值得注意的是：由于构造函数是私有的，因此该类不能被继承

还有一种写法也可以实现单例模式：

package spring;

public class SingletonWW {
    private static SingletonWW instance = null;
    //私有的默认构造函数
    private SingletonWW(){}
    //静态工厂方法
    public synchronized static SingletonWW getInstance(){
        if(instance==null){
            instance = new SingletonWW();
        }
        return instance;
    }
}

这种写法和第一种的区别在于：实例并没有直接实例化，而是在静态工厂方法被调用的时候才进行的，而且对静态工厂方法使用了同步化，以处理多线程并发的环境。
这两种写法还有两个非常有意思的名字：第一种称为饿汉式单例，第二种称为懒汉式单例。
饿汉式单例在自己被加载时就将自己实例化，如果从资源利用效率角度来讲，比懒汉式单例类稍差些。但是从速度和反应时间角度来讲，则比懒汉式要稍好些。

但是遗憾的是：懒汉式单例类也不能被继承。

我们克服前两种单例类不能被继承的缺点，我们可以使用另外一种特殊化的单例模式，它被称为单例注册表。

package spring;

import java.util.HashMap;

public class SingletonWW {
    private static HashMap registry = new HashMap();
    public SingletonWW(){}
    //静态工厂方法
    public synchronized static SingletonWW getInstance(String name){
        if(name != null) {
            if(registry.get(name) == null) {
                try {
                    registry.put(name, Class.forName(name).newInstance());
                } catch(Exception ex) {
                    ex.printStackTrace();
                }
            } else {
                return (SingletonWW) registry.get(name);
            }
        }
        return null;
    }
}

下面我们来看看Spring中的单例实现，当我们试图从Spring容器中取得某个类的实例时，默认情况下，Spring会才用单例模式进行创建。

<bean id="date" class="java.util.Date"/>

<bean id="date" class="java.util.Date" scope="singleton"/> (仅为Spring2.0支持)

<bean id="date" class="java.util.Date" singleton="true"/>

以上三种创建对象的方式是完全相同的，容器都会向客户返回Date类的单例引用。那么如果我不想使用默认的单例模式，每次请求我都希望获得一个新的对象怎么办呢？很简单，将scope属性值设置为prototype(原型)就可以了

<bean id="date" class="java.util.Date" scope="prototype"/>

通过以上配置信息，Spring就会每次给客户端返回一个新的对象实例。

那么Spring对单例的底层实现，到底是饿汉式单例还是懒汉式单例呢？呵呵，都不是。Spring框架对单例的支持是采用单例注册表的方式进行实现的，源码如下：

    public abstract class AbstractBeanFactory implements ConfigurableBeanFactory{
       /**
        * 充当了Bean实例的缓存，实现方式和单例注册表相同
        */
       private final Map singletonCache=new HashMap();
       public Object getBean(String name)throws BeansException{
           return getBean(name,null,null);
       }
    ...
       public Object getBean(String name,Class requiredType,Object[] args)throws BeansException{
          //对传入的Bean name稍做处理，防止传入的Bean name名有非法字符(或则做转码)
          String beanName=transformedBeanName(name);
          Object bean=null;
          //手工检测单例注册表
          Object sharedInstance=null;
          //使用了代码锁定同步块，原理和同步方法相似，但是这种写法效率更高
          synchronized(this.singletonCache){
             sharedInstance=this.singletonCache.get(beanName);
           }
          if(sharedInstance!=null){
             ...
             //返回合适的缓存Bean实例
             bean=getObjectForSharedInstance(name,sharedInstance);
          }else{
            ...
            //取得Bean的定义
            RootBeanDefinition mergedBeanDefinition=getMergedBeanDefinition(beanName,false);
             ...
            //根据Bean定义判断，此判断依据通常来自于组件配置文件的单例属性开关
            //<bean id="date" class="java.util.Date" scope="singleton"/>
            //如果是单例，做如下处理
            if(mergedBeanDefinition.isSingleton()){
               synchronized(this.singletonCache){
                //再次检测单例注册表
                 sharedInstance=this.singletonCache.get(beanName);
                 if(sharedInstance==null){
                    ...
                   try {
                      //真正创建Bean实例
                      sharedInstance=createBean(beanName,mergedBeanDefinition,args);
                      //向单例注册表注册Bean实例
                       addSingleton(beanName,sharedInstance);
                   }catch (Exception ex) {
                      ...
                   }finally{
                      ...
                  }
                 }
               }
              bean=getObjectForSharedInstance(name,sharedInstance);
            }
           //如果是非单例，即prototpye，每次都要新创建一个Bean实例
           //<bean id="date" class="java.util.Date" scope="prototype"/>
           else{
              bean=createBean(beanName,mergedBeanDefinition,args);
           }
    }
    ...
       return bean;
    }
    }   

刚才的源码中，大家真正要记住的是Spring对bean实例的创建是采用单例注册表的方式进行实现的，而这个注册表的缓存是HashMap对象，如果配置文件中的配置信息不要求使用单例，Spring会采用新建实例的方式返回对象实例

如果还对 Spring 的AOP、IOC、ORM感兴趣的，可以看看我写的轻量级框架 swift-framework 框架，简单易懂，而且可用。包含了Spring 中的基本核心功能。

Git 地址 ：https://github.com/zwwjava/swift-framework