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

深碍√TFBOYSˉ_ 2024-03-16 11:02 81阅读 0赞

问题演示

破坏单例模式：

序列化

反射

序列化反序列化：

代码：

运行结果：

反射

代码：

运行结果：

问题的解决

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

代码：

运行结果：

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

代码：

运行结果：

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();
        }
    }

*  #### 运行结果： ####

![ad8657086e824f80ad8045fd3abd1fb3.png][]

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

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

>  *  序列化会破坏单例模式的原因是在反序列化的过程中，会通过构造器重新创建一个新的对象。反序列化的过程是将二进制数据解码为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);
        }
    }

#### 运行结果： ####

![b61ec86486414e3d97c11b610b2d3074.png][]

上面代码运行结果是`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();
        }
    }

#### 运行结果： ####

![46ee66c134bb4fe58ad1a280ad4b40c2.png][]

**源码解析：**

ObjectInputStream类

public final Object readObject() throws IOException, ClassNotFoundException{
        ...
        // if nested read, passHandle contains handle of enclosing object
        int 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() 方法执行结果为true
        if (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;
        }
    }

#### 运行结果： ####

![c620b7a50f08402285da65695a551115.png][]

或：

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

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.  通过源代码查看使用的是哪儿种单例模式

![ab6d456ed36b4aed9a978d0a24822a1a.png][]

> 从上面源代码中可以看出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"));
        }
    }

[ad8657086e824f80ad8045fd3abd1fb3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/01c09377284a4021bc69f5c57e7e5648.png
[b61ec86486414e3d97c11b610b2d3074.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/6d4d4a0c5fc84f1882345a51144e1a54.png
[46ee66c134bb4fe58ad1a280ad4b40c2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/2de622ca8f5a427a8d5bb30d7a23353b.png
[c620b7a50f08402285da65695a551115.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/ecedfbef2d9d40ceb20b8874d6595b77.png
[ab6d456ed36b4aed9a978d0a24822a1a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/b17a37683fef4f81b6259e668e4f668f.png