Spring的单例模式底层实现

第一种称为饿汉式单例，第二种称为懒汉式单例。至于为什么起这个名字，自己好好想想吧。
饿汉式单例在自己被加载时就将自己实例化，如果从资源利用效率角度来讲，比懒汉式单例类稍差些。但是从速度和反应时间角度来讲，则比懒汉式要稍好些。

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

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

[java] view plain copy

1. Import java.util.HashMap;    
2. Public class RegSingleton{    
3.    Static private HashMap registry=new HashMap();    
4.    //静态块，在类被加载时自动执行    
5.     Static{    
6.      RegSingleton rs=new RegSingleton();    
7.      Registry.put(rs.getClass().getName(),rs);    
8.    }    
9. //受保护的默认构造函数，如果为继承关系，则可以调用，克服了单例类不能为继承的缺点    
10. Protected RegSingleton(){}    
11. //静态工厂方法，返回此类的唯一实例    
12. public static RegSingleton getInstance(String name){    
13.     if(name==null){    
14.       name=” RegSingleton”;    
15.     }if(registry.get(name)==null){    
16.       try{    
17.           registry.put(name,Class.forName(name).newInstance());    
18.        }Catch(Exception ex){ex.printStackTrace();}    
19.     }    
20.     Return (RegSingleton)registry.get(name);    
21. }    
22. }     

下面我们来看看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框架对单例的支持是采用单例注册表的方式进行实现的，源码如下：

[java] view plain copy

1. public abstract class AbstractBeanFactory implements ConfigurableBeanFactory{    
2.    /**  
3.     * 充当了Bean实例的缓存，实现方式和单例注册表相同  
4.     */    
5.    private final Map singletonCache=new HashMap();    
6.    public Object getBean(String name)throws BeansException{    
7.        return getBean(name,null,null);    
8.    }    
9. ...    
10.    public Object getBean(String name,Class requiredType,Object[] args)throws BeansException{    
11.       //对传入的Bean name稍做处理，防止传入的Bean name名有非法字符(或则做转码)    
12.       String beanName=transformedBeanName(name);    
13.       Object bean=null;    
14.       //手工检测单例注册表    
15.       Object sharedInstance=null;    
16.       //使用了代码锁定同步块，原理和同步方法相似，但是这种写法效率更高    
17.       synchronized(this.singletonCache){    
18.          sharedInstance=this.singletonCache.get(beanName);    
19.        }    
20.       if(sharedInstance!=null){    
21.          ...    
22.          //返回合适的缓存Bean实例    
23.          bean=getObjectForSharedInstance(name,sharedInstance);    
24.       }else{    
25.         ...    
26.         //取得Bean的定义    
27.         RootBeanDefinition mergedBeanDefinition=getMergedBeanDefinition(beanName,false);    
28.          ...    
29.         //根据Bean定义判断，此判断依据通常来自于组件配置文件的单例属性开关    
30.         //<bean id="date" class="java.util.Date" scope="singleton"/>    
31.         //如果是单例，做如下处理    
32.         if(mergedBeanDefinition.isSingleton()){    
33.            synchronized(this.singletonCache){    
34.             //再次检测单例注册表    
35.              sharedInstance=this.singletonCache.get(beanName);    
36.              if(sharedInstance==null){    
37.                 ...    
38.                try {    
39.                   //真正创建Bean实例    
40.                   sharedInstance=createBean(beanName,mergedBeanDefinition,args);    
41.                   //向单例注册表注册Bean实例    
42.                    addSingleton(beanName,sharedInstance);    
43.                }catch (Exception ex) {    
44.                   ...    
45.                }finally{    
46.                   ...    
47.               }    
48.              }    
49.            }    
50.           bean=getObjectForSharedInstance(name,sharedInstance);    
51.         }    
52.        //如果是非单例，即prototpye，每次都要新创建一个Bean实例    
53.        //<bean id="date" class="java.util.Date" scope="prototype"/>    
54.        else{    
55.           bean=createBean(beanName,mergedBeanDefinition,args);    
56.        }    
57. }    
58. ...    
59.    return bean;    
60. }    
61. }