java序列化和反序列化

引语:

    平时咱们在运行程序的时候,建立的对象都在内存中,当程序中止或者中断了,对象也就不复存在了.若是咱们能将对象保存起来,在须要使用它的时候在拿出来使用就行了,而且对象的信息要和咱们保存
时的信息一致.序列化就能够解决了这样的问题.序列化固然不止一种方式,以下:

序列类型	是否跨语言	优缺点
hession	支持	跨语言,序列化后体积小,速度较快
protostuff	支持	跨语言,序列化后体积小,速度快,可是须要Schema,能够动态生成
jackson	支持	跨语言,序列化后体积小,速度较快,且具备不肯定性
fastjson	支持	跨语言支持较困难,序列化后体积小,速度较快,只支持java,c#
kryo	支持	跨语言支持较困难,序列化后体积小,速度较快
fst	不支持	跨语言支持较困难,序列化后体积小,速度较快，兼容jdk
jdk	不支持	序列化后体积很大,速度快

咱们今天介绍的就是java原生的Serializable序列化.
先列一下概念:
序列化:序列化是将对象的状态信息转换为能够存储或传输的形式的过程
反序列化:从存储或传输形式还原为对象

Serializable的使用

序列化使用起来很简单只须要实现Serializable接口便可,而后序列化(序列化是将对象的状态信息转换为能够存储或传输的形式的过程)和反序列化(反之,从存储或传输形式还原为对象).
只要使用ObjectOutputStream和ObjectInputStream将对象转为二进制序列和还原为java对象.话很少说,看下代码示例:

private static void testSerializable(String fileName) throws IOException {
       try (ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream(fileName))) {
           // "XXX" 的String也能够直接做为对象进行反序列化的
           objectOutputStream.writeObject("test serializable");
           SerializableData data = new SerializableData(1, "testStr");
           objectOutputStream.writeObject(data);
       }
   }

   private static void testDeserializable(String fileName) throws IOException, ClassNotFoundException {
       try (ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream(fileName))) {
           String str = (String) objectInputStream.readObject();
           System.out.println("String的反序列化: " + str);
           SerializableData readData = (SerializableData) objectInputStream.readObject();
           System.out.println("反序列化的对象: " + readData.toString());
           // 输出:反序列化的对象: SerializableData(testInt=1, testStr=testStr)
       }
   }

// 使用到的类
@Data
@AllArgsConstructor
class SerializableData implements Serializable {

    private Integer testInt;

    private String testStr;
}

第一个方法是传入文件路径,将String和SerializableData对象序列化到fileName指定的文件中;第二个方法是反序列化将文件中的二进制还原为java对象.
这里其实比较简单没有什么大问题,稍微提一句的就是writeObject这个方法是能够直接将"写入的字符串"这种形式的对象直接序列化为二进制的.
这里还有一点就是反序列化的版本号必须和本来对象的版本号(private static final long serialVersionUID = 1L;这个由于是本身测试因此没有写默认是1L,修改后,反序列化的对象版本号不一致会报错)一致,而且jvm能找到反序列化的文件的位置,不然都会失败.

transient关键字

简单的使用序列化和反序列化应该没有什么问题,咱们再来看看transient关键字是啥?在某些场景下,咱们须要写入或者还原的数据中其实有咱们不须要透露或者说不想暴露给外部的数据,若是咱们将这些隐私的数据序列化,在反序列化出来,
那么这些信息就泄漏了.而transient关键字呢,就是防止这种事情的发生.
当属性被加上了transient关键字之后,序列化时不会将该属性的值给写入,因此反序列化的时候咱们会发现本来写入的数据,还原出来是null.
咱们写一个例子看看是不是这样呢?

private static void testTransient() throws IOException, ClassNotFoundException {
       String fileName = "transientData.txt";
       try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName))) {
           Account data = new Account(1, "user1", "123456");
           out.writeObject(data);
       }
       try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName))) {
           Account readData = (Account) in.readObject();
           System.out.println("transient关键字的对象: " + readData.toString());
           // 输出: transient关键字的对象: Account(id=1, userName=user1, idCardNumber=null)
       }
   }

// 对应的对象
@Data
@AllArgsConstructor
class Account implements Serializable {

    private Integer id;

    private String userName;

    private transient String idCardNumber;
}

这里咱们有一个Account对象,咱们不想暴露出咱们的省份证号码idCardNumber,因而乎加上了transient关键字.
而后将idCardNumber已经初始化过的data对象序列化,当咱们再反序列化去取得这个idCardNumber的值的时候,发现确实对象的idCardNumber是null,transient是起做用的.
若是是对基本类型数据加上transitent话,会获得对应的默认值,就比如是int的数据类型,获得的就是0.

Externalizable的使用

使用过自动的序列化和反序列化之后,咱们又想在序列化和反序列化的时候咱们能不能本身控制呢?在序列化和反序列化的时候咱们能不能加点日志或者其余的操做之类的呢?
是的,阔以的.只须要轻轻一点,实现Externalizable接口便可,和Serializable使用差很少.

private static void testExternalizable() throws IOException, ClassNotFoundException {
        String fileName = "testExternalizable.txt";
        try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName))) {
            Account2 data = new Account2("user1", 1);
            out.writeObject(data);
        }
        try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName))) {
            Account2 readData = (Account2) in.readObject();
            System.out.println("Externalizable的对象: " + readData.toString());
        }
    }

// 使用到的对象
@Data
@AllArgsConstructor
class Account2 implements Externalizable {

    private Integer id;

    private String userName;

    private transient String idCardNumber;

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        System.out.println("执行了writeExternal方法");
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        System.out.println("执行了readExternal方法");
    }
}

若是执行了上面的代码,恭喜你,得到一个Exception的奖励.大概长这样,java.io.InvalidClassException:XXX no valid constructor,
Externalizable在执行的时候会调用默认的无参构造函数,并且记住哦,必须是public的,若是没有加public你会发现又奖励了一个Exception给你.
讲道理这个是比较坑的.下面咱们来看看正确的用法,序列化和反序列化都是咱们本身控制的:

private static void testExternalizable() throws IOException, ClassNotFoundException {
       String fileName = "testExternalizable.txt";
       try (ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream(fileName))) {
           Account3 data = new Account3("user1", 1);
           out.writeObject(data);
       }
       try (ObjectInputStream in = new ObjectInputStream(new FileInputStream(fileName))) {
           Account3 readData = (Account3) in.readObject();
           System.out.println("Externalizable的对象: " + readData.toString());
           /**
            * 输出:
            * 执行了writeExternal方法
            * 执行了readExternal方法
            * Externalizable的对象: Account3(userName=user1, id=1)
            */
       }
   }

@ToString
class Account3 implements Externalizable {

    private String userName;

    private Integer id;

    public Account3() {

    }

    public Account3(String userName, Integer id) {
        this.userName = userName;
        this.id = id;
    }

    @Override
    public void writeExternal(ObjectOutput out) throws IOException {
        System.out.println("执行了writeExternal方法");
        out.writeObject(userName);
        out.writeInt(id);
    }

    @Override
    public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
        System.out.println("执行了readExternal方法");
        userName = (String) in.readObject();
        id = in.readInt();

    }
}

总结:

1.咱们介绍了jdk自带的序列化和反序列化(和其中的一些坑点);
2.知道了transient能够将隐私数据不序列化;
3.还有Externalizable能够本身来控制序列化和反序列化的进程.

参考资料:

1.https://docs.oracle.com/javas...
2.https://blog.csdn.net/do_bset...