单例、序列化与反序列化
单例、序列化与反序列化
侠客人生 发表于6个月前
单例、序列化与反序列化
  • 发表于 6个月前
  • 阅读 17
  • 收藏 0
  • 点赞 0
  • 评论 0

标题:腾讯云 新注册用户域名抢购1元起>>>   

阅读Java源码的方式介绍序列化是如何破坏单例模式的,以及如何避免序列化对单例的破坏。

单例模式,是设计模式中最简单的一种。通过单例模式可以保证系统中一个类只有一个实例而且该实例易于外界访问,从而方便对实例个数的控制并节约系统资源。如果希望在系统中某个类的对象只能存在一个,单例模式是最好的解决方案。关于单例模式的使用方式,可以阅读:设计模式——单例模式

https://my.oschina.net/u/2505908/blog/1477046

但是,单例模式真的能够实现实例的唯一性吗?

答案是否定的,很多人都知道使用反射可以破坏单例模式,除了反射以外,使用序列化与反序列化也同样会破坏单例。

序列化对单例的破坏

首先来写一个单例的类:

/**
 * 
 * @Description:懒汉式——双重锁  
 * @author:侠客人生
 * @date:2017-4-18 上午7:18:56   
 * @version:V1.0  
 * @Copyright:2017 侠客人生 Inc. All rights reserved.
 */
public class Singleton {
   //3 创建变量来存储实例
   /**
    * 通过volatile 让instance具有可见性,但不能保证它具有原子性。
    */
   private static volatile Singleton instance = null;

   // 定义变量记录调用的次数
   /**
    * AtomicInteger 原子操作,线程安全
    */
   private static AtomicInteger count = new AtomicInteger(0);
   
   //私有构造方法,好在内部控制创建实例的数目
   private Singleton() {
      count.incrementAndGet();
   }
   
   public void show(){
      System.out.println("初始化实例次数:"+count);
   }

   /**
    * 通过这个单例问题大家一定要学会两个编程思想
    *  1) 延迟加载的思想
    *  2) 缓存思想
    *  我们再开发过程中,这两个思想会在我们的项目中经常使用,我们可以借鉴懒汉式去写自己的缓存来提高性能
    */
   //2.提供一个全局访问点
   //避免先生鸡还是先有蛋的问题,我们static 让其变成类级方法
   public static Singleton getInstance(){
      //4 判断我们instance 是否为空 B
      if(instance == null){
         /**
          * synchronized 保证其操作的原子性
          */
         synchronized (Singleton.class) {
            if(instance==null){
               //4.1 直到需要用我才去创建 A B
               instance = new Singleton();
            }
         }
        
      }
      //4.1 直接返回已经创建好的实例
      return instance;
   }

   /**
    * 从时间和空间角度分析:时间 换 空间
    * 从线程安全角度分析:线程不安全
    */
   
     private Object readResolve() {
           return instance;
    }
}

接下来是一个测试类:

code 2

public class SingletonDemo {

   /**   
    * @Title:main   
    * @Description: 反序列化单例  
    * @param:@param args      
    * @return:void      
    * @throws   
    */
   public static void main(String[] args) throws Exception {
         //Write Obj to file
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("Singleton"));
        oos.writeObject(Singleton.getInstance());
        //Read Obj from file
        File file = new File("Singleton");
        ObjectInputStream ois =  new ObjectInputStream(new FileInputStream(file));
        Singleton newInstance = (Singleton) ois.readObject();
        //判断是否是同一个对象
        System.out.println(newInstance == Singleton.getInstance());
 
   }

}

输出结构为false,说明:

通过对Singleton的序列化与反序列化得到的对象是一个新的对象,这就破坏了Singleton的单例性。

这里,在介绍如何解决这个问题之前,我们先来深入分析一下,为什么会这样?在反序列化的过程中到底发生了什么。

ObjectInputStream

对象的序列化过程通过ObjectOutputStream和ObjectInputputStream来实现的,那么带着刚刚的问题,分析一下ObjectInputputStream 的readObject 方法执行情况到底是怎样的。

