单例模式，防止反射和反序列化漏洞

一、懒汉式单例模式，解决反射和反序列化漏洞

package com.iter.devbox.singleton;
 
import java.io.ObjectStreamException;
import java.io.Serializable;
 
/**
 * 懒汉式（如何防止反射和反序列化漏洞）
 * @author Shearer
 *
 */
public class SingletonDemo6 implements Serializable{
    
    // 类初始化时，不初始化这个对象（延迟加载，真正用的时候再创建）
    private static SingletonDemo6 instance;
    
    private SingletonDemo6() {
        // 防止反射获取多个对象的漏洞
        if (null != instance) {
            throw new RuntimeException();
        }
    }
    
    // 方法同步，调用效率低
    public static synchronized SingletonDemo6 getInstance() {
        if (null == instance)
            instance = new SingletonDemo6();
        return instance;
    }
 
    // 防止反序列化获取多个对象的漏洞。
    // 无论是实现Serializable接口，或是Externalizable接口，当从I/O流中读取对象时，readResolve()方法都会被调用到。
    // 实际上就是用readResolve()中返回的对象直接替换在反序列化过程中创建的对象。
    private Object readResolve() throws ObjectStreamException {  
        return instance;
    }
}
 
 
package com.iter.devbox.singleton;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
 
public class Client2 {
 
    public static void main(String[] args) throws Exception {
        SingletonDemo6 sc1 = SingletonDemo6.getInstance();
        SingletonDemo6 sc2 = SingletonDemo6.getInstance();
        System.out.println(sc1); // sc1，sc2是同一个对象
        System.out.println(sc2);
        
        // 通过反射的方式直接调用私有构造器（通过在构造器里抛出异常可以解决此漏洞）
/*        Class<SingletonDemo6> clazz = (Class<SingletonDemo6>) Class.forName("com.iter.devbox.singleton.SingletonDemo6");
        Constructor<SingletonDemo6> c = clazz.getDeclaredConstructor(null);
        c.setAccessible(true); // 跳过权限检查
        SingletonDemo6 sc3 = c.newInstance();
        SingletonDemo6 sc4 = c.newInstance();
        System.out.println(sc3);  // sc3，sc4不是同一个对象
        System.out.println(sc4);*/
        
        // 通过反序列化的方式构造多个对象（类需要实现Serializable接口）
        
        // 1. 把对象sc1写入硬盘文件
        FileOutputStream fos = new FileOutputStream("object.out");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(sc1);
        oos.close();
        fos.close();
        
        // 2. 把硬盘文件上的对象读出来
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.out"));
        // 如果对象定义了readResolve()方法，readObject()会调用readResolve()方法。从而解决反序列化的漏洞
        SingletonDemo6 sc5 = (SingletonDemo6) ois.readObject();
        // 反序列化出来的对象，和原对象，不是同一个对象。如果对象定义了readResolve()方法，可以解决此问题。
        System.out.println(sc5); 
        ois.close();
    }
 
}

二、静态内部类式单例模式（解决反射和反序列化漏洞）

package com.iter.devbox.singleton;
 
import java.io.ObjectStreamException;
import java.io.Serializable;
 
/**
 * 静态内部类实现方式（也是一种懒加载方式）
 * 这种方式：线程安全，调用效率高，并且实现了延迟加载
 * 解决反射和反序列化漏洞
 * @author Shearer
 *
 */
public class SingletonDemo7 implements Serializable{
    
    private static class SingletonClassInstance {
        private static final SingletonDemo7 instance = new SingletonDemo7();
    }
    
    // 方法没有同步，调用效率高
    public static SingletonDemo7 getInstance() {
        return SingletonClassInstance.instance;
    }
    
    // 防止反射获取多个对象的漏洞
    private SingletonDemo7() {
        if (null != SingletonClassInstance.instance)
            throw new RuntimeException();
    }
    
    // 防止反序列化获取多个对象的漏洞
    private Object readResolve() throws ObjectStreamException {  
        return SingletonClassInstance.instance;
    }
}
 
 
package com.iter.devbox.singleton;
 
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.lang.reflect.Constructor;
 
public class Client3 {
 
    public static void main(String[] args) throws Exception {
        SingletonDemo7 sc1 = SingletonDemo7.getInstance();
        SingletonDemo7 sc2 = SingletonDemo7.getInstance();
        System.out.println(sc1); // sc1，sc2是同一个对象
        System.out.println(sc2);
        
        // 通过反射的方式直接调用私有构造器（通过在构造器里抛出异常可以解决此漏洞）
        Class<SingletonDemo7> clazz = (Class<SingletonDemo7>) Class.forName("com.iter.devbox.singleton.SingletonDemo7");
        Constructor<SingletonDemo7> c = clazz.getDeclaredConstructor(null);
        c.setAccessible(true); // 跳过权限检查
        SingletonDemo7 sc3 = c.newInstance();
        SingletonDemo7 sc4 = c.newInstance();
        System.out.println("通过反射的方式获取的对象sc3：" + sc3);  // sc3，sc4不是同一个对象
        System.out.println("通过反射的方式获取的对象sc4：" + sc4);
        
        // 通过反序列化的方式构造多个对象（类需要实现Serializable接口）
        
        // 1. 把对象sc1写入硬盘文件
        FileOutputStream fos = new FileOutputStream("object.out");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(sc1);
        oos.close();
        fos.close();
        
        // 2. 把硬盘文件上的对象读出来
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.out"));
        // 如果对象定义了readResolve()方法，readObject()会调用readResolve()方法。从而解决反序列化的漏洞
        SingletonDemo7 sc5 = (SingletonDemo7) ois.readObject();
        // 反序列化出来的对象，和原对象，不是同一个对象。如果对象定义了readResolve()方法，可以解决此问题。
        System.out.println("对象定义了readResolve()方法，通过反序列化得到的对象：" + sc5); 
        ois.close();
    }
 
}

--------------------- 
作者：Lena-Yang 
来源：CSDN 
原文：https://blog.csdn.net/hardwin/article/details/51477359 
版权声明：本文为博主原创文章，转载请附上博文链接！