当前位置:网站首页>序列化和反序列 破坏单例模式,优化深克隆

序列化和反序列 破坏单例模式,优化深克隆

2022-01-15 02:32:00 朝上

1.序列化和反序列化

​ Java 提供了一种对象序列化的机制。用一个字节序列可以表示一个对象,该字节序列包含该对象的数据对象的类型对象中存储的属性等信息。字节序列写出到文件之后,相当于文件中持久保存了一个对象的信息。

​ 反之,该字节序列还可以从文件中读取回来,重构对象,对它进行反序列化对象的数据对象的类型对象中存储的数据信息,都可以用来在内存中创建对象。

ObjectOutputStream类

java.io.ObjectOutputStream 类,将Java对象的原始数据类型写出到文件,实现对象的持久存储。

构造方法

  • public ObjectOutputStream(OutputStream out): 创建一个指定OutputStream的ObjectOutputStream。

构造举例,代码如下:

FileOutputStream fileOut = new FileOutputStream("employee.txt");
ObjectOutputStream out = new ObjectOutputStream(fileOut);

序列化操作

1.一个对象要想序列化,必须满足两个条件:

  • 该类必须实现java.io.Serializable 接口,Serializable 是一个标记接口,不实现此接口的类将不会使任何状态序列化或反序列化,会抛出NotSerializableException
  • 该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的,则该属性必须注明是瞬态的,使用transient 关键字修饰。

2.写出对象方法

  • public final void writeObject (Object obj) : 将指定的对象写出。

ObjectInputStream类

ObjectInputStream反序列化流,将之前使用ObjectOutputStream序列化的原始数据恢复为对象。

构造方法

  • public ObjectInputStream(InputStream in): 创建一个指定InputStream的ObjectInputStream。

反序列化操作1

如果能找到一个对象的class文件,我们可以进行反序列化操作,调用ObjectInputStream读取对象的方法:

  • public final Object readObject () : 读取一个对象。

对于JVM可以反序列化对象,它必须是能够找到class文件的类。如果找不到该类的class文件,则抛出一个 ClassNotFoundException 异常。

反序列化操作2

另外,当JVM反序列化对象时,能找到class文件,但是class文件在序列化对象之后发生了修改,那么反序列化操作也会失败,抛出一个InvalidClassException异常。

发生这个异常的原因如下:

  • 该类的序列版本号与从流中读取的类描述符的版本号不匹配
  • 该类包含未知数据类型
  • 该类没有可访问的无参数构造方法

Serializable 接口给需要序列化的类,提供了一个序列版本号。serialVersionUID 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

public class Employee implements java.io.Serializable {
    
     // 加入序列版本号
     private static final long serialVersionUID = 1L;
     public String name;
     public String address;
     // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
     public int eid; 

     public void addressCheck() {
    
         System.out.println("Address check : " + name + " -- " + address);
     }
}

2.破坏单例模式

单例模式

public class Singleton implements Serializable {
    

    private static final long serialVersionUID = -4998695514017895268L;

    //1.私有化的构造方法
    private Singleton(){
    

    }

    //2.私有的静态内部类
    private static class InnerClass{
    
        //3.私有的静态的本类的实例
        private static Singleton singleton = new Singleton();
    }

    //4.公开的静态的获得本类实例的方法
    public static Singleton getInstance(){
    
        return InnerClass.singleton;
    }

}
public class SingletonTest {
    

    public static void main(String[] args) {
    
        Singleton s1 = Singleton.getInstance();
        try (
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
        ){
    
            //序列化
            oos.writeObject(s1);
            oos.flush();

            //反序列化
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            Singleton s2 = (Singleton)ois.readObject();

            //测试获取的单例,还是不是反序列化获取的实例
            System.out.println(s1 == s2);  //false 
        } catch (IOException | ClassNotFoundException e) {
    
            e.printStackTrace();
        }
    }

}
/* 拿到的不是同一个地址的对象,破坏了单例模式 解决方法: 在Singleton类里加入readResolve()方法 */   
    //定义一个readResolve(),解决反序列化后的实例仍然是此单例
    public Object readResolve(){
    
        return InnerClass.singleton;
    }

3.序列化本身就是一个深克隆

当一个类发生关联时,序列化就是一个深克隆,关联类的对象也随之被克隆

在之前的博客里的完成克隆的方法是

( Student 类关联了 Major 类)

//Object类中clone
    @Override
    protected Student clone() throws CloneNotSupportedException {
    
        //浅克隆
        //return super.clone();

        //深克隆
        Student stu = (Student)super.clone();
        Major major = this.major.clone();
        stu.setMajor(major);

        return stu;
    }

这样写代码的类耦合度太高,当一个类关联多个类,关联类又关联类时,想完成深克隆,每个类都需要实现Cloneable接口重写clone()方法,非常繁琐

解决方案:

我们采用序列化和反序列化解决此问题

 //序列化和反序列化,完成深克隆
    @Override
    protected Student clone() throws CloneNotSupportedException {
    
        try (
                ByteArrayOutputStream baos = new ByteArrayOutputStream();
                ObjectOutputStream oos = new ObjectOutputStream(baos);
        ){
    
            //序列化
            oos.writeObject(this);
            oos.flush();

            //反序列化
            ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bais);
            Student stu = (Student)ois.readObject();
            return stu;
        } catch (IOException | ClassNotFoundException e) {
    
            e.printStackTrace();
        }
        return null;
    }

ByteArrayInputStream是内存流,字节数组输出流在内存中创建一个字节数组缓冲区,所有发送到输出流的数据保存在该字节数组缓冲区中

版权声明
本文为[朝上]所创,转载请带上原文链接,感谢
https://blog.csdn.net/m0_51051154/article/details/120538131

随机推荐