共计 7545 个字符,预计需要花费 19 分钟才能阅读完成。
[TOC]
1. 单例是什么?
单例模式:是一种创立型设计模式,目标是保障全局一个类只有一个实例对象,分为懒汉式和饿汉式。所谓懒汉式,相似于懒加载,须要的时候才会触发初始化实例对象。而饿汉式正好相同,我的项目启动,类加载的时候,就会创立初始化单例对象。
后面说过单例模式以及如何毁坏单例模式,咱们个别状况尽可能阻止单例模式被毁坏,于是各种序列化,反射,以及克隆的伎俩,咱们都须要思考进来,最终的代码如下:
import java.io.Serializable;
public class Singleton implements Serializable {
private static int num = 0;
// valitile 禁止指令重排
private volatile static Singleton singleton;
// 禁止屡次反射调用结构器
private Singleton() {synchronized (Singleton.class) {if (num == 0) {num++;} else {throw new RuntimeException("Don't use this method");
}
}
}
public static Singleton getSingleton() {if (singleton == null) {synchronized (Singleton.class) {if (singleton == null) {singleton = new Singleton();
}
}
}
return singleton;
}
// 禁止序列化的时候,从新生成对象
private Object readResolve() {return singleton;}
}
后面提过毁坏序列化的四种形式:
- 没有将结构器私有化,能够间接调用。
- 反射调用结构器
- 实现了
cloneable
接口 - 序列化与反序列化
2. 枚举的单例能够被毁坏么?
然而忽然想到一个问题,个别都说枚举的形式实现单例比拟好,较为举荐。真的是这样么?这样真的是平安的么?
那咱们就试试,看看各种伎俩,能不能毁坏它的单例。首先咱们来写一个单例枚举类:
public enum SingletonEnum {
INSTANCE;
public SingletonEnum getInstance(){return INSTANCE;}
}
在命令行执行以下的命令看下面的枚举类编译之后到底是什么货色?
javac SingletonEnum.java
javap SingletonEnum
public final class singleton.SingletonEnum extends java.lang.Enum<singleton.SingletonEnum> {
public static final singleton.SingletonEnum INSTANCE;
public static singleton.SingletonEnum[] values();
public static singleton.SingletonEnum valueOf(java.lang.String);
public singleton.SingletonEnum getInstance();
static {};}
能够看出,实际上,编译后的代码是继承于 Enum
类的,并且是泛型。用 final
润饰,其实也是类,那就是不能够被继承起因。而且 INSTANCE
也是 final
润饰的,也是不可变的。然而这样看,下面的都是 public
办法。那构造方法呢?没有被重写成为 private
么?
要是没有重写的话,那就很容易毁坏单例啊!咱们应用 javap -p SingletonEnum
看看后果:
<img src=”https://markdownpicture.oss-cn-qingdao.aliyuncs.com/blog/20201213225659.png” style=”zoom:50%;” />
能够看出的确构造函数曾经被私有化,那么内部就不能间接调用到构造方法了。那其余办法呢?咱们试试喷射调用结构器:
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class SingletonTests {public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
SingletonEnum singleton1 = SingletonEnum.INSTANCE;
SingletonEnum singleton2 = SingletonEnum.INSTANCE;
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
Constructor<SingletonEnum> constructor = null;
constructor = SingletonEnum.class.getDeclaredConstructor();
constructor.setAccessible(true);
SingletonEnum singleton3 = constructor.newInstance();
System.out.println(singleton1 == singleton3);
}
}
执行后果如下:
692404036
692404036
Exception in thread "main" java.lang.NoSuchMethodException: singleton.SingletonEnum.<init>()
at java.lang.Class.getConstructor0(Class.java:3082)
at java.lang.Class.getDeclaredConstructor(Class.java:2178)
at singleton.SingletonTests.main(SingletonTests.java:15)
咦,怎么回事?反射失败了???
<img src=”https://markdownpicture.oss-cn-qingdao.aliyuncs.com/blog/20201213231748.png” style=”zoom:50%;” />
看起来报错是 getDeclaredConstructor()
失败了,那咱们看看到底有哪些结构器:
public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {Constructor<SingletonEnum>[] constructor = null;
constructor = (Constructor<SingletonEnum>[]) SingletonEnum.class.getDeclaredConstructors();
for(Constructor<SingletonEnum> singletonEnumConstructor:constructor){System.out.println(singletonEnumConstructor);
}
}
执行后果如下, 发现只有一个结构器,外面参数是 String
和int
,所以啊,反射调用无参数结构器必定也是如此。
private singleton.SingletonEnum(java.lang.String,int)
毕竟它是继承于 Enum
的,那我猜测它大略也只有这个办法,验证以下,关上源码:
public abstract class Enum<E extends Enum<E>>
implements Comparable<E>, Serializable {
private final String name;
public final String name() {return name;}
private final int ordinal;
public final int ordinal() {return ordinal;}
protected Enum(String name, int ordinal) {
this.name = name;
this.ordinal = ordinal;
}
能够看出,这外面只有两个属性:name
和 ordinal
,结构器被重写了,正是String
和int
,验证了咱们的猜测,也就是没有方法应用无参数结构器来结构出毁坏单例的对象。那要是咱们应用有参数结构呢?试试!!!
import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class SingletonTests {public static void main(String[] args) throws IllegalAccessException, InvocationTargetException, InstantiationException, NoSuchMethodException {
SingletonEnum singleton1 = SingletonEnum.INSTANCE;
SingletonEnum singleton2 = SingletonEnum.INSTANCE;
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
Constructor<SingletonEnum> constructor = null;
constructor = SingletonEnum.class.getDeclaredConstructor(String.class,int.class);// 其父类的结构器
constructor.setAccessible(true);
SingletonEnum singleton3 = constructor.newInstance("INSTANCE",0);
System.out.println(singleton1 == singleton3);
}
}
后果呢?还是一样的报错,这是什么东东?
692404036
692404036
Exception in thread "main" java.lang.IllegalArgumentException: Cannot reflectively create enum objects
at java.lang.reflect.Constructor.newInstance(Constructor.java:417)
at singleton.SingletonTests.main(SingletonTests.java:18)
看起来意思是不能反射创立 enum 对象,啥?这谬误一看,就是Constructor.newInstance()
417 行抛出来的,咱们看看:
@CallerSensitive
public T newInstance(Object ... initargs)
throws InstantiationException, IllegalAccessException,
IllegalArgumentException, InvocationTargetException
{if (!override) {if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {Class<?> caller = Reflection.getCallerClass();
checkAccess(caller, clazz, null, modifiers);
}
}
// 限度枚举类型
if ((clazz.getModifiers() & Modifier.ENUM) != 0)
throw new IllegalArgumentException("Cannot reflectively create enum objects");
ConstructorAccessor ca = constructorAccessor; // read volatile
if (ca == null) {ca = acquireConstructorAccessor();
}
@SuppressWarnings("unchecked")
T inst = (T) ca.newInstance(initargs);
return inst;
}
原来反射的源代码中,枚举类型的曾经被限度了,一旦调用就会抛出异样,那这条路走不通了,也就证实了反射无奈毁坏枚举的单例。new
对象更是行不通了。
那 clone
呢?关上 Enum
的源码咱们外面就断了这个念头,这外面的 clone()
办法,曾经被 final
润饰了,不能被子类重写,一调用就抛出异样。所以 clone
这条路也不可能毁坏枚举的单例模式。
protected final Object clone() throws CloneNotSupportedException {throw new CloneNotSupportedException();
}
那序列化呢?如果咱们序列化之后,再反序列化,会呈现什么状况?
import java.io.*;
import java.lang.reflect.InvocationTargetException;
public class SingletonTests {public static void main(String[] args) throws Exception, InvocationTargetException, InstantiationException, NoSuchMethodException {SingletonEnum singleton1 = SingletonEnum.getInstance();
ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("file"));
objectOutputStream.writeObject(singleton1);
File file = new File("file");
ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(file));
SingletonEnum singleton2 = (SingletonEnum) objectInputStream.readObject();
System.out.println(singleton1.hashCode());
System.out.println(singleton2.hashCode());
}
}
下面的代码执行之后,后果如下:
1627674070
1627674070
阐明序列化反序列化回来之后,其实是同一个对象!!!所以无奈毁坏单例模式。为什么呢?咱们来剖析一下源码!!!
先看看序列化的时候,实际上调用的是ObjectOutputStream.writeObject(Object obj)
writerObject()Object obj
办法外面调用了 writeObject0(obj,false)
,writeObject0(obj,false)
外面看到枚举类型的序列化写入:
writeEnum(Enum<?>)
外面是怎么序列化的呢?
private void writeEnum(Enum<?> en,
ObjectStreamClass desc,
boolean unshared)
throws IOException
{
// 标识是枚举类型
bout.writeByte(TC_ENUM);
ObjectStreamClass sdesc = desc.getSuperDesc();
// 类型形容
writeClassDesc((sdesc.forClass() == Enum.class) ? desc : sdesc, false);
handles.assign(unshared ? null : en);
// 将名字写入 name()
writeString(en.name(), false);
}
看起来序列化的时候,是用名字写入序列化流中,那反序列化的时候呢?是怎么操作的呢?
public final Object readObject()
throws IOException, ClassNotFoundException {return readObject(Object.class);
}
外面调用的是另外一个 readObject()
办法,readObject()
办法其实是调用了readObject0(type,false)
。
看到反序列化的时候,枚举类型的时候,是怎么实现的呢?外面有一个readEnum()
:
咱们来看看 readEnum()
,外面其实外面是先读取了名字name
, 再通过名字Enum.valueOf()
获取枚举。
所以下面没有应用反射,还是获取了之前的对象,综上所述,枚举的序列化和反序列化并不会影响单例模式。
3. 总结一下
通过下面一顿剖析,枚举不能够间接调用构造函数,不能够反射毁坏单例模式,因为外部实现阻止了,实现 clone
接口也不能够,这个办法曾经设置为final
。序列化和反序列化的时候,外部没有应用反射去实现,而是查找之前的对象,间接返回,所以还是同一个对象。
这样一来,怪不得《effective java》外面举荐这个写法,既简洁,还可能避免各种毁坏,还有不必的理由么?
【作者简介】:
秦怀,公众号【秦怀杂货店】作者,技术之路不在一时,山高水长,纵使迟缓,驰而不息。这个世界心愿所有都很快,更快,然而我心愿本人能走好每一步,写好每一篇文章,期待和你们一起交换。
此文章仅代表本人(本菜鸟)学习积攒记录,或者学习笔记,如有侵权,请分割作者核实删除。人无完人,文章也一样,文笔稚嫩,在下不才,勿喷,如果有谬误之处,还望指出,感激不尽~