珠尿娜 发表于 2025-6-1 21:29:29

【设计模式】破解单例模式:反射、序列化与克隆攻击的防御之道

可能有的小伙伴看了我上一篇文章里几种方式对比的表格,觉得枚举有缺点,为什么Joshua Bloch还推荐使用枚举?
这就要提到单例的破解了。普通的单例模式是可以通过反射和序列化/反序列化来破解的,而Enum由于自身的特性问题,是无法破解的。当然,由于这种情况基本不会出现,因此我们在使用单例模式的时候也比较少考虑这个问题。
枚举类是实现单例模式最好的方式

在单例模式的实现中,除去枚举方法实现的单例模式,其它的实现都可以利用反射构造新的对象,从而破坏单例模式,但是枚举就不行,下面说说原因:
破坏单例的方式有 3 种,反射、克隆以及序列化,下面详细介绍:
反射

常见的单例模式实现中,往往有一个私有的构造函数,防止外部程序的调用,但是通过反射可以轻而易举的破坏这个限制:
public class DobleCheckSingleton {

    private DobleCheckSingleton(){}

    private static volatile DobleCheckSingleton dobleCheckSingleton;

    public static DobleCheckSingleton getSingleton(){
      if (dobleCheckSingleton == null){
            synchronized (DobleCheckSingleton.class){
                if (dobleCheckSingleton == null){
                  dobleCheckSingleton = new DobleCheckSingleton();
                }
            }
      }
      return dobleCheckSingleton;
    }

    public static void main(String[] args) {
      try {
            DobleCheckSingleton dobleCheckSingleton = DobleCheckSingleton.getSingleton();
            Constructor<DobleCheckSingleton> constructor = DobleCheckSingleton.class.getDeclaredConstructor();
            constructor.setAccessible(true);
            DobleCheckSingleton reflectInstance = constructor.newInstance();
            System.out.println(dobleCheckSingleton == reflectInstance);
      } catch (Exception ee.printStackTrace();
      }
    }
}

输出:false,单例被破坏显然,通过反射可以破坏所有含有无参构造器的单例类,如可以破坏懒汉式、饿汉式、静态内部类的单例模式
但是反射无法破坏通过枚举实现的单例模式,利用反射构造新的对象,由于 enum 没有无参构造器,结果会抛出 NoSuchMethodException 异常
public enum EnumSingleton {

    INSTANCE;

    public static void main(String[] args) {
      try {
            EnumSingleton enumSingleton = EnumSingleton.INSTANCE;
            // 获取无参的构造函数
            Constructor<EnumSingleton> constructor = null;
            constructor = EnumSingleton.class.getDeclaredConstructor();
            // 使用构造函数创建对象
            constructor.setAccessible(true);
            EnumSingleton reflectInstance = constructor.newInstance();
            System.out.println(enumSingleton == reflectInstance);
      } catch (Exception e) {
            e.printStackTrace();
      }
    }
}

输出:java.lang.NoSuchMethodException: singleton.EnumSingleton.<init>()
    at java.lang.Class.getConstructor0(Class.java:3082)
    at java.lang.Class.getDeclaredConstructor(Class.java:2178)
    at singleton.EnumSingleton.main(EnumSingleton.java:19)枚举安全的原因解释:

对 EnumSingleton 文件进行反编译,可以发现 EnumSingleton 继承于 Enum,而 Enum 类确实没有无参的构造器,所以抛出 NoSuchMethodException。
枚举类 EnumSingleton 反编译结果
public final class singleton.EnumSingleton extends java.lang.Enum<singleton.EnumSingleton>

Enum 类的构造方法
protected Enum(String name, int ordinal) {
      this.name = name;
      this.ordinal = ordinal;
}进一步,通过调用父类有参构造器构造枚举实例对象,样例程序又抛出 IllegalArgumentException 异常。
public enum EnumSingleton {

    INSTANCE;

    public EnumSingleton getInstance(){
      return INSTANCE;
    }

    public static void main(String[] args) {
      try {
            EnumSingleton enumSingleton = EnumSingleton.INSTANCE;
            // 获取无参的构造函数
            Constructor<EnumSingleton> constructor = null;
            constructor = EnumSingleton.class.getDeclaredConstructor(String.class,int.class);
            // 使用构造函数创建对象
            constructor.setAccessible(true);
            EnumSingleton reflectInstance = constructor.newInstance("test",1);
            System.out.println(enumSingleton == reflectInstance);
      } catch (Exception e) {
            e.printStackTrace();
      }
    }
}

