单例模式是一种广泛使用的设计模式,它能够避免实例对象的重复创建,不仅可以减少每次创建对象的时间开销,还可以节约内存空间(比如spring管理的无状态bean);还能够避免由于操作多个实例导致的逻辑错误;在应用的整个生命周期内,只有一个对象,起到了全局统一管理控制的作用。
接下来,我们看一下如何在java中创建单例对象。
1、恶汉加载方式:
public class Singleton {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
//或者
public class Singleton {
private static Singleton instance = null;
static {
instance = new Singleton();
}
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
说明:这种方式基于static和classloder机制,确保了在类加载时创建了该类对象,同时通过private构造函数,保证了在其他类中无法通过new的方式创建对象。
2、双重检验锁:
public class Singleton {
private volatile static Singleton singleton; //volatile修饰
private Singleton (){}
public static Singleton getSingleton() {
if (singleton == null) {
synchronized (Singleton.class) {
// 注意此处还得有次判空~
if (singleton == null) {
singleton = new Singleton();
}
}
}
return singleton;
}
}
说明:这是一种懒汉模式(懒加载功能)。
3、静态内部类:
public class Singleton {
// 静态内部类
private static class SingletonHolder {
private static final Singleton INSTANCE = new Singleton();
}
private Singleton (){}
public static final Singleton getInstance() {
return SingletonHolder.INSTANCE;
}
}
说明:这也是一种懒汉模式,利用了静态内部类和外部类没有关联这一特点,只有调用getInstance方法时才去加载静态内部类,并且在静态内部类中有一个static的成员对象,确保了唯一性。
4、枚举方式:
public enum Singleton {
INSTANCE;
//属性方法
private String str = "test";
public void say() {
System.out.println("hello" + str);
}
}
//使用时
Singleton.INSTANCE.say();
说明:枚举编译后也是一个类,所以可以像类中定义的变量、方法一样,在枚举中定义。
这种方式是Effective Java作者Josh Bloch提倡的方式,是最安全的一种单例模式。为什么说是最安全的?我们先来看前三种实现单例的方式,其特点是:
- 静态化实例对象
- 私有化构造方法,禁止通过构造方法创建实例
- 提供一个公共的静态方法,用来返回唯一实例
问题就出在私有化构造方法,无法抵御反射调用的攻击;此外,对于对象序列化、反序列化操作,jdk也会创建对象。那么接下来,测试一下是否安全。
4.1)我们以最常见的恶汉模式单例来测试:
public class Singleton implements Serializable {
private static Singleton instance = new Singleton();
private Singleton (){}
public static Singleton getInstance() {
return instance;
}
}
public class Main {
public static void main(String[] args) throws Exception {
Singleton s = Singleton.getInstance();
// 拿到所有的构造函数,包括非public的
Constructor<Singleton> constructor = Singleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
// 使用空构造函数new一个实例。即使它是private的~~~
Singleton sReflection = constructor.newInstance();
System.out.println(s); //com.fsx.bean.Singleton@1f32e575
System.out.println(sReflection); //com.fsx.bean.Singleton@279f2327
System.out.println(s == sReflection); // false
}
}
输出:
com.fsx.bean.Singleton@1f32e575
com.fsx.bean.Singleton@279f2327
false
通过反射,竟然给所谓的单例创建出了一个新的实例对象。所以这种方式也还是存在不安全因素的。怎么破?其实Joshua Bloch说了:可以在构造函数在被第二次调用的时候抛出异常。具体示例代码,可以参考枚举实现的源码。
再看看它的序列化、反序列时会不会有问题(单例底层并不是反射)。如下:
public class Main {
public static void main(String[] args) throws Exception {
Singleton s = Singleton.getInstance();
byte[] serialize = SerializationUtils.serialize(s);
Object deserialize = SerializationUtils.deserialize(serialize);
System.out.println(s);
System.out.println(deserialize);
System.out.println(s == deserialize);
}
}
输出:
com.fsx.bean.Singleton@452b3a41
com.fsx.bean.Singleton@6193b845
false
可以看出,序列化前后两个对象并不相等。所以它序列化也是不安全的。
4.2)以枚举单例测试:
public enum EnumSingleton {
INSTANCE;
}
1)反射攻击:
public class Main {
public static void main(String[] args) throws Exception {
EnumSingleton s = EnumSingleton.INSTANCE;
// 拿到所有的构造函数,包括非public的
Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor();
constructor.setAccessible(true);
// 使用空构造函数new一个实例。即使它是private的~~~
EnumSingleton sReflection = constructor.newInstance();
System.out.println(s); //com.fsx.bean.Singleton@1f32e575
System.out.println(sReflection); //com.fsx.bean.Singleton@279f2327
System.out.println(s == sReflection); // false
}
}
输出:
Exception in thread "main" java.lang.NoSuchMethodException: com.fsx.bean.EnumSingleton.<init>()
at java.lang.Class.getConstructor0(Class.java:3082)
at java.lang.Class.getDeclaredConstructor(Class.java:2178)
at com.fsx.maintest.Main.main(Main.java:19)
这个看起来是因为没有空的构造函数导致的,还并不能下定义说防御了反射攻击。那它有什么构造函数呢,可以看它的父类Enum类:
// @since 1.5 它是所有Enum类的父类,是个抽象类
public abstract class Enum<E extends Enum<E>> implements Comparable<E>, Serializable {
// 这是它的唯一构造函数,接收两个参数(若没有自己额外指定构造函数的话~)
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
...
}
既然它有这个构造函数,那我们就先拿到这个构造函数再创建对象试试:
public class Main {
public static void main(String[] args) throws Exception {
EnumSingleton s = EnumSingleton.INSTANCE;
// 拿到所有的构造函数,包括非public的
Constructor<EnumSingleton> constructor = EnumSingleton.class.getDeclaredConstructor(String.class, int.class);// 拿到有参的构造器
constructor.setAccessible(true);
// 使用空构造函数new一个实例。即使它是private的~~~
System.out.println("拿到了构造器:" + constructor);
EnumSingleton sReflection = constructor.newInstance("testInstance", 1);
System.out.println(s); //com.fsx.bean.Singleton@1f32e575
System.out.println(sReflection); //com.fsx.bean.Singleton@279f2327
System.out.println(s == sReflection); // false
}
}
输出:
拿到了构造器:private com.fsx.bean.EnumSingleton(java.lang.String,int)
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
at com.fsx.maintest.Main.main(Main.java:22)
第一句输出了,表示我们是成功拿到了构造器Constructor对象的,只是在执行newInstance时候报错了。并且也提示报错在Constructor的417行,看看Constructor的源码处:
public final class Constructor<T> extends Executable {
...
public T newInstance(Object ... initargs) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException {
...
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
...
}
...
}
主要是这一句:(clazz.getModifiers() & Modifier.ENUM) != 0。说明:反射在通过newInstance创建对象时,会检查该类**是否ENUM修饰**,如果是则抛出异常,反射失败,因此枚举类型对反射是绝对安全的。
2)反序列化攻击:
public class Main {
public static void main(String[] args) {
EnumSingleton s = EnumSingleton.INSTANCE;
byte[] serialize = SerializationUtils.serialize(s);
Object deserialize = SerializationUtils.deserialize(serialize);
System.out.println(s == deserialize); //true
}
}
结果是:true。因此:枚举类型对序列化、反序列也是安全的。