简易之手写序列化和反序列化框架

序列化和反序列化

gitee地址:https://gitee.com/kylin1991_admin/serializer-framework

1、概念

  • 个人理解,序列化和反序列化就是一种压缩和解压的过程。压缩和解压讲究一个速度和大小

2、translate

  • 禁止序列化

3、破坏translate

java 和file 、javaXML 都可以通过重写私有readObject和writeObject进行破坏translate修饰

其他框架默认不会,例如XStram、FastJson、Protobuf等默认不会序列化translate修饰的

4、手写serialize框架

a、设计ISerializer接口

public interface ISerializer {

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

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

b、子类JavaSerializer

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 e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }
}

c、子类JavaXMLSerializer

public class JavaXMLSerializer implements ISerializer {


    // 使用java的,必须要进行 get set 方法。同时需要再类中注解  @XmlRootElement
    @Override
    public <T> byte[] serialize(T obj) {
        StringWriter sw = new StringWriter();
        try {
            JAXBContext context = JAXBContext.newInstance(obj.getClass());

            Marshaller marshaller = context.createMarshaller();
            marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT,
                    Boolean.TRUE);
            marshaller.marshal(obj, sw);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return sw.toString().getBytes();
    }


    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) {
        Object xmlObject = null;
        try {
            JAXBContext context = JAXBContext.newInstance(clazz);
            // 进行将Xml转成对象的核心接口
            Unmarshaller unmarshaller = context.createUnmarshaller();
            StringReader sr = new StringReader(new String(data));
            xmlObject = unmarshaller.unmarshal(sr);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) xmlObject;

    }
}

d、子类FastJsonSerializer

public class FastJsonSerializer implements ISerializer {
    /*
        
        
            com.alibaba
            fastjson
            1.2.68
        
    不能序列化translate修饰的字段
     */
    @Override
    public <T> byte[] serialize(T obj) {
        return JSONObject.toJSONBytes(obj);
    }

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

e、子类XtreamSerializer

public class XtreamSerializer implements ISerializer {
    private static final XStream xStream = new XStream();
    /*
        需要引入jar包
        
        
            com.thoughtworks.xstream
            xstream
            1.4.11.1
        

        不能序列化translate修饰的字段
     */

    @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));
    }
}

f、子类ProtostuffSerializer

public class ProtostuffSerializer implements ISerializer {
    private static LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
    private static Map<Class<?>, Schema<?>> schemaCache = new ConcurrentHashMap<>();

    /*
            
        
            io.protostuff
            protostuff-core
            1.7.0
        
        
        
            io.protostuff
            protostuff-runtime
            1.7.0
        


        如果是用的protobuf的话会有点小麻烦,所以后面出来的protostuff(是一个基于protobuf实现的序列化方法)
        貌似有自己的语言  自己的编译环境。。需要配置?
        可以配置protoc  用protoc来进行序列化和反序列化


    不能序列化translate修饰的字段
     */
    @Override
    public <T> byte[] serialize(T obj) {
        if (obj == null) {
            throw new NullPointerException();
        }
        Class<T> clazz = (Class<T>) obj.getClass();
        Schema<T> schema = getSchema(clazz);
        byte[] data;
        try {
            data = ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        } finally {
            buffer.clear();
        }

        return data;
    }

    @Override
    public <T> T deserialize(byte[] data, Class<T> clazz) {
        Schema<T> schema = getSchema(clazz);
        T obj = schema.newMessage();
        ProtostuffIOUtil.mergeFrom(data, obj, schema);
        return obj;
    }

    /**
     *  保证schema单例
     * @param clazz
     * @param 
     * @return
     */
    private static <T> Schema<T> getSchema(Class<T> clazz) {
        Schema<T> schema = (Schema<T>) schemaCache.get(clazz);
        if (schema == null) {
            //这个schema通过RuntimeSchema进行懒创建并缓存
            //所以可以一直调用RuntimeSchema.getSchema(),这个方法是线程安全的
            schema = RuntimeSchema.getSchema(clazz);
            if (schema != null) {
                schemaCache.put(clazz, schema);
            }
        }

        return schema;
    }

