Java 实现序列化和反序列化多种方式

序列化（Serialization）：是将对象的状态信息转化为可以存储或者传输的形式的过程，一般将一个对象存储到一个储存媒介，例如档案或记忆体缓冲等，在网络传输过程中，可以是字节或者XML等格式；

反序列化：而字节或者XML格式的可以还原成完全相等的对象，这个相反的过程又称为反序列化；

常见的协议有XML、json（JavaScript Object Notation, JS 对象标记）、Hessian、Fastjson、Thrift、Avro、Protobuf等

我们来一起看使用方法，开始介绍使用之前先定义一个统一的接口：

public interface ISerializer {

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


    <T> T deserialize(byte[] data,Class<T> clazz);
}

1. xml

   public class XStreamSerializer implements ISerializer{
   
       XStream xStream=new XStream(new DomDriver());
   
       @Override
       public <T> byte[] serialize(T obj) {
   
           return xStream.toXML(obj).getBytes();
       }
   
       @Override
       public <T> T deserialize(byte[] data, Class<T> clazz) {
           return (T)xStream.fromXML(new String(data));
       }
   }

    

2. Fastjson

   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 (T)JSON.parseObject(new String(data),clazz);
       }
   }

    

3. hessian

   public class HessianSerializer implements ISerializer{
       @Override
       public <T> byte[] serialize(T obj) {
           ByteArrayOutputStream outputStream=new ByteArrayOutputStream();
           HessianOutput hessianOutput=new HessianOutput(outputStream);
           try {
               hessianOutput.writeObject(obj);
               return outputStream.toByteArray();
           } catch (IOException e) {
               e.printStackTrace();
           }
   
           return new byte[0];
       }
   
       @Override
       public <T> T deserialize(byte[] data, Class<T> clazz) {
           ByteArrayInputStream inputStream=new ByteArrayInputStream(data);
           HessianInput hessianInput=new HessianInput(inputStream);
           try {
               return (T)hessianInput.readObject();
           } catch (IOException e) {
               e.printStackTrace();
           }
           return null;
       }
   }

    

4. java原生的

   public class JavaSerializer implements ISerializer{
   
   
       @Override
       public <T> byte[] serialize(T obj) {
           ByteArrayOutputStream byteArrayOutputStream=
                   new ByteArrayOutputStream();
           try {
               ObjectOutputStream outputStream=
                       new ObjectOutputStream(byteArrayOutputStream);
   
               outputStream.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 e) {
               e.printStackTrace();
           } catch (ClassNotFoundException e) {
               e.printStackTrace();
           }
           return null;
       }
   }

   以上是几种常见的java序列化和反序列化协议的使用

  他们的序列化后的大小:

xml>java原生>hessian>json>protobuf