破坏单例模式--存在的问题---问题的解决

目录

破坏单例模式--存在的问题---问题的解决

 问题演示

破坏单例模式：

序列化

反射

序列化反序列化：

代码：

运行结果：

反射  

代码：

运行结果：

问题的解决

序列化、反序列方式破坏单例模式的解决方法

代码： 

运行结果：

反射方式破解单例的解决方法

代码：

运行结果：

JDK源码解析-Runtime类

Runtime类就是使用的单例设计模式。

---

破坏单例模式--存在的问题---问题的解决

•  问题演示

  • 破坏单例模式：

使上面定义的单例类（Singleton）可以创建多个对象，枚举方式除外。有两种方式，分别是：

• 序列化

• 反射

• 序列化反序列化：

  • 代码：

Singleton类：

package com.dong.demo;import java.io.Serializable;public class Singleton implements Serializable {public Singleton() {}private static class  singletonHolder{private static final Singleton INSTANCE=new Singleton();}public static Singleton getInstance(){return singletonHolder.INSTANCE;}
}

Client类：

package com.dong.demo;import java.io.*;public class Client {public static void main(String[] args) throws IOException, ClassNotFoundException {// writeObject2File();readObject1File();readObject1File();}//此文件读取数据（对象）public static void readObject1File() throws IOException, ClassNotFoundException {//创建文件输出流对象ObjectInputStream ois=new ObjectInputStream(new FileInputStream("D:\\蓝桥杯\\设计模式作业\\530\\a.txt"));//读取对象Singleton singleton = (Singleton) ois.readObject();System.out.println(singleton);//释放资源ois.close();}//从文件中写数据（对象）public static void writeObject2File() throws IOException {//获取Singleton对象Singleton singleton=Singleton.getInstance();//创建对象输出流对象ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("D:\\蓝桥杯\\设计模式作业\\530\\a.txt"));//写对象oos.writeObject(singleton);//释放资源oos.close();}
}

• 运行结果：

两对象不一样，因此，序列化破坏了单例模式。

表明序列化和反序列化已经破坏了单例设计模式。

• 序列化会破坏单例模式的原因是在反序列化的过程中，会通过构造器重新创建一个新的对象。反序列化的过程是将二进制数据解码为Java对象，这个过程会创建一个新的对象，并不会保留旧对象的状态。因此，如果使用序列化和反序列化来实现单例模式，就可能破坏单例模式的唯一性。
• 在上述代码中，每次读取对象时都会创建一个新对象并返回，与最初创建的对象并不相同。具体原因是：在Singleton类中定义了私有的构造方法，使得无法在外部调用构造方法创建对象，而在内部通过静态内部类singletonHolder的方式创建Singleton的唯一实例，并将该实例赋值给静态final变量INSTANCE。但是，当通过反序列化的方式创建对象时，虚拟机会自动调用Singleton类的无参构造方法创建一个新的对象，从而导致创建了多个不同的实例，打破了Singleton模式的设计初衷。

• 反射  

代码：

Singleton类：

package com.dong.demo002;import java.io.Serializable;public class Singleton implements Serializable {public Singleton() {}private static class  singletonHolder{private static final Singleton INSTANCE=new Singleton();}public static Singleton getInstance(){return singletonHolder.INSTANCE;}
}

Client类：  

package com.dong.demo002;import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;/*** 反射破坏单例模式*/
public class Client {public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {//Singleton.class.getDeclaredConstructor().setAccessible(true);//获取Singleton的字节码对象Class singletonClass = Singleton.class;//获取无参构造方法对象Constructor cons = singletonClass.getDeclaredConstructor();//取消范文检查cons.setAccessible(true);//创建Singleton对象Singleton s1 = (Singleton) cons.newInstance();Singleton s2= (Singleton) cons.newInstance();System.out.println(s1==s2);}
}

运行结果：

上面代码运行结果是false，表明反射已经破坏了单例设计模式  

注意：枚举方式不会出现这两个问题。

问题的解决

• 序列化、反序列方式破坏单例模式的解决方法

  • 在Singleton类中添加readResolve()方法，在反序列化时被反射调用，如果定义了这个方法，就返回这个方法的值，如果没有定义，则返回新new出来的对象。

代码： 

Singleton类：

package com.dong.demo001;import java.io.Serializable;public class Singleton implements Serializable {public Singleton() {}private static class  singletonHolder{private static final Singleton INSTANCE=new Singleton();}public static Singleton getInstance(){return singletonHolder.INSTANCE;}public  Object readResolve(){return singletonHolder.INSTANCE;}
}

Client类：【不变】

package com.dong.demo001;import java.io.*;public class Client {public static void main(String[] args) throws IOException, ClassNotFoundException {// writeObject2File();readObject1File();readObject1File();}//此文件读取数据（对象）public static void readObject1File() throws IOException, ClassNotFoundException {//创建文件输出流对象ObjectInputStream ois=new ObjectInputStream(new FileInputStream("D:\\蓝桥杯\\设计模式作业\\530\\a.txt"));//读取对象Singleton singleton = (Singleton) ois.readObject();System.out.println(singleton);//释放资源ois.close();}//从文件中写数据（对象）public static void writeObject2File() throws IOException {//获取Singleton对象Singleton singleton=Singleton.getInstance();//创建对象输出流对象ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("D:\\蓝桥杯\\设计模式作业\\530\\a.txt"));//写对象oos.writeObject(singleton);//释放资源oos.close();}
}

运行结果：

源码解析：

ObjectInputStream类

public final Object readObject() throws IOException, ClassNotFoundException{...// if nested read, passHandle contains handle of enclosing objectint outerHandle = passHandle;try {Object obj = readObject0(false);//重点查看readObject0方法.....
}private Object readObject0(boolean unshared) throws IOException {...try {switch (tc) {...case TC_OBJECT:return checkResolve(readOrdinaryObject(unshared));//重点查看readOrdinaryObject方法...}} finally {depth--;bin.setBlockDataMode(oldMode);}    
}private Object readOrdinaryObject(boolean unshared) throws IOException {...//isInstantiable 返回true，执行 desc.newInstance()，通过反射创建新的单例类，obj = desc.isInstantiable() ? desc.newInstance() : null; ...// 在Singleton类中添加 readResolve 方法后 desc.hasReadResolveMethod() 方法执行结果为trueif (obj != null && handles.lookupException(passHandle) == null && desc.hasReadResolveMethod()) {// 通过反射调用 Singleton 类中的 readResolve 方法，将返回值赋值给rep变量// 这样多次调用ObjectInputStream类中的readObject方法，继而就会调用我们定义的readResolve方法，所以返回的是同一个对象。Object rep = desc.invokeReadResolve(obj);...}return obj;
}

• 反射方式破解单例的解决方法

代码：

package com.dong.demo002;import java.io.Serializable;public class Singleton implements Serializable {private static boolean flag=false;public Singleton() {synchronized (Singleton.class) {if (flag) {throw new RuntimeException("不能创建多个对象！！！！！！");}flag = true;}}private static class  singletonHolder{private static final Singleton INSTANCE=new Singleton();}public static Singleton getInstance(){return singletonHolder.INSTANCE;}
}

package com.dong.demo002;import java.io.*;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;/*** 反射破坏单例模式*/
public class Client {public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {//Singleton.class.getDeclaredConstructor().setAccessible(true);//获取Singleton的字节码对象Class singletonClass = Singleton.class;//获取无参构造方法对象Constructor cons = singletonClass.getDeclaredConstructor();//取消范文检查cons.setAccessible(true);//创建Singleton对象Singleton s1 = (Singleton) cons.newInstance();Singleton s2= (Singleton) cons.newInstance();System.out.println(s1==s2);}
}

运行结果：

 或：

反射方式破解单例的解决方法

public class Singleton {//私有构造方法private Singleton() {/*反射破解单例模式需要添加的代码*/if(instance != null) {throw new RuntimeException();}}private static volatile Singleton instance;//对外提供静态方法获取该对象public static Singleton getInstance() {if(instance != null) {return instance;}synchronized (Singleton.class) {if(instance != null) {return instance;}instance = new Singleton();return instance;}}
}

说明:

这种方式比较好理解。当通过反射方式调用构造方法进行创建创建时，直接抛异常。不运行此中操作。

---

JDK源码解析-Runtime类

Runtime类就是使用的单例设计模式。

1. 通过源代码查看使用的是哪儿种单例模式

从上面源代码中可以看出Runtime类使用的是饿汉式（静态属性）方式来实现单例模式的。

2.使用Runtime类中的方法  

public class RuntimeDemo {public static void main(String[] args) throws IOException {//获取Runtime类对象Runtime runtime = Runtime.getRuntime();//返回 Java 虚拟机中的内存总量。System.out.println(runtime.totalMemory());//返回 Java 虚拟机试图使用的最大内存量。System.out.println(runtime.maxMemory());//创建一个新的进程执行指定的字符串命令，返回进程对象Process process = runtime.exec("ipconfig");//获取命令执行后的结果，通过输入流获取InputStream inputStream = process.getInputStream();byte[] arr = new byte[1024 * 1024* 100];int b = inputStream.read(arr);System.out.println(new String(arr,0,b,"gbk"));}
}