单例模式的破坏及任何防止被破坏

        常用的单例模式有懒汉式、饿汉式两种情况。实际的应用场景也是很常见，好比如数据库连接池的设计，还有Windows的Task Manager（任务管理器）等。

        所谓单例模式就是，某一个类只能有一个实例，实现的核心就是将类的构造函数私有化，只能由该类创建对象，其他对象就不能调用该类的构造函数，即不能创建对象了。

现在看一个问题：对象的创建方式有哪几种？ 
        四种：new 、克隆、序列化、反射。

        其实上面的说法有点问题，改为：……其他对象就不能调用该类的构造函数，即不能通过new 来创建对象了。那么是否还有可以通过其他的三种方式创建对象呢，即其他三种方式会不会破坏单例模式呢？

克隆可以对单例模式的破坏

       由克隆我们可以想到原型模式，原型模式就是通过clone方法实现对象的创建的，clone方式是Object方法，每个对象都有，那么使用一个单例模式类的对象，调用clone方法，再创建一个新的对象了，那岂不是上面说的单例模式失效了。当然答案是否定，某一个对象直接调用clone方法，会抛出异常，即并不能成功克隆一个对象。调用该方法时，必须实现一个Cloneable 接口。这也就是原型模式的实现方式。还有即如果该类实现了cloneable接口，尽管构造函数是私有的，他也可以创建一个对象。即clone方法是不会调用构造函数的，他是直接从内存中copy内存区域的。

解决办法：单例模式的类不实现cloneable接口。

序列化可以对单例模式的破坏

        一是可以实现数据的持久化；二是可以对象数据的远程传输。 如果过该类implements Serializable，那么就会在反序列化的过程中再创一个对象。

/**
 * 
 * @author 小钦
 *懒汉式
 */
public class Singleton implements Serializable {
    
	private static volatile Singleton instance;
	private Singleton(){}
	public static Singleton getInstance(){
		if(instance==null){
			synchronized (Singleton.class) {
				if(instance==null){
					instance=new Singleton();
				}
			}
		}
		return instance;
	}

}

测试类：

public class SerializableDemo1 {
	 //为了便于理解，忽略关闭流操作及删除文件操作。真正编码时千万不要忘记
    //Exception直接抛出
    public static void main(String[] args) throws IOException, ClassNotFoundException {
    	
    	//Write Obj to file
		ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("testFile"));
		oos.writeObject(Singleton.getInstance());
		//Read Obj from file
		File file=new File("testFile");
		ObjectInputStream ois=new ObjectInputStream(new FileInputStream(file));
		Singleton newInstance=(Singleton)ois.readObject();
		 //判断是否是同一个对象
		System.out.println(newInstance==Singleton.getInstance());
	}
}

//输出的是false

       序列化会通过反射调用无参数的构造方法创建一个新的对象。

       通过对Singleton的序列化与反序列化得到的对象是一个新的对象，这就破坏了Singleton的单例性。

解决办法：在反序列化时，指定反序化的对象实例。即只要在Singleton类中定义readResolve就可以解决该问题：

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

主要在Singleton中定义readResolve方法，并在该方法中指定要返回的对象的生成策略，就可以防止单例被破坏。

反射可以对单例模式的破坏

       反射是可以获取类的构造函数，再加一行 setAccessible(true);就可以调用私有的构造函数，创建对象了。

/**
 * 
 * @author 小钦
 *懒汉式
 */
public class Singleton  {
    
	private static volatile Singleton instance;
	private Singleton(){}
	public static Singleton getInstance(){
		if(instance==null){
			synchronized (Singleton.class) {
				if(instance==null){
					instance=new Singleton();
				}
			}
		}
		return instance;
	}
	

}

测试类：

public class TestDemo {
  public static void main(String[] args) throws Exception, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
	Singleton s1=Singleton.getInstance();
	Singleton s2=Singleton.getInstance();
	Constructor constructor=Singleton.class.getDeclaredConstructor(null);
	 constructor.setAccessible(true);
     Singleton s3 =(Singleton) constructor.newInstance(null);

     System.out.println(s1.hashCode());
     System.out.println(s2.hashCode());
     System.out.println(s3.hashCode());
}
}

       //输出：366712642
                    366712642
                    1829164700

解决办法：当第二次调用构造函数时抛出异常。

/**
 * 
 * @author 小钦
 *懒汉式
 */
public class Singleton  {
   
	private static volatile Singleton instance;
	private static boolean flag=true;
	private Singleton(){
		if(flag){
			flag=false;
		}
		else {
			throw new RuntimeException("单例模式遇到攻击，第二个对象未创建成功");
		}
		
	}
	public static Singleton getInstance(){
		if(instance==null){
			synchronized (Singleton.class) {
				if(instance==null){
					instance=new Singleton();
				}
			}
		}
		return instance;
	}
	
	
}