文档章节

单例、序列化与反序列化

侠客人生
 侠客人生
发布于 2017/07/21 13:59
字数 1724
阅读 20
收藏 0

阅读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方法,并在该方法中指定要返回的对象的生成策略,就可以方式单例被破坏。

总结

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

© 著作权归作者所有

共有 人打赏支持
侠客人生
粉丝 15
博文 43
码字总数 82954
作品 0
朝阳
为什么我墙裂建议大家使用枚举来实现单例。

关于单例模式,我的博客中有很多文章介绍过。作为23种设计模式中最为常用的设计模式,单例模式并没有想象的那么简单。因为在设计单例的时候要考虑很多问题,比如线程安全问题、序列化对单例的...

06/10
0
0
为什么我墙裂建议大家使用枚举来实现单例

我们知道,单例模式,一般有七种写法,那么这七种写法中,最好的是哪一种呢?为什么呢?本文就来抽丝剥茧一下。 哪种写单例的方式最好 在StakcOverflow中,有一个关于What is an efficient ...

冷_6986
06/13
0
0
深度解析单例与序列化之间的爱恨情仇~

转载:原文链接:https://mp.weixin.qq.com/s/iXC47w4tMfpZzTNxS_JQOw 首先来写一个单例的类:code 1 接下来是一个测试类: code 2 输出结构为false,说明: 通过对Singleton的序列化与反序列化...

u010398771
02/04
0
0
Java基础知识学习(Java中有哪几种引用 & 最佳单列模式分析)

1、Java中有哪几种引用?它们的含义和区别是什么? 2、请用Java实现一个线程安全且高效的单例模式。 (1)利用了类加载机制来保证只创建一个instance实例,只要应用中不使用内部类,JVM就不会去...

Kael_祈求者
01/03
0
0
单例模式被反序列化而变多例

单例模式在不考虑序列化的情况下,无论勤加载还是懒加载,均是安全的.看你代码是怎么写的了. 但当单例执行了Serializiable接口以后,就不安全了. 将单例序列化再反序列化, 单例就多了一份copy,...

xpbug
2012/11/07
477
2

没有更多内容

加载失败,请刷新页面

加载更多

docker多容器部署lnmp环境

环境:RHEL7.5 ip:192.168.10.102,主机名:lb02 一、创建web、数据库目录 web网站目录为:/wwwroot,属主属组:www [root@lb02 ~]# mkdir /wwwroot[root@lb02 ~]# useradd -s /sbin/nolo...

人在艹木中
11分钟前
0
0
eclipse运行springboot项目报错‘找不到或无法加载主类’

这是一个很烦躁的问题~,往往困住大家好长时间,然后各种百度。借此,咱将这个问题有可能产生的原因进行一下总结。若有不完善之处欢迎大家在下面留言指出~~ Duang!问题出现 然后开始尝试解决...

Code辉
32分钟前
0
0
springboot oauth2 跨域设置

@Overridepublic void configure(HttpSecurity http) throws Exception { http .authorizeRequests() .antMatchers("/security/**") .authentica......

昆虫大侠
34分钟前
0
0
08-利用思维导图梳理JavaSE-泛型

08-利用思维导图梳理JavaSE-泛型 主要内容 1.泛型的基本概念 1.1.定义 1.2.使用前提 1.3.使用泛型的好处 2.泛型的使用 2.1.泛型类定义 2.2.泛型对象定义 2.3.泛型中的构造方法 2.4.泛型方法的...

飞鱼说编程
36分钟前
0
0
Docker 部署 Spring Boot 项目指南

仅想在Docker里运行一个Spring Boot项目,捣鼓了许久。。。 本文主要适用于Windows环境下的Docker 一、运行环境 Windows 10 Maven 3.5 Docker 18.06.1-ce-win73 (19507) 二、创建Spring Boot...

AmosWang
42分钟前
3
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部