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

反射：获得类的构造器后用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是否是同一个实例？ trueOne和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是否是同一个实例？ trueOne和Three是否是同一个实例？ false

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

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

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

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

public enum Singleton {
    uniqueInstance;
}

原文出处：https://www.cnblogs.com/keeya/p/9516501.html