目录

菠萝🍍的博客

有谁不喜欢吃菠萝呢

X

【机翻】msgpack java快速开始 0.6.x (已过时)

来源

msgpack java 0.6.x的快速入门(已淘汰)

  • 安装
  • 从Maven2存储库安装
  • 从git仓库安装
  • 如何使用
  • 制造一个 message-packable 类
  • 没有注释的序列化
  • Optional fields
  • Dynamic typing
  • 更多文件
  • API参考

本教程简要介绍了如何使用msgpack-java。我们将首先介绍msgpack-java的安装,然后说明如何将对象序列化/反序列化为msgpack对象

安装

您可以通过两种方式安装msgpack-java-使用Maven下载或构建jar。

从Maven2存储库安装

MessagePack for Java在Maven中央存储库上发布。您可以如下配置pom.xml来使用它:

<dependencies>
  ...
  <dependency>
    <groupId>org.msgpack</groupId>
    <artifactId>msgpack</artifactId>
    <version>${msgpack.version}</version>
  </dependency>
  ...
</dependencies>

更换${msgpack.version} 使用当前版本的MessagePack for Java, 你可以在the maven central repository.找到

从git仓库安装

您可以使用git获取最新的源代码。

$ git clone git@github.com:msgpack/msgpack-java.git
$ cd msgpack-java
$ mvn package

然后,您将在msgpack-java / target目录中获得msgpack jar文件。您还需要https://code.google.com/p/json-simple/和https://github.com/jboss-javassist/javassist才能使用。否则,您将收到NoClassDefFoundError。

如何使用

Make a message-packable class

注释 @Message 使您可以像这样在自己的类的对象中序列化“公共”字段。

import org.msgpack.MessagePack;
import org.msgpack.annotation.Message;
 
public class Main1 {
    @Message // Annotation
    public static class MyMessage {
        // public fields are serialized.
        public String name;
        public double version;
    }
 
    public static void main(String[] args) throws Exception {
        MyMessage src = new MyMessage();
        src.name = "msgpack";
        src.version = 0.6;
 
        MessagePack msgpack = new MessagePack();
        // Serialize
        byte[] bytes = msgpack.write(src);
        // Deserialize
        MyMessage dst = msgpack.read(bytes, MyMessage.class);
    }
}

如果要顺序序列化多个对象, 您可以使用 Packer and Unpacker 对象. 这是因为MessagePack.write(Object)read(byte[]) 方法每次 调用 创建了 PackerUnpacker 对象.使用 PackerUnpacker 对象, 调用createPacker(OutputStream)createUnpacker(InputStream).

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
 
import org.msgpack.MessagePack;
import org.msgpack.annotation.Message;
import org.msgpack.packer.Packer;
import org.msgpack.unpacker.Unpacker;
 
public class Main2 {
    @Message
    public static class MyMessage {
        public String name;
        public double version;
    }
 
    public static void main(String[] args) throws Exception {
        MyMessage src1 = new MyMessage();
        src1.name = "msgpack";
        src1.version = 0.6;
        MyMessage src2 = new MyMessage();
        src2.name = "muga";
        src2.version = 10.0;
        MyMessage src3 = new MyMessage();
        src3.name = "frsyukik";
        src3.version = 1.0;
 
        MessagePack msgpack = new MessagePack();
        //
        // Serialize
        //
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        Packer packer = msgpack.createPacker(out);
        packer.write(src1);
        packer.write(src2);
        packer.write(src3);
        byte[] bytes = out.toByteArray();
 
        //
        // Deserialize
        //
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        Unpacker unpacker = msgpack.createUnpacker(in);
        MyMessage dst1 = unpacker.read(MyMessage.class);
        MyMessage dst2 = unpacker.read(MyMessage.class);
        MyMessage dst3 = unpacker.read(MyMessage.class);
    }
}

Various types of values serialization/deserialization

The classes Packer/Unpacker 允许序列化/反序列化各种类型的值,如下所示。它们支持序列化/反序列化各种类型的值,例如原始类型的值,原始包装器类的值, String objects, byte[] objects, ByteBuffer对象等。如上所述,它们还允许序列化/反序列化您自己的类的对象,这些对象由注释 @Message.

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.math.BigInteger;
import java.nio.ByteBuffer;
 
import org.msgpack.MessagePack;
import org.msgpack.packer.Packer;
import org.msgpack.unpacker.Unpacker;
 
public class Main3 {
    public static void main(String[] args) throws Exception {
        MessagePack msgpack = new MessagePack();
 
        //
        // 序列化
        //
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        Packer packer = msgpack.createPacker(out);
 
        // 序列化基本类型的值
        packer.write(true); // boolean value
        packer.write(10); // int value
        packer.write(10.5); // double value
 
        // 序列化原始包装器类型的对象
        packer.write(Boolean.TRUE);
        packer.write(new Integer(10));
        packer.write(new Double(10.5));
 
        // 序列化各种类型的数组
        packer.write(new int[] { 1, 2, 3, 4 });
        packer.write(new Double[] { 10.5, 20.5 });
        packer.write(new String[] { "msg", "pack", "for", "java" });
        packer.write(new byte[] { 0x30, 0x31, 0x32 }); // byte array
 
        // 序列化各种其他参考值
        packer.write("MessagePack"); // String object
        packer.write(ByteBuffer.wrap(new byte[] { 0x30, 0x31, 0x32 })); // ByteBuffer object
        packer.write(BigInteger.ONE); // BigInteger object
 
        //
        // 反序列化
        //
        byte[] bytes = out.toByteArray();
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        Unpacker unpacker = msgpack.createUnpacker(in);
 
        // 原始值
        boolean b = unpacker.readBoolean(); // boolean value
        int i = unpacker.readInt(); // int value
        double d = unpacker.readDouble(); // double value
 
        // 原始包装值
        Boolean wb = unpacker.read(Boolean.class);
        Integer wi = unpacker.read(Integer.class);
        Double wd = unpacker.read(Double.class);
 
        //到数组
        int[] ia = unpacker.read(int[].class);
        Double[] da = unpacker.read(Double[].class);
        String[] sa = unpacker.read(String[].class);
        byte[] ba = unpacker.read(byte[].class);
 
        // to字符串对象,ByteBuffer对象,BigInteger对象,List对象和Map对象
        String ws = unpacker.read(String.class);
        ByteBuffer buf = unpacker.read(ByteBuffer.class);
        BigInteger bi = unpacker.read(BigInteger.class);
    }
}

