用私有构造器或枚举类型强化Singleton

Singleton指只有一个实例的类，只能被创建一次。

在Java1.5之前实现Singleton有两种方式，都是将构造器设为private并导出公有的静态成员实例。

第一种方式将公有的静态成员实例设为final：

public class Singleton {

    public static final Singleton INSTANCE = new Singleton();

    private Singleton() {}

}

私有构造器仅被调用一次，用来实例化公有的静态final属性INSTANCE，由于缺少对外暴露的构造器所以保证INSTANCE全局唯一。不过如果考虑到反射，其实客户端还是会生成多个实例，客户端可以通过反射获取Constructor并调用Constructor.setAccessible(true)，接着Constructor.newInstance()也是可以生成多个实例的。如果需要防止出现这种情况，通过修改构造器可以在被要求创建第二个实例时抛出异常：

 public class Singleton {

     private static int i = 0;

     public static final Singleton INSTANCE = new Singleton();

     private Singleton() {
         i++;
         if (i > 1)
             throw new RuntimeException("单例，不允许创建多个");
     }

     public static void main(String[] args) throws IllegalAccessException, InstantiationException, InvocationTargetException {
         Singleton s = Singleton.INSTANCE; // 第一次
         Class<Singleton> clz = Singleton.class;
         clz.newInstance(); // 第二次, Class.newInstance底层调用的还是Constructor.newInstance
         Constructor[] cs = clz.getDeclaredConstructors(); // 或者直接尝试使用构造器
         for (Constructor c : cs) {
             c.setAccessible(true);
             c.newInstance();
         }
     }

 }

Exception in thread "main" java.lang.RuntimeException: 单例，不允许创建多个
    at Singleton.<init>(Singleton.java:20)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
    at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
    at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
    at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
    at java.lang.Class.newInstance(Class.java:442)
    at Singleton.main(Singleton.java:26)

 第二种方式是提供公有的静态工厂方法：

public class Singleton {

    private static final Singleton INSTANCE = new Singleton();

    public static Singleton getInstance() {
        return INSTANCE;
    }

    private Singleton() {}
}

这种方式的优势是更灵活，在不改变API的前提下，如果不想返回单例也可以每次都new新的实例。

上述两种方式如果让Singleton类变成可序列化（implements Serializable）,那么在反序列化时就会破坏单例性，因为反序列化时会创建一个新实例。为了保证在implements Serializable的前提下仍能保证单例那么就需要做两件事，第一将Singleton中所有属性都声明为transient,第二提供一个readResolve方法：

private Object readResolve() {
    return INSTANCE;
}

提供上面的readResolve方法后，在反序列化成功后会调用readResolve方法得到INSTANCE并用INSTANCE替换调刚刚反序列化得到的新实例，新实例将会被接下里的GC操作回收，从而保证了单例性。

jdk1.5以后利用枚举又有了第三种实现单例的方式，利用包含单个元素的枚举：

public enum Singleton {

    INSTANCE;

    public void doSomething() {}
}

这种方式与公有域（第一种方式）方法类似，不过更加简洁，并默认提供序列化并防止多次实例化。是实现单例的最佳方法。

下面尝试使用反射和序列化测试使用枚举实现的单例

反射：

 public class Main {

     public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException {
         Class<Singleton> clz = Singleton.class;

         // 1.使用Class.newInstance
         clz.newInstance();

     }

 }

Exception in thread "main" java.lang.InstantiationException: Singleton
    at java.lang.Class.newInstance(Class.java:427)
    at Main.main(Main.java:15)
Caused by: java.lang.NoSuchMethodException: Singleton.<init>()
    at java.lang.Class.getConstructor0(Class.java:3082)
    at java.lang.Class.newInstance(Class.java:412)
    ... 1 more

 public class Main {

     public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException {
         Class<Singleton> clz = Singleton.class;

         // 2.直接使用构造器
         Constructor[] constructors = clz.getDeclaredConstructors();
         for (Constructor constructor : constructors) {
             constructor.setAccessible(true);
             Singleton singleton = (Singleton) constructor.newInstance();
         }

     }

 }

Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
    at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
    at Main.main(Main.java:22)

通过上面测试可以验证通过反射没法创建新的实例，所以使用枚举实现的单例有效的防止了放射。

序列化：

public enum Singleton implements Serializable { // 这里即使不手动implements Serializable默认Enum已经implements Serializable

    INSTANCE;

    Person person = new Person.PersonBuilder("hehe", 100).build();

    public void doSomething() {}

}

public class Person {

    private final String name; // 必填
    private final int age; // 必填

    private final int gender; // 可选
    private final String tel; // 可选
    private final String address; //可选
    private final String school; // 可选

    public static class PersonBuilder implements Builder<Person> {

        @Override
        public Person build() {
            return new Person(this);
        }

        private final String name; // 必填
        private final int age; // 必填

        private int gender = 0; // 可选
        private String tel = ""; // 可选
        private String address = ""; //可选
        private String school = ""; // 可选

        public PersonBuilder(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public PersonBuilder gender(int gender) {
            this.gender = gender;
            return this;
        }

        public PersonBuilder tel(String tel) {
            this.tel = tel;
            return this;
        }

        public PersonBuilder address(String address) {
            this.address = address;
            return this;
        }

        public PersonBuilder school(String school) {
            this.school = school;
            return this;
        }

    }

    private Person(PersonBuilder builder) {
        this.name = builder.name;
        this.age = builder.age;
        this.gender = builder.gender;
        this.tel = builder.tel;
        this.address = builder.address;
        this.school = builder.school;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }

}

public class Main {

    public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, IOException, ClassNotFoundException {
        Singleton s = Singleton.INSTANCE;
        System.out.println(s.person);

        ObjectOutputStream bos = new ObjectOutputStream(new FileOutputStream("INS"));
        bos.writeObject(s);

        ObjectInputStream bis = new ObjectInputStream(new FileInputStream("INS"));
        Singleton ns = (Singleton) bis.readObject();
        System.out.println(ns.person);

        System.out.println(s == ns ? "Singleton同一实例" : "Singleton非单例");
        System.out.println(s.person == ns.person ? "Person同一实例" : "Person不是同一个实例");

    }

}

运行后打印输出：

Person{name='hehe', age=100}
Person{name='hehe', age=100}
Singleton同一实例
Person同一实例

通过上面测试可以证明使用枚举实现的单例在面对序列化时也是可靠的。

枚举类型的序列化和反序列化并不是真的序列化操作，在序列化枚举类型时仅仅是序列化枚举的name，反序列化也仅仅是通过name找到对应的枚举并返回，所以这样就保证了序列化前后都是同一个对象。