设计模式 : 单例设计模式

23种设计模式的分类 :

创建型模式:
        单例模式、工厂模式、抽象工厂模式、建造者模式、原型模式.

结构型模式:
        适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式.

行为型模式:

        模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式、状态模式、策略模式、职责链模式、访问者模式.

单例设计模式 :

★ . 核心作用 :保证一个类只有一个实例,并且提供一个访问该实例的全局访问点 .

★ . 常见应用场景 : 

① . windows中的任务管理器、回收站.
② . 项目中,读取配置文件的类,一般也只有一个对象.没有必要每次使用配置文件数据,就new一个对象去读取.
③ . 网站的计数器,一般也是采用单例模式实现,否则难以同步.
④ . 应用程序的日志应用,一般都使用单例实现,这一般是由于共享的日志文件一直处于打开状态,因为只能有一个实例去操作,否则内容不好追加.
⑤ . 数据库连接池的设计一般也是采用单例模式,因为数据库连接是一种数据库资源.
⑥ . 操作系统的文件系统,也是一个单例模式.
⑦ . Application也是单例的典型应用(Servlet编程中会涉及到).
⑧ . 在Spring中,每个Bean默认就是单例的,这样做的优点是Spring容器可以管理.
⑨ . 在Servlet编程中,每个Servlet也是单例.
⑩ . 在Spring MVC/struts1框架中,控制器对象也是单例.

★ .  单例模式的优点 :

        由于单例模式只生成一个实例,减少了系统性能开销,当一个对象的产生需要比较多的资源时,如读取配置、产生其他依赖对象时,则可以通过在应用启动时直接产生一个单例对象,然后永久驻留内存的方式来解决
        单例模式可以在系统设置全局的访问点,优化共享资源访问,例如可以设计一个单例类,负责所有数据表的映射处理.

★ .  常见的五种单例模式实现方式 :

主要 :
         饿汉式(线程安全,调用效率高.但是,不能延时加载)

        懒汉式(线程安全,调用效率不高.但是,可以延时加载)

其他 :

        双重检测锁式(由于JVM底层内部模型原因，偶尔会出问题。不建议使用）

        静态内部类式(线程安全,调用效率高.但是,可以延时加载)

        枚举单例(线程安全,调用效率高,不能延时加载)

具体实现:

饿汉式单例模式 :

package cn.demo;

/**
 * 饿汉式单例模式
 * @author Miao
 *
 */
public class SingletonDemo1 {
	//类加载时就创建对象
	private static final SingletonDemo1 INSTANCE = new SingletonDemo1();
	
	//构造器私有化
	private SingletonDemo1(){
	}
	
	//方法不同步,执行效率高,不支持延时加载
	public static SingletonDemo1 getInstance(){
		return INSTANCE;
	}
}

懒汉式单例模式 :

package cn.demo;

/**
 * 懒汉式单例模式
 * @author Miao
 *
 */
public class SingletonDemo2 {
	
	//类加载时不创建对象
	private static SingletonDemo2 instance;
	
	//构造器私有化
	private SingletonDemo2 (){
	}
	
	//方法同步,执行效率不高,支持延时加载
	public static synchronized SingletonDemo2 getInstance(){
		if(instance == null) {
			instance = new SingletonDemo2();
		}
		return instance;
	}
}

静态内部类实现单例模式 :

package cn.demo;

/**
 * 静态内部类实现单例模式
 * @author Miao
 *
 */
public class SingletonDemo3 {
	
	//静态内部类,类加载时不创建单例对象
	private static class SingletonInnerClass {
		private static final SingletonDemo3 INSTANCE = new SingletonDemo3();
	}
	
	//构造器私有化
	private SingletonDemo3(){
	}
	
	//方法不同步,执行效率高,支持延时加载
	public static SingletonDemo3 getInstance(){
		return SingletonInnerClass.INSTANCE;
	}
}

枚举类型单例模式 :

package cn.demo;

/**
 * 枚举类型单例模式
 * @author Miao
 *
 */
public enum SingletonDemo4 {
	
	INSTANCE; //枚举类型都是单例模式
	
	public void operation(){
		//do something ...
	}
}

双重检测锁单例模式 :

package cn.demo;

/**
 * 双重检测锁单例模式
 * @author Miao
 *
 */
public class SingletonDemo5 {
	private static SingletonDemo5 instance = null;
	
	public static SingletonDemo5 getInstance() {
		if(instance == null) {
			SingletonDemo5 sc;
			synchronized (SingletonDemo5.class) {
				sc = instance;
				if(sc == null) {
					synchronized (SingletonDemo5.class) {
						if(sc == null) {
							sc = new SingletonDemo5();
						}
					}
					instance = sc;
				}
			}
		}
		return instance;
	}
	
	private SingletonDemo5(){
	}
}

★ . 如何破解单例模式

其实单例模式也是可以通过反射和序列化进行破解的 , 下面以饿汉式单例模式为例说明如何进行破解 :

饿汉式单例模式 :

package cn.demo;

import java.io.Serializable;

/**
 * 饿汉式单例模式
 * @author Miao
 *
 */
public class SingletonDemo6 implements Serializable{
	//类加载时就创建对象
	private static final SingletonDemo6 INSTANCE = new SingletonDemo6();
	
	//构造器私有化
	private SingletonDemo6(){
	}
	
	//方法不同步,执行效率高,不支持延时加载
	public static SingletonDemo6 getInstance(){
		return INSTANCE;
	}
}

破解 :

package cn.demo;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * 利用反射或序列化破解单例模式的方法
 * @author Miao
 *
 */
public class Client {

	public static void main(String[] args) throws Exception {
		SingletonDemo6 s1 = SingletonDemo6.getInstance();
		SingletonDemo6 s2 = SingletonDemo6.getInstance();
		
		System.out.println(s1);
		System.out.println(s2);
		
		//利用反射破解单例
//		Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("cn.demo.SingletonDemo6");
//		Constructor<SingletonDemo6> c = (Constructor<SingletonDemo6>) clazz.getDeclaredConstructor(null);
//		c.setAccessible(true);
//		SingletonDemo6 s3 = c.newInstance();
//		SingletonDemo6 s4 = c.newInstance();
		
		//利用反序列化破解单例
		File file = new File("e:\\temp\\a.txt");
		ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file));
		oos.writeObject(s1);
		oos.close();
		
		ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file));
		SingletonDemo6 s3 = (SingletonDemo6) ois.readObject();
		ois.close();
		
		System.out.println(s3);
	}

}

★ . 如何防止破解单例模式 :

下面以饿汉式单例模式为例来说一下如何防止利用反射和反序列化破解单例模式 :

package cn.demo;

import java.io.ObjectStreamException;
import java.io.Serializable;

/**
 * 饿汉式单例模式(如何防止反射和反序列化)
 * @author Miao
 *
 */
public class SingletonDemo6 implements Serializable{
	//类加载时就创建对象
	private static final SingletonDemo6 INSTANCE = new SingletonDemo6();
	
	//构造器私有化
	private SingletonDemo6(){
		//防止利用反射创建实例
		if(INSTANCE != null) {
			throw new RuntimeException();
		} 
	}
	
	//方法不同步,执行效率高,不支持延时加载
	public static SingletonDemo6 getInstance(){
		return INSTANCE;
	}
	
	//反序列化时,如果定义了readResolve()则直接返回此方法指定的对象,而不要单独再创建新对象!
	public Object readResolve() throws ObjectStreamException{
		return INSTANCE;
	}
}