Spring的单例模式底层实现

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

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

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

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

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

scope="singleton"/> (仅为Spring2.0支持)

singleton="true"/>

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

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定义判断，此判断依据通常来自于组件配置文件的单例属性开关
         //
         //如果是单例，做如下处理
         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实例
        //
        else{
           bean=createBean(beanName,mergedBeanDefinition,args);
        }
 }
 ...
    return bean;
 }
 }