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

太过爱你忘了你带给我的痛 2021-09-27 13:58 431阅读 0赞

常用的单例模式有懒汉式、饿汉式两种情况。实际的应用场景也是很常见，好比如数据库连接池的设计，还有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;
    	}
    	
    	
    }