列挙型（Enum）を用いたシングルトンパターンは、 Effective Java で推奨されている実装方法の一つです。その簡潔さと、様々な攻撃に対する堅牢性から、多くの開発者に支持されています。しかし、なぜ列挙型シングルトンはこれほどまでに安全なのでしょうか。本稿では、リフレクション、直列化、クローン生成といった一般的なシングルトンパターンの破壊手法が、列挙型シングルトンに対してどのように無力化されるかを解説します。

列挙型シングルトンの基本

まず、列挙型シングルトンの基本的な実装を見てみましょう。

public enum SafeSingleton {
    INSTANCE;

    public SafeSingleton getInstance() {
        return INSTANCE;
    }
}

このコードをコンパイルし、`javap`コマンドでデコンパイルすると、以下のような構造がわかります。

public final class com.example.SafeSingleton extends java.lang.Enum {
  public static final com.example.SafeSingleton INSTANCE;
  public static com.example.SafeSingleton[] values();
  public static com.example.SafeSingleton valueOf(java.lang.String);
  public com.example.SafeSingleton getInstance();
  static {};
}

列挙型は `java.lang.Enum` を継承した `final` クラスであることがわかります。そして、`INSTANCE` は `final` な静的フィールドとして定義されています。さらに、コンストラクタは自動的に `private` として扱われ、引数として `String` と `int` を受け取ります。

リフレクションによる攻撃の試み

では、このシングルトンをリフレクションで破壊できるか試してみましょう。

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

public class SingletonAttackTest {
    public static void main(String[] args) {
        SafeSingleton instance1 = SafeSingleton.INSTANCE;
        SafeSingleton instance2 = SafeSingleton.INSTANCE;

        System.out.println("Instance 1 Hash: " + instance1.hashCode());
        System.out.println("Instance 2 Hash: " + instance2.hashCode());

        try {
            Constructor<SafeSingleton> constructor = SafeSingleton.class.getDeclaredConstructor(String.class, int.class);
            constructor.setAccessible(true);

            SafeSingleton instance3 = constructor.newInstance("ATTACK_INSTANCE", 999);
            System.out.println("Instance 3 Hash: " + instance3.hashCode());
            System.out.println("Is same instance? " + (instance1 == instance3));
        } catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

このコードを実行すると、以下のような `IllegalArgumentException` がスローされます。

Instance 1 Hash: 1627674070
Instance 2 Hash: 1627674070
java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
    ...

この例外は、Java のリフレクションAPIが列挙型のインスタンス生成を明示的に禁止しているためです。`Constructor.newInstance()` メソッド内で、`clazz.getModifiers() & Modifier.ENUM` のチェックが行われ、列挙型の場合は例外がスローされます。

クローンによる攻撃の試み

次に、`clone()` メソッドによる破壊を試みます。`Enum` クラスのソースコードを見ると、`clone()` メソッドは `final` として宣言され、`CloneNotSupportedException` をスローするように実装されています。

protected final Object clone() throws CloneNotSupportedException {
    throw new CloneNotSupportedException();
}

このため、列挙型を継承したクラスで `clone()` をオーバーライドすることはできず、シングルトンをクローンで複製することは不可能です。

直列化と逆直列化による攻撃の試み

最後に、直列化と逆直列化による破壊をテストします。

import java.io.*;

public class SerializationTest {
    public static void main(String[] args) throws Exception {
        SafeSingleton instance1 = SafeSingleton.INSTANCE;

        // 直列化
        try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("singleton.ser"))) {
            oos.writeObject(instance1);
        }

        // 逆直列化
        SafeSingleton instance2;
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("singleton.ser"))) {
            instance2 = (SafeSingleton) ois.readObject();
        }

        System.out.println("Instance 1 Hash: " + instance1.hashCode());
        System.out.println("Instance 2 Hash: " + instance2.hashCode());
        System.out.println("Are they the same? " + (instance1 == instance2));
    }
}

このコードを実行すると、以下のような出力が得られます。

Instance 1 Hash: 1627674070
Instance 2 Hash: 1627674070
Are they the same? true

列挙型の直列化は特別な処理が行われます。`ObjectOutputStream` は列挙型の名前（`name()` メソッドの戻り値）をストリームに書き込みます。そして、`ObjectInputStream` は逆直列化時に、その名前を `Enum.valueOf()` メソッドに渡して、既存の列挙定数を検索・取得します。新しいインスタンスは生成されないため、シングルトンの特性が維持されます。