effective java(3) 之用私有构造器或者枚举类型强化Singleton属性

effective java 之用私有构造器或者枚举类型强化Singleton属性

实现单例模式通常有3种方法（详细请看设计模式单例模式一节）
Singleton指仅仅被实例化一次的类。
私有构造函数只能在函数内部调用，外部不能实例化，所以私有构造函数可以防止该类在外部被实例化。
1.静态成员
public class Aagersingleton {
private static final Aagersingleton m_instance = new Aagersingleton();
// 私有默认构造方法
private Aagersingleton() {
}
//普通方法
public void method() {
System.out.println("饿汉式单例类,通过静态工厂调用！");
}
}
public static void main(String[] args) {
Aagersingleton instance1 = Aagersingleton.m_instance;
instance1.method();
}

2.静态工厂方法
//饿汉式单例类
public class Aagersingleton {
private static final Aagersingleton m_instance = new Aagersingleton();

// 私有默认构造方法
private Aagersingleton() {
}
// 静态工厂方法
public static Aagersingleton getInstance() {
return m_instance;
}
//普通方法
public void method() {
System.out.println("饿汉式单例类,通过静态工厂调用！");
}
}
public static void main(String[] args) {

Aagersingleton instance1 = Aagersingleton.getInstance();
instance1.method();
}

但是这两种方法不能保证全局只有一个对象。
可以通过反射机制，设置AccessibleObject.setAccessible(true)，改变构造器的访问属性，调用构造器生成新的实例。

Constructor<?> constructor = Aagersingleton.class.getDeclaredConstructors()[0];
constructor.setAccessible(true);
Aagersingleton instance2 = (Aagersingleton) constructor.newInstance();
instance2.method();

实例化count=0次
饿汉式单例类,通过静态工厂调用！
实例化count=1次
饿汉式单例类,通过静态工厂调用！
可以看出实例化两次，不能保证全局只有一个对象。

解决方案：
public class Aagersingleton {
private static int count = 0;
public static final Aagersingleton m_instance = new Aagersingleton();

// 私有默认构造方法
private Aagersingleton() {
System.out.println("实例化count="+count+"次");
if (count > 0) {
throw new IllegalArgumentException(
"Cannot create Aagersingleton twice");
}
count++;
}

// 静态工厂方法
public static Aagersingleton getInstance() {
return m_instance;
}

// 普通方法
public void method() {
System.out.println("饿汉式单例类,通过静态工厂调用！");
}
}
public static void main(String[] args) throws InstantiationException,
IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
Aagersingleton instance1 = Aagersingleton.m_instance;
instance1.method();

Constructor<?> constructor = Aagersingleton.class.getDeclaredConstructors()[0];
constructor.setAccessible(true);
Aagersingleton instance2 = (Aagersingleton) constructor.newInstance();
instance2.method();
}

实例化count=0次
饿汉式单例类,通过静态工厂调用！
实例化count=1次
Exception in thread "main" java.lang.reflect.InvocationTargetException
第二次实例化报错，保证全局只有一个对象。

如果上面两种方法实现的Singleton是可以序列化的，加上 implements Serializable只保证它可以序列化。
为了保证反序列化的时候，实例还是Singleton，必须声明所有的实例域都是transient的，并且提供 readResolve方法，否则，每次反序列化都会生成新的实例。

private Object readResolve() {
        return m_instance;
    }

3.单元素枚举类型

public enum Aagersingleton1 {
m_instance;


// 普通方法
public void method() {
System.out.println("饿汉式单例类,通过静态工厂调用！");
}
}
public class Test2 {
public static void main(String[] args) throws InstantiationException,
IllegalAccessException, IllegalArgumentException,
InvocationTargetException {
Aagersingleton1 instance1 = Aagersingleton1.m_instance;
instance1.method();


Constructor<?> constructor = Aagersingleton1.class.getDeclaredConstructors()[0];
constructor.setAccessible(true);
Aagersingleton1 instance2 = (Aagersingleton1) constructor.newInstance();
instance2.method();
}
}

通过枚举实现Singleton更加简洁，同时枚举类型无偿地提供了序列化机制，可以防止反序列化的时候多次实例化一个对象。
枚举类型也可以防止反射攻击，当你试图通过反射去实例化一个枚举类型的时候会抛出IllegalArgumentException异常

所以单元素的枚举类型是实现Singleton的最佳方法。

每天努力一点，每天都在进步。