避免反射和序列化来破坏单例

反射：获得类的构造器后用setAccessible(true)绕过权限检查，可以直接调用私有构造器来生成实例。

我们来用双重检测锁来看看反射是如何破坏单例模式的

import java.lang.reflect.Constructor;

public class Main {
    public static void main(String[] args) throws Exception {
        Singleton singletonOne = Singleton.getSingleton();
        Singleton singletonTwo = Singleton.getSingleton();
        System.out.println("One和Two是否是同一个实例？ " + (singletonOne == singletonTwo));
        //利用反射来破坏单例模式
        Class clazz = Class.forName("Singleton");
        Constructor constructor = clazz.getDeclaredConstructor(null);
        constructor.setAccessible(true);
        Singleton singletonThree = (Singleton) constructor.newInstance(null);
        System.out.println("One和three是否是同一个实例？ "+(singletonOne==singletonThree));
    }
}
//双重检测锁模式
class Singleton {
    private Singleton() {
    }

    static Singleton singleton;

    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
输出结果：
One和Two是否是同一个实例？ true
One和three是否是同一个实例？ false

如何解决呢？其实方法很简单，有个小技巧，直接在私有构造器里抛出异常：

private Singleton(){
    if(singleton!=null){
        throw new RuntimeException();
    }
}

通过序列化反序列化方式可以破坏单例模式

import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        Singleton singletonOne = Singleton.getSingleton();
        Singleton singletonTwo = Singleton.getSingleton();
        System.out.println("One和Two是否是同一个实例？ " + (singletonOne == singletonTwo));
        //序列化
        ObjectOutputStream obj = new ObjectOutputStream(new FileOutputStream("d:/a.txt"));
        obj.writeObject(singletonOne);
        obj.close();
        //反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("d:/a.txt"));
        Singleton singletonThree = (Singleton) ois.readObject();
        System.out.println("One和Three是否是同一个实例？ " + (singletonOne == singletonThree));

    }
}
class Singleton implements Serializable {
    private Singleton() {
    }

    static Singleton singleton;

    public static Singleton getSingleton() {
        if (singleton == null) {
            synchronized (Singleton.class) {
                if (singleton == null) {
                    singleton = new Singleton();
                }
            }
        }
        return singleton;
    }
}
输出：
One和Two是否是同一个实例？ true
One和Three是否是同一个实例？ false

解决方法:定义Object readResolve()方法

这个方法会紧挨着readObject()之后被调用，该方法的返回值将会代替原来反序列化的对象，而原来readObject()反序列化的对象将会立即丢弃。readObject()方法在序列化单例类，枚举类时尤其有用。

private Object readResolve() throws ObjectStreamException{
    return instance;
}

Effective Java作者Josh Bloch 提倡使用枚举的方式，因为创建一个enum类型是线程安全的。这种方法在功能上与公有域方法相近，但是它更加简洁，无偿提供了序列化机制，绝对防止多次实例化，即使是在面对复杂序列化或者反射攻击的时候。

public enum Singleton {
    uniqueInstance;
}

文章永久链接：https://tech.souyunku.com/48586