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

序列化和反序列化

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 {
    /*
        <!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.68</version>
        </dependency>
    不能序列化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包
        <!-- https://mvnrepository.com/artifact/com.thoughtworks.xstream/xstream -->
        <dependency>
            <groupId>com.thoughtworks.xstream</groupId>
            <artifactId>xstream</artifactId>
            <version>1.4.11.1</version>
        </dependency>

        不能序列化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<>();

    /*
            <!-- https://mvnrepository.com/artifact/io.protostuff/protostuff-core -->
        <dependency>
            <groupId>io.protostuff</groupId>
            <artifactId>protostuff-core</artifactId>
            <version>1.7.0</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/io.protostuff/protostuff-runtime -->
        <dependency>
            <groupId>io.protostuff</groupId>
            <artifactId>protostuff-runtime</artifactId>
            <version>1.7.0</version>
        </dependency>


        如果是用的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 <T>
     * @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;
    }

    /*
    <!-- https://mvnrepository.com/artifact/com.google.protobuf/protobuf-java -->
    <dependency>
        <groupId>com.google.protobuf</groupId>
        <artifactId>protobuf-java</artifactId>
        <version>3.11.4</version>
    </dependency>

     */

}

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,有没有问题？

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

序列化和反序列化

1、概念

2、translate

3、破坏translate

4、手写serialize框架

a、设计ISerializer接口

b、子类JavaSerializer

c、子类JavaXMLSerializer

d、子类FastJsonSerializer

e、子类XtreamSerializer

f、子类ProtostuffSerializer

5、序列化框架介绍

XML 序列化框架介绍

JSON 序列化框架

Hessian 序列化框架

Avro 序列化

kyro 序列化框架

Protobuf 序列化框架

继续阅读

关于Gradle配置的小结

Java小案例——随机数猜测随机数猜测

nginx location中斜线的位置的重要性

27 Best Free Eclipse Plug-ins for Java Developer to be ProductiveCode Quality PluginsText Editor PluginsDependency ManagementVersion Control Integration PluginsFramework Development Continuous Integration Related PluginsOther Utility Plugins

Java String.format方法的简单使用

neo4j之cypher使用文档

GitHub连夜封杀！这份阿里 10W 字内部 Java 字面试手册到底有多强？

spark/scala关于【资源文件】加载方法概述外部文件加载方案测试资源文件打包入jar包中小结

mybatis_入门程序Mybatis入门

AOP编程_Android优雅权限框架(1)概念基础，2021金三银四前言正文大纲正文

Effective Java 8:通用程序设计

OOM三种类型

工厂模式-三种类型

【递归】高效率求2的n次幂

win10本地scala和spark安装安装scala安装spark

scala (3) Function 和 Method