输出:
java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
    at singleton.EnumSingleton.main(EnumSingleton.java:31)因为 Constructor 的 newInstance 方法限定了 clazz 的类型不能是 enum,否则抛出异常
@CallerSensitive
public T newInstance(Object ... initargs)
   throws InstantiationException, IllegalAccessException,
            IllegalArgumentException, InvocationTargetException
{
    ...
   if ((clazz.getModifiers() & Modifier.ENUM) != 0)
         throw new IllegalArgumentException("Cannot reflectively create enum objects");
   ...
}所以枚举类不能通过反射构建构造函数的方式构建新的实例
序列化

先看看通过序列化破坏单例的例子,其中 Singleton 实现了 Serializable 接口,才有可能通过序列化破坏单例。
public class DobleCheckSingleton implements Serializable {

    private DobleCheckSingleton() {
    }

    private static volatile DobleCheckSingleton dobleCheckSingleton;

    public static DobleCheckSingleton getSingleton() {
      if (dobleCheckSingleton == null) {
            synchronized (DobleCheckSingleton.class) {
                if (dobleCheckSingleton == null) {
                  dobleCheckSingleton = new DobleCheckSingleton();
                }
            }
      }
      return dobleCheckSingleton;
    }

    public static void main(String[] args) {
      try {
            DobleCheckSingleton dobleCheckSingleton = DobleCheckSingleton.getSingleton();

            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("SerSingleton.obj"));
            oos.writeObject(dobleCheckSingleton);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("SerSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            DobleCheckSingleton s1 = (DobleCheckSingleton) ois.readObject();
            ois.close();

            System.out.println(dobleCheckSingleton == s1);
                        } catch (Exception e) {
            e.printStackTrace();
      }
    }
}
输出:false,单例被破坏枚举类实现,枚举类不实现 Serializable 接口,都可以进行序列化,并且返回原来的单例。
public enum EnumSingleton {

    INSTANCE;

    public static void main(String[] args) {
      try {
            EnumSingleton enumSingleton = EnumSingleton.INSTANCE;

            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("SerSingleton.obj"));
            oos.writeObject(enumSingleton);
            oos.flush();
            oos.close();

            FileInputStream fis = new FileInputStream("SerSingleton.obj");
            ObjectInputStream ois = new ObjectInputStream(fis);
            EnumSingleton s1 = (EnumSingleton) ois.readObject();
            ois.close();

            System.out.println(enumSingleton == s1);

      } catch (Exception e) {
            e.printStackTrace();
      }
    }
}

输出:true原因: 枚举类的 writeObject 方法仅仅是将 Enum.name 写到文件中,反序列化时,根据 readObject 方法的源码定位到 Enum 的 valueOf 方法,他会根据名称返回原来的对象。
克隆

实现 Cloneable 接口重写 clone 方法,但是 Enum 类中 clone 的方法是 final 类型,无法重写,也就不能通过克隆破坏单例。
public abstract class Enum<E extends Enum<E>>
      implements Comparable<E>, Serializable {
   protected final Object clone() throws CloneNotSupportedException {
      throw new CloneNotSupportedException();
    }
}不用枚举如何防止单例模式破坏

若实现了序列化接口,重写 readResolve 方法即可,反序列化时将调用该方法返回对象实例
public Object readResolve() throws ObjectStreamException {
    return dobleCheckSingleton;
}通过反射破坏单例的场景,可以在构造方法中判断实例是否已经创建,若已创建则抛出异常
private Singleton(){
    if (instance !=null){
      throw new RuntimeException("实例已经存在,请通过 getInstance()方法获取");
    }
}通过clone破坏单例的场景,可以重写clone方法,返回已有单例对象
往期推荐


[*]《SpringBoot》EasyExcel实现百万数据的导入导出
[*]《SpringBoot》史上最全SpringBoot相关注解介绍
[*]Spring框架IoC核心详解
[*]万字长文带你窥探Spring中所有的扩展点
[*]如何实现一个通用的接口限流、防重、防抖机制
[*]万字长文带你深入Redis底层数据结构
[*]volatile关键字最全原理剖析

来源:程序园用户自行投稿发布,如果侵权,请联系站长删除
免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!
页: [1]
查看完整版本: 【设计模式】破解单例模式:反射、序列化与克隆攻击的防御之道