Bean的概念

是Spring框架在运行时管理的对象，是任何引用程序的基本构建块。

Bean的属性

id属性：Bean的唯一标志名，必须以字母开头且不包含特殊字符
class属性：用来定义类的全限定名（包名 + 类名）
name属性：用来为Bean指定一个或多个别名，且能包含特殊字符，如果没有id，name相当于id。
scope属性
- singleton（单例）：默认值
- prototype（多例）
- request：Web项目中，把创建的对象放到Request域中
- session：Web项目中，把创建的对象放到Session域中

单例模式定义

单例模式是指在内存中只会创建且仅创建一次对象的设计模式。在程序中多次使用同一个对象且作用相同时，为了防止频繁地创建对象使得内存飙升，单例模式可以让程序仅在内存中创建一个对象，让所有需要调用的地方都共享这一单例对象。在Spring中定义Bean的时候可以指定其scope(属性)。如果是Singleton，就会创建在Spring容器内创建一个全局唯一的单例Bean。需要注意的是，Spring中的单例跟设计模式中的单例还是有区别的，在设计模式中，相同的类加载器只能创建一个实例，但是在Spring中，是通过Bean的id来校验唯一性，就是说，同一个类可以创建多个id不同的实例。

设计模式的单例

饿汉式

饿汉式在类加载时已经创建好该对象，在程序调用时直接返回该单例对象即可，即我们在编码时就已经指明了要马上创建这个对象，不需要等到被调用时再去创建。

优点：这种写法比较简单，就是在类装载的时候就完成实例化。避免了线程同步问题。

缺点：在类装载的时候就完成实例化，没有达到Lazy Loading的效果。如果从始至终从未使用过这个实例，则会造成内存的浪费。

public class Singleton {
    //在类初始化时就实例化好了当前对象
    private static Singleton instance = new Singleton();
  	
    //私有无参构造防止类在外部被实例化
    private Singleton(){}
    
    public static Singleton getInstance() {
        return instance;
    }
}

懒汉式(线程不安全)

这种写法起到了懒加载的效果，但是只能在单线程下使用。如果在多线程下，一个线程进入了判断语句块，还未来得及往下执行，另一个线程也通过了这个判断语句，这时便会产生多个实例。所以在多线程环境下不可使用这种方式。

public class Singleton {
    private static Singleton instance;
  	
    private Singleton(){}
    
    public static Singleton getInstance() {
    	if(instance == null) instance = new Singleton();
        return instance;
    }
}

懒汉式(线程安全)

优点：线程安全

缺点：效率太低了，每个线程在想获得类的实例时候，执行getInstance()方法都要进行同步。而其实这个方法只执行一次实例化代码就够了，后面的想获得该类实例，直接return就行了。方法进行同步效率太低要改进。

public class Singleton {
    private static Singleton instance;
  	
    private Singleton(){}
    
    public static synchronized Singleton getInstance() {
    	if(instance == null) instance = new Singleton();
        return instance;
    }
}

双重检查锁（DCL）

volatile是Java提供的一种轻量级的同步机制。Java 语言包含两种内在的同步机制：同步块（或方法）和 volatile 变量，相比于synchronized（synchronized通常称为重量级锁），volatile更轻量级，因为它不会引起线程上下文的切换和调度。但是volatile 变量的同步性较差（有时它更简单并且开销更低），而且其使用也更容易出错。 优点：线程安全；延迟加载；效率较高。

public class Singleton {
    private volatile static Singleton instance;
  	
    private Singleton(){}
    
    public static Singleton getInstance() {
    	if(instance == null){
    		synchronized(Singleton.class){
    			if(instance == null){
    				instance = new Singleton();
    			}
    		}
    	}
        return instance;
    }
}

静态内部类

这种方式跟饿汉式方式采用的机制类似，但又有不同。两者都是采用了类装载的机制来保证初始化实例时只有一个线程。不同的地方在饿汉式方式是只要Singleton类被装载就会实例化，没有Lazy-Loading的作用，而静态内部类方式在Singleton类被装载时并不会立即实例化，而是在需要实例化时，调用getInstance方法，才会装载SingletonInstance类，从而完成Singleton的实例化。类的静态属性只会在第一次加载类的时候初始化，所以在这里，JVM帮助我们保证了线程的安全性，在类进行初始化时，别的线程是无法进入的。优点：避免了线程不安全，延迟加载，效率高。

public class Singleton {

    private Singleton(){}
    
    private static class SingletonInstance{
    	private static final Singleton INSTANCE = new singleton();
    }
   
    public static Singleton getInstance() {
        return SingletonInstance.INSTANCE;
    }
}

枚举

不仅能避免多线程同步问题，而且还能防止反序列化重新创建新的对象。

public enum Singleton{
	INSTANCE;
}

Spring源码

关于Spring中的单例模式主要就看org.springframework.beans.factory.support.AbstractBeanFactory。会从getBean()方法中调用doGetBean()方法，而在doGetBean()中就是判断bean的属性去决定单例或者多例，这里主要研究单例。

其次在看org.springframework.beans.factory.support.DefaultSingletonBeanRegistry。在这里面可以观察到getSingleton()的三个重载方法。还有其方法内有雾个很重要的属性。

/**
 * 在一个CurrentHashMap中存储beanName到beanInstance的映射关系，
 * 从代码可以看出，Spring在创建一个单例bean的时候，会先通过beanName从一级缓存中获取，
 * 当获取不到是才会去调用回调函数createBean进行实例创建，
 * 在createBean中调用doCreateBean，在doCreateBean中调用instantiateBean()方法。
 */
private final Map<String, Object> singletonObjects = new ConcurrentHashMap(256);
//二级缓存
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap(16);
//三级缓存
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap(16);

这个getSingleton()重载方法就用到了双重检查锁

至于bean的加载、初始化等等还是得看大牛们的文章此篇我只去了解了Spring的单例设计模式，但对于bean的过程我还是达不到那个能看得懂源码的地步。感谢观看。

【Spring源码设计模式】单例模式外带设计模式的单例模式