java序列化与反序列化

我的上一篇博客，介绍了通讯的原理，写了几个关于Socket的几个Demo，那么我们思考下，如何基于Socket进行对象的传输呢？

之前又同学说建议我写博客代码的部分不要截图，直接贴代码，我今天就把代码贴上来吧。来看下我写的Demo吧（代码只是demo，连接啥的我没都没有关闭哦）。

 

public class User {
 private String name;
 public String getName() {
 return name;
 }
 public void setName(String name) {
 this.name = name;
 } }

import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;

public class SocketClientConsumer {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("localhost", 8888);
        ObjectOutputStream objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
        objectOutputStream.writeObject(new User("carry"));
    }
}

import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class SocketServerProvider {

    public static void main(String[] args) throws IOException {
        ServerSocket serverSocket = new ServerSocket(8888);
        Socket socket = serverSocket.accept();
        ObjectInputStream inputStream = new ObjectInputStream(socket.getInputStream());
        try {
            User user = (User) inputStream.readObject();
            System.out.println(user);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

看下运行的结果：

直接报错了，告诉我们没有序列化的异常，我们只需要在User实体上实现 Serializable接口就好了

了解序列化的意义

我们发现对 User 这个类增加一个 Serializable，就可以解决 Java 对象的网络传输问题。这就

是今天想给大家讲解的序列化这块的意义

Java 平台允许我们在内存中创建可复用的 Java 对象，但一般情况下，只有当 JVM 处于运行

时，这些对象才可能存在，即，这些对象的生命周期不会比 JVM 的生命周期更长。但在现实

应用中，就可能要求在 JVM 停止运行之后能够保存(持久化)指定的对象，并在将来重新读取

被保存的对象。Java 对象序列化就能够帮助我们实现该功能

简单来说

序列化是把对象的状态信息转化为可存储或传输的形式过程，也就是把对象转化为字节序列

的过程称为对象的序列化

反序列化是序列化的逆向过程，把字节数组反序列化为对象，把字节序列恢复为对象的过程

成为对象的反序列化

 

常见的序列化和反序列化的协议：

XML、JSON、Protobuf、Thrift和Avro

我们常见的就是JSON形式的序列化吧，在之前webservice流行的时候，XML和SOAP协议，我对这几个协议也不是很清楚，

但是我觉得，我们想要序列化技术肯定要满足跨平台，性能高，传输小等特性吧。我们可以去看下一直知名的框架用的序列化协议吧，我们去github上看下Dubbo有啥协议吧

我们在github上搜索Dubbo，看下他的序列化协议有几种。

这几种主流的协议都有实现，大框架就是不一样。怀着好奇的心情，我也打算实现几种序列化技术，来简单的分析一下这些序列化技术的性能吧。

我们来定义一个序列化接口

public interface ISerializer {

    // 序列化

    <T> byte[] serialize(T obj);

    // 反序列化
    <T> T deserialize(byte[] data, Class<T> clazz);
}

我们先来看下Java提供的序列化技术：

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

/**
 * java方式实现序列化和反序列化
 */
public class JavaSerializer implements ISerializer {
    @Override
    public <T> byte[] serialize(T obj) {
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        try {
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
            objectOutputStream.writeObject(obj);
            return byteArrayOutputStream.toByteArray();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return new byte[0];
    }

    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) {
        ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(data);
        try {
            ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
            return (T) objectInputStream.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

可以找一个main方法，测试一下这个java序列化的：

public static void xStreamSerial() {
        ISerializer javaSerializer = new XStreamSerializer();
        User javaUser = new User("carry");
        byte[] serialize = javaSerializer.serialize(javaUser);
        System.out.println("xStreamSerial序列化的长度:" + serialize.length);
        // 反序列化
        User user = javaSerializer.deserialize(serialize, User.class);
        System.out.println(user);
    }

这就java原生实现序列化与反序列化的实现

2.我们来看下把对象序列化成xml的格式，我们来利用XStream来实现：

<dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.12</version>
        </dependency>

import com.thoughtworks.xstream.XStream;
import com.thoughtworks.xstream.io.xml.DomDriver;

public class XStreamSerializer implements ISerializer {
    XStream xStream = new XStream(new DomDriver());
    @Override
    public <T> byte[] serialize(T obj) {
        xStream.allowTypesByWildcard(new String[] {
                "com.carry.**"  //你的包路径
        });
        byte[] bytes = xStream.toXML(obj).getBytes();
        return bytes;
    }

    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) {
        xStream.allowTypesByWildcard(new String[] {
                "com.carry.**"  //你的包路径
        });
        return (T) xStream.fromXML(new String(data));
    }
}

 public static void xStreamSerial() {
        ISerializer javaSerializer = new XStreamSerializer();
        User javaUser = new User("carry");
        byte[] serialize = javaSerializer.serialize(javaUser);
        System.out.println("xStreamSerial序列化的长度:" + serialize.length);
        // 反序列化
        User user = javaSerializer.deserialize(serialize, User.class);
        System.out.println(user);
    }

 

我们再看下利用fastJson来实现对象的序列化：

import com.alibaba.fastjson.JSON;

public class FastJsonSeriliazer implements ISerializer {

    @Override
    public <T> byte[] serialize(T obj) {
        return JSON.toJSONString(obj).getBytes();
    }

    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) {
        return JSON.parseObject(new String(data), clazz);
    }
}

   public static void fastJsonSerial() {
        ISerializer javaSerializer = new FastJsonSeriliazer();
        User javaUser = new User("carry");
        byte[] serialize = javaSerializer.serialize(javaUser);
        System.out.println("fastJsonSerial序列化的长度:" + serialize.length);
        // 反序列化
        User user = javaSerializer.deserialize(serialize, User.class);
        System.out.println(user);
    }

注意：这个fastJson实现一个序列化一个大坑就是，如果你的User实体的路径有中文，他会报错，我可以给你们演示一下：

其实还有几种技术实现这个序列化技术，我们都可以去实现的，我就玩这三种就好了。

我再想讲一下一个和序列化相关的知识点：

transient，不知道大家知不知道这个关键字是啥含义：

我们创建的类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。

绕开 transient 机制的办法

虽然 name 被 transient 修饰，但是通过我们写的这两个方法依然能够使得 name 字段正确

被序列化和反序列化

 

writeObject 和 readObject 原理

 

writeObject 和 readObject 是两个私有的方法，他们是什么时候被调用的呢？从运行结果来

看，它确实被调用。而且他们并不存在于 Java.lang.Object，也没有在 Serializable 中去声明。

我们唯一的猜想应该还是和 ObjectInputStream 和 ObjectOutputStream 有关系，所以基于

这个入口去看看在哪个地方有调用：

 

从源码层面来分析可以看到，readObject 是通过反射来调用的。

其实我们可以在很多地方看到 readObject 和 writeObject 的使用，比如 HashMap，ArrayList。

 

我们如果在User实体的name属性，加上这个transient ，可以在看下这个执行结果：

如果我们再User实体里面写上readObject 和 writeObject这两个方法，效果就不一样了：

  private void writeObject(java.io.ObjectOutputStream s) throws IOException {
        s.defaultWriteObject();

        s.writeObject(name);
    }

    private void readObject(java.io.ObjectInputStream s) throws IOException, ClassNotFoundException {
        s.defaultReadObject();
        name=(String)s.readObject();
    }

我们上面已经分析过了，这个会在java.io.ObjectInputStream 里面进行反射调用的，只要方法名称是这两个，注意不要乱起方法名称哦。

其实这样的使用在Java集合里面大量使用，我们可以看下ArrayList里面的使用：

这个存放list集合的数组都不让他参与序列化的，但是这些属性我们肯定是想要传输的，就可以利用我们上面提到的来绕过这个。我们看下ArrayList是不是这样实现的。

哈哈，确实是这样的。我们可以思考下为啥这样做：

我们知道集合有一个扩容机制，你的elementData数组肯定有很多空闲的空间，如果一股脑交给自带的序列化机制去实现，肯定有一些无用的序列化次数，性能比较差，如果你根据你数组的数据量来序列化，次数肯定少很多。