java设计模式——单例模式(二)
破坏单例模式
上一章节，介绍了单例模式的几种方式，这次来学习一波我们创建的单例模式是否安全，能不能破坏。换句话说，也就是在程序运行中，不止有一个实例。
一. 序列化，反序列化破坏
以饿汉式的单例模式为例，先看下面的代码：
/** * @program: designModel * @description: 饿汉式，与懒汉式最大的区别，就是延时加载，但是饿汉式如果不用该实例，会占用资源 * @author: YuKai Fan * @create: 2018-12-04 16:57 **/ public class HungrySingleton implements Serializable { private final static HungrySingleton hungrySingleton; static { hungrySingleton = new HungrySingleton(); } private HungrySingleton() { } } public static HungrySingleton getInstance() { return hungrySingleton; } }
/** * @program: designModel * @description: * @author: YuKai Fan * @create: 2018-12-04 14:07 **/ public class Test { public static void main(String[] args) throws IOException, ClassNotFoundException { HungrySingleton instance = HungrySingleton.getInstance(); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file")); oos.writeObject(instance); File file = new File("singleton_file"); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); HungrySingleton newInstance = (HungrySingleton)ois.readObject(); System.out.println(instance); System.out.println(newInstance); System.out.println(instance == newInstance); } }
上面这段代码的输出结果是
可以看出，产生了两种不同的实例，并输出false。
那么为什么会这样，在输出流，和输入流的过程中，会将类进行序列化，但是输出的实例与输入的实例确实不一样的，这样单例模式就别破坏了。
现在改动一下上面的饿汉式单例模式代码,添加一个Object类型的readResolve方法，然后返回这个实例：
/** * @program: designModel * @description: 饿汉式，与懒汉式最大的区别，就是延时加载，但是饿汉式如果不用该实例，会占用资源 * @author: YuKai Fan * @create: 2018-12-04 16:57 **/ public class HungrySingleton implements Serializable { private final static HungrySingleton hungrySingleton; static { hungrySingleton = new HungrySingleton(); } private HungrySingleton() { if (hungrySingleton != null) { throw new RuntimeException("单例构造器禁止反射调用"); } } public static HungrySingleton getInstance() { return hungrySingleton; } private Object readResolve() { return hungrySingleton; } }
在运行一下，得到的结果为：
可以看到，结果是true，只存在一个实例。
这其中的原理需要来解读ObjectInputStream的readObject() 源码才能知晓。
//ObjectInputStream中的readObject方法，会根据实例类中的是否存在readResolve方法，来返回最终的实例是原来的，还是创建新的 方法readObject: try { Object obj = readObject0(false); handles.markDependency(outerHandle, passHandle); } 方法readObject0: case TC_OBJECT: return checkResolve(readOrdinaryObject(unshared)); 方法readOrdinaryObject: Object obj; try { //判断实例类是不是序列化的 obj = desc.isInstantiable() ? desc.newInstance() : null; } //如果是序列化的，在判断是否有readResolve方法 if (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) { Object rep = desc.invokeReadResolve(obj);} 方法hasReadResolveMethod： /** * Returns true if represented class is serializable or externalizable and * defines a conformant readResolve method. Otherwise, returns false. * 这个注释就是表达了，是否存在这个readResolve方法 */ boolean hasReadResolveMethod() { return (readResolveMethod != null); } 方法invokeReadResolve: if (readResolveMethod != null) { try { //利用反射的invoke，来调用实例中的readResolve方法，返回实例 return readResolveMethod.invoke(obj, (Object[]) null); }
上面的源码了解到，为什么只在代码中添加了一个readResolve()方法，就解决了序列化攻击。
在readObject中的一层层封装的方法中，readOrdinaryObject()会判断类是否序列化，如果是，则调用hasReadResolveMethod()判断是否有readResolve()方法，如果存在readResolve()方法就调用invokeReadResolve()方法，利用反射来获取类中readResolve方法返回的实例。
二. 反射攻击破坏
之前学过单例模式，知道了。在单例模式中，通过创建一个私有的无参构造器在阻止类在其他地方被创建，从而保证只有一个实例。但是，通过反射的方式，可以改变构造器的类型，即改为public。看下面代码：
/** * @program: designModel * @description: 通过反射，来获取新的实例，破坏单例模式 * @author: YuKai Fan * @create: 2018-12-05 14:55 **/ public class Test3 { public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException, ClassNotFoundException { //饿汉式 Class objectClass = HungrySingleton.class; Constructor constructor = objectClass.getDeclaredConstructor(); //通过反射，将类的构造器权限改为了public，这样就这样new出新的实例 constructor.setAccessible(true); HungrySingleton instance = HungrySingleton.getInstance(); HungrySingleton newInstance = (HungrySingleton) constructor.newInstance(); System.out.println(instance); System.out.println(newInstance); System.out.println(instance == newInstance); } }
得到的结果是：false
从上面代码可以看到，利用反射的getDeclaredConstructor()方法将构造器的权限修改为public，这样就可以创建不同的实例了
那么怎么样来阻止呢？
看下修改后的，饿汉式单例模式的代码：直接在私有构造器中加上一个判断即可
/** * @program: designModel * @description: 饿汉式，与懒汉式最大的区别，就是延时加载，但是饿汉式如果不用该实例，会占用资源 * @author: YuKai Fan * @create: 2018-12-04 16:57 **/ public class HungrySingleton implements Serializable { private final static HungrySingleton hungrySingleton; static { hungrySingleton = new HungrySingleton(); } private HungrySingleton() { if (hungrySingleton != null) { throw new RuntimeException("单例构造器禁止反射调用"); } } public static HungrySingleton getInstance() { return hungrySingleton; } private Object readResolve() { return hungrySingleton; } }
上面的原理，是用饿汉式的特点，在类加载的时候就创建了实例，这样即使改变了构造器的权限也无法判断成功，因为此时实例已经创建了，无法在调用构造器方法。
但是这仅仅只适用于饿汉式，和静态内部类的方式。如果单例模式是延时加载，那就跟代码的执行顺序有关了。看下面这段代码：
懒汉式单例模式：
/** * @program: designModel * @description: 懒汉单例,懒汉式注重的就是延迟加载，当在使用到这个实例的时候才会初始化 * @author: YuKai Fan * @create: 2018-12-04 14:04 **/ public class LazySingleton { private static LazySingleton lazySingleton = null; // private static boolean flag = true; private LazySingleton() { /*if (flag) { flag = false; } else { throw new RuntimeException("单例构造器禁止反射调用"); }*/ if (lazySingleton != null) { throw new RuntimeException("单例构造器禁止反射调用"); } } //在代码块上加锁，让这个方法每次只能有一个线程访问,这样只会产生一个实例 //这种方式，锁的是class类，存在加锁和解锁的开销，对性能有一定影响 public static LazySingleton getInstance() { synchronized(LazySingleton.class) { if (lazySingleton == null) { lazySingleton = new LazySingleton(); } } return lazySingleton; } }
/** * @program: designModel * @description: 通过反射，来获取新的实例，破坏单例模式 * @author: YuKai Fan * @create: 2018-12-05 14:55 **/ public class Test3 { public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException, ClassNotFoundException { Class objectClass = LazySingleton.class; Constructor constructor = objectClass.getDeclaredConstructor(); //通过反射，将类的构造器权限改为了public，这样就这样new出新的实例 constructor.setAccessible(true); //如果按照上面两种方式在类加载的时候判断，依旧会就会产生不同的实例 *//* 可以看出，这跟创建实例的顺序是有关的， 如果先执行LazySingleton.getInstance()方法，由于getInstance是同步的，就会先拿到实例，后面反射在获取实例时，此时单例对象已经存在，就会抛出异常 在多线程环境下，如果获取单例一个线程后执行，反射单例一个线程先执行，那就会产生两个不同的实例 *//* LazySingleton newInstance = (LazySingleton) constructor.newInstance(); LazySingleton instance = LazySingleton.getInstance(); System.out.println(instance); System.out.println(newInstance); System.out.println(instance == newInstance); } }
根据上面代码的注释看得出，在延时加载的情况下单例模式的反射攻击并没有有效的防止措施。也不好在私有的构造器中添加判断。那么下面介绍一种推荐的单例模式，利用枚举类的特性来，实现单例。
枚举类：
/** * @program: designModel * @description: 使用枚举实现单例 * @author: YuKai Fan * @create: 2018-12-05 15:55 **/ public enum EnumInstance { INSTANCE{ protected void printTest() { System.out.println("Print Test"); } }; protected abstract void printTest(); private Object data; public Object getData() { return data; } public void setData(Object data) { this.data = data; } public static EnumInstance getInstance() { return INSTANCE; } }
Test：
package com.javaDesign.designModel.creational.Singleton; import java.io.*; import java.lang.reflect.InvocationTargetException; /** * @program: designModel * @description: 通过反射，来获取新的实例，破坏单例模式 * @author: YuKai Fan * @create: 2018-12-05 14:55 **/ public class Test3 { public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException, ClassNotFoundException { /** * 枚举类型的单例模式下的，反射与序列化攻击 */ EnumInstance instance = EnumInstance.getInstance(); instance.setData(new Object()); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file")); oos.writeObject(instance); File file = new File("singleton_file"); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); /* ObjectInputStream中有一个readEnum()方法，这是读取枚举类的方法，它会获取到枚举对象的名称name， String name = readString(false); Enum<?> result = null; Class<?> cl = desc.forClass(); if (cl != null) { try { @SuppressWarnings("unchecked") //根据name获取到枚举常量,由于name是唯一的，并且对应一个枚举常量，所以对于枚举类，实例也只会产生一个，所以枚举类对于序列化的破坏是不受影响的 Enum<?> en = Enum.valueOf((Class)cl, name); result = en; } */ EnumInstance newInstance = (EnumInstance)ois.readObject(); System.out.println(instance.getData()); System.out.println(newInstance.getData()); System.out.println(instance.getData() == newInstance.getData()); } }
阅读源码可知，由于ObjectInputStream中的readEnum()方法，根据枚举类类名来得到唯一的枚举常量，从而只会产生一个实例，所以枚举类对于序列化的破坏是不受影响的
下面模拟反射攻击:
package com.javaDesign.designModel.creational.Singleton; import java.io.*; import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; /** * @program: designModel * @description: 通过反射，来获取新的实例，破坏单例模式 * @author: YuKai Fan * @create: 2018-12-05 14:55 **/ public class Test3 { public static void main(String[] args) throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException, IOException, ClassNotFoundException { /** * 枚举类型的单例模式下的，反射与序列化攻击 */ /*EnumInstance instance = EnumInstance.getInstance(); instance.setData(new Object()); ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton_file")); oos.writeObject(instance); File file = new File("singleton_file"); ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file)); *//* ObjectInputStream中有一个readEnum()方法，这是读取枚举类的方法，它会获取到枚举对象的名称name， String name = readString(false); Enum<?> result = null; Class<?> cl = desc.forClass(); if (cl != null) { try { @SuppressWarnings("unchecked") //根据name获取到枚举常量,由于name是唯一的，并且对应一个枚举常量，所以对于枚举类，实例也只会产生一个，所以枚举类对于序列化的破坏是不受影响的 Enum<?> en = Enum.valueOf((Class)cl, name); result = en; } *//* EnumInstance newInstance = (EnumInstance)ois.readObject(); System.out.println(instance.getData()); System.out.println(newInstance.getData()); System.out.println(instance.getData() == newInstance.getData());*/ Class objectClass = EnumInstance.class; /* 因为枚举类中是没有无参构造器的，所以必须要传两个参数 */ Constructor constructor = objectClass.getDeclaredConstructor(String.class, int.class); //通过反射，将类的构造器权限改为了public，这样就这样new出新的实例 constructor.setAccessible(true); EnumInstance instance = EnumInstance.getInstance(); EnumInstance newInstance = (EnumInstance) constructor.newInstance("测试",666); /* 通过反射来获取实例时，会有一个判断，看是否是枚举类，如果是的话就会抛出异常，这样反射攻击也会失败 newInstance(): if ((clazz.getModifiers() & Modifier.ENUM) != 0) throw new IllegalArgumentException("Cannot reflectively create enum objects"); */ System.out.println(instance); System.out.println(newInstance); System.out.println(instance == newInstance); } }
输出结果为：
同样阅读newInstance()方法源码，通过反射获取实例，会判断是否是枚举类，这样反射攻击也会无效。
