单例设计模式反射，序列化漏洞及解决方案

朱雀 2022-06-17 09:13 111阅读 0赞

单例设计模式的实现方式有很多种，如饿汉式，懒汉式，双重检查锁，静态内部类，枚举等等，但是在平时的开发中，我们实现的单利模式是有一定的漏洞的，可以通过反射或者序列化以及反序列化获取不同的实例，虽然这个漏洞在系统运行的时候不会体现出来，但是在开发时也是值得注意的问题。

## **使用反射技术来获取不同的实例：** ##

以下是一个简单的饿汉式的单利模式的代码实现：

当我们需要获取Singleton对象的时候，直接调用静态方法getInstance就可以了：

package com.spring.designmodel;
    
    import java.io.IOException;
    import java.lang.reflect.Constructor;
    
    
    public class SingletonTest {
    
        public static void main(String[] args) {
            try {
                Singleton singleton1 = Singleton.getInstance();
                Singleton singleton2 = Singleton.getInstance();
                System.out.println(singleton1);
                System.out.println(singleton2);
                //使用反射获取对象实例
                Class<Singleton> clazz1 = (Class<Singleton>) Class.forName("com.spring.designmodel.Singleton");
                Constructor<Singleton> constructor1 = clazz1.getDeclaredConstructor(null);
                constructor1.setAccessible(true);
                Singleton singleton3 = constructor1.newInstance();
    
                Class<Singleton> clazz2 = (Class<Singleton>) Class.forName("com.spring.designmodel.Singleton");
                Constructor<Singleton> constructor2 = clazz2.getDeclaredConstructor(null);
                constructor2.setAccessible(true);
                Singleton singleton4 = constructor2.newInstance();
                System.out.println(singleton3);
                System.out.println(singleton4);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

但是学过反射的人都知道，通过反射技术也能获取到一个类的实例对象，即使它的构造函数时私有化的，我们也可以通过暴力访问来调用其构造函数，所以以上测试类的运行结果为：

com.spring.designmodel.Singleton@73fbaf73  
com.spring.designmodel.Singleton@73fbaf73  
com.spring.designmodel.Singleton@3f4f44  
com.spring.designmodel.Singleton@3c6cf97c

可以看出通过调用getInstance方法获取到的实例是一样的，但是通过反射获取到的实例却是不同的，违反了单例设计模式的思想，那么我们应该怎么解决呢？我们只需要在私有的构造函数中加入一个判断即可：

package com.spring.designmodel;
    
    import java.io.Serializable;
    
    public class Singleton implements Serializable{ 
    
        private static final long serialVersionUID = 1L;
    
        private static final Singleton singleton = new Singleton();
    
        private Singleton(){
            if(null != singleton){
                throw new RuntimeException();
            }
        }
    
        public static Singleton getInstance(){
            return singleton;
        }
    }

此时，我们再次启动测试类，获得到以下结果：

com.spring.designmodel.Singleton@73fbaf73  
com.spring.designmodel.Singleton@73fbaf73  
java.lang.reflect.InvocationTargetException  
at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)  
at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:57)  
at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)  
at java.lang.reflect.Constructor.newInstance(Constructor.java:526)  
at org.springsource.loaded.ri.ReflectiveInterceptor.jlrConstructorNewInstance(ReflectiveInterceptor.java:1075)  
at com.spring.designmodel.SingletonTest.main(SingletonTest.java:19)  
Caused by: java.lang.RuntimeException  
at com.spring.designmodel.Singleton.(Singleton.java:13)  
… 6 more

当然，就解决了使用反射技术来获取不同实例的问题了。

## **使用序列化及反序列化技术获取不同的实例：** ##

如果我们的单例类实现了Serializable接口，那么这个类就能进行序列化和反序列化，测试代码如下：

package com.spring.designmodel;
    
    import java.io.FileInputStream;
    import java.io.FileOutputStream;
    import java.io.ObjectInputStream;
    import java.io.ObjectOutputStream;
    
    
    public class SingletonTest {
    
        public static void main(String[] args){
            try {
                Singleton singleton1 = Singleton.getInstance();
                FileOutputStream fos = new FileOutputStream("d://singleton.txt");
                ObjectOutputStream oos = new ObjectOutputStream(fos);
                oos.writeObject(Singleton.getInstance());
    
                FileInputStream fis = new FileInputStream("d://singleton.txt");
                ObjectInputStream ois = new ObjectInputStream(fis);
                Singleton singleton2 = (Singleton) ois.readObject();
                oos.close();
                ois.close();
                System.out.println(singleton1);
                System.out.println(singleton2);
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

运行结果如下：  
com.spring.designmodel.Singleton@139008b  
com.spring.designmodel.Singleton@221c3dfe

我们发现进过序列化及反序列化之后对象的引用就改变了，显然也是违反了单例设计模式的思想的，跟踪readObject源码后，发现这个方法会先写出一个newInstance,然后判断这个对象中是否存在readResolve这个方法，如果不存在，那么直接返回这个newInstance,如果存在，那么就调用readResolve这个方法，将这个方法的返回值返回给readObject.源码片段如下：

ObjectStreamClass desc = readClassDesc(false);
        desc.checkDeserialize();
        Class<?> cl = desc.forClass();
        if (cl == String.class || cl == Class.class
                || cl == ObjectStreamClass.class) {
            throw new InvalidClassException("invalid class descriptor");
        }
    
        Object obj;
        try {
            obj = desc.isInstantiable() ? desc.newInstance() : null;
        } catch (Exception ex) {
            throw (IOException) new InvalidClassException(
                desc.forClass().getName(),
                "unable to create instance").initCause(ex);
        }

if (obj != null &&
        handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
        {
            Object rep = desc.invokeReadResolve(obj);
            if (unshared && rep.getClass().isArray()) {
                rep = cloneArray(rep);
            }
            if (rep != obj) {
                handles.setObject(passHandle, obj = rep);
            }
        }

由上可知，我们只需要在Singleton这个类中添加一个readResolve这个方法即可。

再次启用测试类，运行结果如下：

com.spring.designmodel.Singleton@403729c5  
com.spring.designmodel.Singleton@403729c5