    /*
    
    
        com.google.protobuf
        protobuf-java
        3.11.4
    

     */

}

5、序列化框架介绍

XML 序列化框架介绍

XML 序列化的好处在于可读性好,方便阅读和调试。但是序列化以后的字节码文件比较大, 而且效率不高,适用于对性能不高,而且QPS较低的企业级内部系统之间的数据交换的场景, 同时XML又具有语言无关性,所以还可以用于异构系统之间的数据交换和协议。比如我们熟 知的Webservice,就是采用XML格式对数据进行序列化的。XML序列化/反序列化的实现方 式有很多,熟知的方式有XStream和Java自带的XML序列化和反序列化两种

JSON 序列化框架

JSON(JavaScript Object Notation)是一种轻量级的数据交换格式,相对于XML来说,JSON 的字节流更小,而且可读性也非常好。现在JSON数据格式在企业运用是最普遍的 JSON序列化常用的开源工具有很多

  • Jackson (https://github.com/FasterXML/jackson)
  • 阿里开源的FastJson (https://github.com/alibaba/fastjon)
  • Google的GSON (https://github.com/google/gson) 这几种 json 序列化工具中,Jackson 与 fastjson 要比 GSON 的性能要好,但是 Jackson、 GSON的稳定性要比Fastjson好。而fastjson的优势在于提供的api非常容易使用

Hessian 序列化框架

Hessian是一个支持跨语言传输的二进制序列化协议,相对于Java默认的序列化机制来说, Hessian具有更好的性能和易用性,而且支持多种不同的语言
实际上 Dubbo 采用的就是 Hessian 序列化来实现,只不过 Dubbo 对 Hessian 进行了重构, 性能更高

Avro 序列化

Avro是一个数据序列化系统,设计用于支持大批量数据交换的应用。它的主要特点有:支持 二进制序列化方式,可以便捷,快速地处理大量数据;动态语言友好,Avro提供的机制使动 态语言可以方便地处理Avro数据。

kyro 序列化框架

Kryo是一种非常成熟的序列化实现,已经在Hive、Storm)中使用得比较广泛,不过它不能 跨语言. 目前 dubbo 已经在 2.6 版本支持 kyro 的序列化机制。它的性能要优于之前的 hessian2

Protobuf 序列化框架

Protobuf是Google的一种数据交换格式,它独立于语言、独立于平台。Google提供了多种 语言来实现,比如Java、C、Go、Python,每一种实现都包含了相应语言的编译器和库文件, Protobuf是一个纯粹的表示层协议,可以和各种传输层协议一起使用。 Protobuf使用比较广泛,主要是空间开销小和性能比较好,非常适合用于公司内部对性能要 求高的 RPC 调用。 另外由于解析性能比较高,序列化以后数据量相对较少,所以也可以应 用在对象的持久化场景中 但是要使用Protobuf会相对来说麻烦些,因为他有自己的语法,有自己的编译器,如果需要 用到的话必须要去投入成本在这个技术的学习中

protobuf有个缺点就是要传输的每一个类的结构都要生成对应的proto文件,如果某个类发 生修改,还得重新生成该类对应的proto文件

可以根据自己的情况接入各种序列化框架序列化对比地址:

https://github.com/eishay/jvm-serializers/wiki

除了以上,再看看如下的知识是否理解了?

1、什么是序列化,Java是如何实现序列化的

  • 针对对象的状态进行保存,至于对象的方法,序列化不关心

2、如果一个子类实现了序列化,父类没有实现,那么父类中的成员变量能否被序列化?

3、你有了解过哪些序列化技术?以及他们之间的差异性?

4、transient是干嘛的?

5、有什么方法能够绕过transient的机制。这个实现机制的原理是什么?

6、serializable的安全性如何保证?7.有没有了解过protobuf,它的序列化实现原理是什么?

7、serialVersionUID的 作 用 是 什 么 ? 如 果 我 不 设 置serialVersionUID,有没有问题?

你可能感兴趣的:(•,Java架构,——【分布式架构基础】)