spring怎么实现单例模式

spring怎么实现单例模式_弹指天下-CSDN博客_spring 单例模式

在Spring中,bean可以被定义为两种模式:prototype(多例)和singleton(单例)

singleton(单例):只有一个共享的实例存在,所有对这个bean的请求都会返回这个唯一的实例。

prototype(多例):对这个bean的每次请求都会创建一个新的bean实例,类似于new。

Spring bean 默认是单例模式

简单来说,spring中的单例是通过单例注册表实现的。

实战演示:

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

在配置文件中,修改这句代码为:

在测试类中,修改代码为:

         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);

结果为:

在这里插入图片描述
结论:二个变量指向一个对象。

将配置文件改为:

其他的不变,运行测试类,结果为:

spring怎么实现单例模式_第1张图片
结论:每次访问bean,均创建一个新实例。

Spring怎么实现单例模式

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

import java.util.HashMap;

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 singletonObjects = new ConcurrentHashMap(256);
    private final Map> singletonFactories = new HashMap(16);
    private final Map 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
————————————————
版权声明:本文为CSDN博主「斗者_2013」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:spring怎么实现单例模式_弹指天下-CSDN博客_spring 单例模式

你可能感兴趣的:(spring,spring,单例模式,java)