【Spring】Spring中实现单例模式

1.spring中的单例是通过单例注册表实现的

原文链接

在Spring中，bean可以被定义为两种模式：prototype（多例）和singleton（单例），默认单例模式。

singleton（单例）：只有一个共享的实例存在，所有对这个bean的请求都会返回这个唯一的实例。

prototype（多例）：对这个bean的每次请求都会创建一个新的bean实例，类似于new。

2.实战演示

代码详见上一篇文章中的代码。

在配置文件中，修改这句代码为：

<bean id="hi" class="com.test.Hi" init-method="init" scope="singleton">

在测试类中，修改代码为：

ApplicationContext context = new FileSystemXmlApplicationContext("applicationContext.xml");
Hi hi1 = (Hi) context.getBean("hi");
Hi hi2 = (Hi) context.getBean("hi");
System.out.println(hi1);
System.out.println(hi2);

结果为：

结论：二个变量指向一个对象。

将配置文件改为：

<bean id="hi" class="com.test.Hi" init-method="init" scope="prototype">

其他的不变，运行测试类，结果为：

结论：每次访问bean，均创建一个新实例。

3.Spring怎么实现单例模式

单例模式也属于创建型模式，所谓单例，顾名思义，所指的就是单个实例，也就是说要保证一个类仅有一个实例。
单例模式有以下的特点：
①单例类只能有一个实例
②单例类必须自己创建自己的唯一实例
③单例类必须给所有其他对象提供这一实例
我们可以使用另外一种特殊化的单例模式，它被称为单例注册表。

public class RegSingleton{  
   private static  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会才用单例模式进行创建。

(仅为Spring2.0支持)

以上三种创建对象的方式是完全相同的，容器都会向客户返回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定义判断，此判断依据通常来自于组件配置文件的单例属性开关  
        //``  
        //如果是单例，做如下处理  
        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;  
}  
}   

继续分析单例的获取流程：

@Nullable
    protected Object getSingleton(String beanName, boolean allowEarlyReference) {
        Object singletonObject = this.singletonObjects.get(beanName);
        if (singletonObject == null && this.isSingletonCurrentlyInCreation(beanName)) {
            Map var4 = this.singletonObjects;
            synchronized(this.singletonObjects) {
                singletonObject = this.earlySingletonObjects.get(beanName);
                if (singletonObject == null && allowEarlyReference) {
                    ObjectFactory<?> singletonFactory = (ObjectFactory)this.singletonFactories.get(beanName);
                    if (singletonFactory != null) {
                        singletonObject = singletonFactory.getObject();
                        this.earlySingletonObjects.put(beanName, singletonObject);
                        this.singletonFactories.remove(beanName);
                    }
                }
            }
        }

        return singletonObject;
    }

这里涉及到三个单例容器：
singletonObjects
earlySingletonObjects
singletonFactories

public class DefaultSingletonBeanRegistry extends SimpleAliasRegistry implements SingletonBeanRegistry {
    private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
    private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);
    private final Map<String, Object> earlySingletonObjects = new HashMap(16);
}

三级缓存
通过分析源码：
单例的获取顺利是singletonObjects ——》earlySingletonObjects ——》singletonFactories 这样的三级层次。

我们发现，在singletonObjects 中获取bean的时候，没有使用synchronized关键字，而在singletonFactories 和earlySingletonObjects 中的操作都是在synchronized代码块中完成的，正好和他们各自的数据类型对应，singletonObjects 使用的使用ConcurrentHashMap线程安全，而singletonFactories 和earlySingletonObjects 使用的是HashMap，线程不安全。

从字面意思来说：singletonObjects指单例对象的cache，singletonFactories指单例对象工厂的cache，earlySingletonObjects指提前曝光的单例对象的cache。以上三个cache构成了三级缓存，Spring就用这三级缓存巧妙的解决了循环依赖问题。

另外,源码中这三个容器的初始容积也做了配置，分别是256,16,16，也是值得分析和借鉴的。

单例的注册：
DefaultSingletonBeanRegistry类中:

  public void registerSingleton(String beanName, Object singletonObject) throws IllegalStateException {
        Assert.notNull(beanName, "Bean name must not be null");
        Assert.notNull(singletonObject, "Singleton object must not be null");
        Map var3 = this.singletonObjects;
        synchronized(this.singletonObjects) {
            Object oldObject = this.singletonObjects.get(beanName);
            if (oldObject != null) {
                throw new IllegalStateException("Could not register object [" + singletonObject + "] under bean name '" + beanName + "': there is already object [" + oldObject + "] bound");
            } else {
                this.addSingleton(beanName, singletonObject);
            }
        }
    }

 protected void addSingleton(String beanName, Object singletonObject) {
        Map var3 = this.singletonObjects;
        synchronized(this.singletonObjects) {
            this.singletonObjects.put(beanName, singletonObject);
            this.singletonFactories.remove(beanName);
            this.earlySingletonObjects.remove(beanName);
            this.registeredSingletons.add(beanName);
        }
    }

向一级缓存中加入单例对象，同时，移除二级缓存，三级缓存中的单例对象。
并向注册登记表registeredSingletons中，记录单例的名称beanName。
由于容器对象都是map对象，所以能自动保存通一个beanName保存的对象唯一。

这里也可以知道了容器是什么？
spring中的存放bean的容器就是ConcurrentHashMap