方法 Packer#write() 允许序列化各种类型的数据。

这个类Unpacker 提供了将二进制反序列化为原始值的反序列化方法。例如,如果您想将二进制反序列化为boolean(或int)类型的值,则可以在其中使用readBoolean(或readInt)方法解包器Unpacker还提供了参考值的读取方法。它的方法允许将二进制反序列化为您指定为参数类型的引用的值。例如,如果您想将二进制反序列化为“ String”(或“ byte []”)对象,则必须描述对“ read(String.class)”的调用。(或read(byte []。class))方法。

List, Map 对象序列化/反序列化

序列化通用容器对象,如ListMap 对象, 您可以使用Template. Template对象是成对的序列化器和反序列化器.例如,序列化一个 List具有 Integer对象作为元素,您可以通过以下方式创建Template对象。

Template listTmpl = Templates.tList(Templates.TInteger);

The classes tList, TInteger 是静态方法和字段Templates.一个简单的例子 List and Map对象如下所示。

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.util.*;
 
import org.msgpack.MessagePack;
import org.msgpack.packer.Packer;
import org.msgpack.template.Template;
import org.msgpack.unpacker.Unpacker;
import static org.msgpack.template.Templates.tList;
import static org.msgpack.template.Templates.tMap;
import static org.msgpack.template.Templates.TString;
 
public class Main4 {
    public static void main(String[] args) throws Exception {
        MessagePack msgpack = new MessagePack();
 
        //创建用于序列化/反序列化List和Map对象的templates
        Template<List<String>> listTmpl = tList(TString);
        Template<Map<String, String>> mapTmpl = tMap(TString, TString);
 
        //
        //序列化
        //
 
        ByteArrayOutputStream out = new ByteArrayOutputStream();
        Packer packer = msgpack.createPacker(out);
 
        // 序列化列表对象
        List<String> list = new ArrayList<String>();
        list.add("msgpack");
        list.add("for");
        list.add("java");
        packer.write(list); // List object
 
        //序列化Map对象
        Map<String, String> map = new HashMap<String, String>();
        map.put("sadayuki", "furuhashi");
        map.put("muga", "nishizawa");
        packer.write(map); // Map object
 
        //
        //反序列化
        //
 
        byte[] bytes = out.toByteArray();
        ByteArrayInputStream in = new ByteArrayInputStream(bytes);
        Unpacker unpacker = msgpack.createUnpacker(in);
 
        // to List object
        List<String> dstList = unpacker.read(listTmpl);
 
        // to Map object
        Map<String, String> dstMap = unpacker.read(mapTmpl);
    }
}

没有注释的序列化

If you cannot append @Message to classes representing objects that you want to serialize, register method enables you to serialize the objects of the classes.

MessagePack msgpack = new MessagePack();
msgpack.register(MyMessage2.class);

例如,如果外部库中包含MyMessage2类,您无法轻松地修改类声明并追加 @Message to it. register方法允许为MyMessage2类自动生成一对序列化器和反序列化器。 执行该方法后,可以序列化MyMessage2类的对象。

###选填栏位

您可以添加新字段以保持兼容性。Use the @Optional in the new fields.

@Message
public static class MyMessage {
    public String name;
    public double version;
 
    // new field
    @Optional
    public int flag = 0;
}

如果您尝试反序列化旧版本数据,可选字段将被忽略。

Dynamic typing

由于Java是一种静态类型语言, MessagePack通过以下方式实现了动态键入Value. Value 具有检查其自身类型的方法(isIntegerType(), isArrayType(), etc ...) 并转换成自己的类型(asStringValue(), convert(Template)).

import java.util.*;
 
import org.msgpack.MessagePack;
import org.msgpack.type.Value;
import org.msgpack.unpacker.Converter;
 
import static org.msgpack.template.Templates.*;
 
public class Main5 {
    public static void main(String[] args) throws Exception {
        // Create serialize objects.
        List<String> src = new ArrayList<String>();
        src.add("msgpack");
        src.add("kumofs");
        src.add("viver");
 
        MessagePack msgpack = new MessagePack();
        // Serialize
        byte[] raw = msgpack.write(src);
 
        // Deserialize directly using a template
        List<String> dst1 = msgpack.read(raw, tList(TString));
 
        // Or, Deserialze to Value then convert type.
        Value dynamic = msgpack.read(raw);
        List<String> dst2 = new Converter(dynamic).read(tList(TString));
    }
}

更多文件

API参考


标题:【机翻】msgpack java快速开始 0.6.x (已过时)
作者:MingGH
地址:https://runnable.run/articles/2020/03/09/1583724879217.html