为了节省篇幅,这里给出ObjectInputStream的readObject的调用栈:

readObject--->readObject0--->readOrdinaryObject--->checkResolve

这里看一下重点代码,readOrdinaryObject方法的代码片段:
code 3

private Object readOrdinaryObject(boolean unshared)throws IOException{
    //此处省略部分代码
    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);
        }
    }
    return obj;
}


代码3:

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

这里创建的这个obj对象,就是本方法要返回的对象,也可以暂时理解为是ObjectInputStream的readObject返回的对象。

isInstantiable:如果一个serializable/externalizable的类可以在运行时被实例化,那么该方法就返回true。针对serializable和externalizable我会在其他文章中介绍。

desc.newInstance:该方法通过反射的方式调用无参构造方法新建一个对象。

所以。到目前为止,也就可以解释,为什么序列化可以破坏单例了?

答:序列化会通过反射调用无参数的构造方法创建一个新的对象。

那么,接下来我们再看刚开始留下的问题,如何防止序列化/反序列化破坏单例模式。

防止序列化破坏单例模式

先给出解决方案,然后再具体分析原理:

只要在Singleton类中定义readResolve就可以解决该问题:

code 4

import java.io.Serializable;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * 
 * @Description:懒汉式   
 * @author:侠客人生
 * @date:2017-4-18 上午7:18:56   
 * @version:V1.0  
 * @Copyright:2017 侠客人生 Inc. All rights reserved.
 */
public class Singleton implements Serializable {
   //3 创建变量来存储实例
   /**
    * 通过volatile 让instance具有可见性,但不能保证它具有原子性。
    */
   private static volatile Singleton instance = null;

   // 定义变量记录调用的次数
   /**
    * AtomicInteger 原子操作,线程安全
    */
   private static AtomicInteger count = new AtomicInteger(0);
   
   //私有构造方法,好在内部控制创建实例的数目
   private Singleton() {
      count.incrementAndGet();
   }
   
   public void show(){
      System.out.println("初始化实例次数:"+count);
   }

   /**
    * 通过这个单例问题大家一定要学会两个编程思想
    *  1) 延迟加载的思想
    *  2) 缓存思想
    *  我们再开发过程中,这两个思想会在我们的项目中经常使用,我们可以借鉴懒汉式去写自己的缓存来提高性能
    */
   //2.提供一个全局访问点
   //避免先生鸡还是先有蛋的问题,我们static 让其变成类级方法
   public static Singleton getInstance(){
      //4 判断我们instance 是否为空 B
      if(instance == null){
         /**
          * synchronized 保证其操作的原子性
          */
         synchronized (Singleton.class) {
            if(instance==null){
               //4.1 直到需要用我才去创建 A B
               instance = new Singleton();
            }
         }
        
      }
      //4.1 直接返回已经创建好的实例
      return instance;
   }

   /**
    * 从时间和空间角度分析:时间 换 空间
    * 从线程安全角度分析:线程不安全
    */
   
    //反序列必须
     private Object readResolve() {
           return instance;
    }
}

具体原理,我们回过头继续分析code 3中的第二段代码:

code 3.2

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

            }

        }

hasReadResolveMethod:如果实现了serializable 或者 externalizable接口的类中包含readResolve则返回true

invokeReadResolve:通过反射的方式调用要被反序列化的类的readResolve方法。

所以,原理也就清楚了,主要在Singleton中定义readResolve方法,并在该方法中指定要返回的对象的生成策略,就可以方式单例被破坏。

总结

在涉及到序列化的场景时,要格外注意他对单例的破坏。

共有 人打赏支持
粉丝 14
博文 43
码字总数 82954
×
侠客人生
如果觉得我的文章对您有用,请随意打赏。您的支持将鼓励我继续创作!
* 金额(元)
¥1 ¥5 ¥10 ¥20 其他金额
打赏人
留言
* 支付类型
微信扫码支付
打赏金额:
已支付成功
打赏金额: