MessagePackプローブ

MessagePackプローブ
MessagePack is an efficient binary serialization format.
MessagePackバージョン-0.6.11
例1:Javaオブジェクトをシーケンス化する

@Message // Annotation
public static class MyMessage {
    // public fields are serialized.
    public String name;
    public double version;
}


@Test
public void test977() throws IOException {
    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);
    System.out.println(dst.name);
    System.out.println(dst.version);
}

ここではMessagePackクラスを使用していますが、シーケンス化されたクラスは注記@Messageを使用することに注意してください
インスタンス2:複数のJavaオブジェクトをシーケンス化する

@Message // Annotation
public static class MyMessage {
    // public fields are serialized.
    public String name;
    public double version;
}


@Test
public void test8666() throws IOException {
    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);

    // print dst1
    System.out.println(dst1.name);
    System.out.println(dst1.version);

    // print dst2
    System.out.println(dst2.name);
    System.out.println(dst2.version);

    // print dst2
    System.out.println(dst3.name);
    System.out.println(dst3.version);
}

PackerとUnpackerを使用して複数のJavaオブジェクトをシーケンス化
例3:基本タイプと基本タイプのパッケージタイプを含む複数のデータ型のシーケンス化と逆シーケンス化

@Test
public void test444() throws IOException {
    MessagePack msgpack = new MessagePack();

    //
    // Serialization
    //
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    Packer packer = msgpack.createPacker(out);

    // Serialize values of primitive types
    packer.write(true); // boolean value
    packer.write(10); // int value
    packer.write(10.5); // double value

    // Serialize objects of primitive wrapper types
    packer.write(Boolean.TRUE);
    packer.write(new Integer(10));
    packer.write(new Double(10.5));

    // Serialize various types of arrays
    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

    // Serialize various types of other reference values
    packer.write("MesagePack"); // String object
    packer.write(ByteBuffer.wrap(new byte[]{0x30, 0x31, 0x32})); // ByteBuffer object
    packer.write(BigInteger.ONE); // BigInteger object

    //
    // Deserialization
    //
    byte[] bytes = out.toByteArray();
    ByteArrayInputStream in = new ByteArrayInputStream(bytes);
    Unpacker unpacker = msgpack.createUnpacker(in);

    // to primitive values
    boolean b = unpacker.readBoolean(); // boolean value
    System.out.println(b);
    int i = unpacker.readInt(); // int value
    System.out.println(i);
    double d = unpacker.readDouble(); // double value
    System.out.println(d);


    // to primitive wrapper value
    Boolean wb = unpacker.read(Boolean.class);
    System.out.println(wb);
    Integer wi = unpacker.read(Integer.class);
    System.out.println(wi);
    Double wd = unpacker.read(Double.class);

    System.out.println(wd);
    // to arrays
    int[] ia = unpacker.read(int[].class);
    System.out.println(ia);
    Double[] da = unpacker.read(Double[].class);
    System.out.println(da);
    String[] sa = unpacker.read(String[].class);
    System.out.println(sa);
    byte[] ba = unpacker.read(byte[].class);

    System.out.println(ba);
    // to String object, ByteBuffer object, BigInteger object, List object and Map object
    String ws = unpacker.read(String.class);
    System.out.println(ws);
    ByteBuffer buf = unpacker.read(ByteBuffer.class);
    BigInteger bi = unpacker.read(BigInteger.class);
    System.out.println(bi);
}

例4:ListとMapタイプのシーケンス化と逆シーケンス化

@Test
public void test8655() throws IOException {
    MessagePack msgpack = new MessagePack();

    // Create templates for serializing/deserializing List and Map objects
    Template<List<String>> listTmpl = Templates.tList(Templates.TString);
    Template<Map<String, String>> mapTmpl = Templates.tMap(Templates.TString, Templates.TString);

    //
    // Serialization
    //
    ByteArrayOutputStream out = new ByteArrayOutputStream();
    Packer packer = msgpack.createPacker(out);

    // Serialize List object
    List<String> list = new ArrayList<String>();
    list.add("msgpack");
    list.add("for");
    list.add("java");
    packer.write(list); // List object

    // Serialize Map object
    Map<String, String> map = new HashMap<String, String>();
    map.put("sadayuki", "furuhashi");
    map.put("muga", "nishizawa");
    packer.write(map); // Map object

    //
    // Deserialization
    //
    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);
}

例5:注釈@Messageを使用しないシーケンス化オブジェクト

public static class MyMessage3 {
    public String name;
    public double version;
}

@Test
public void test86666() throws IOException {

    MyMessage3 src = new MyMessage3();
    src.name = "msgpack";
    src.version = 0.6;

    MessagePack msgpack = new MessagePack();
    msgpack.register(MyMessage3.class);    // @Message

    byte[] bytes = msgpack.write(src);

    MyMessage3 dest = msgpack.read(bytes, MyMessage3.class);
    System.out.println(dest.name);
    System.out.println(dest.version);

}

例6:@Optional注記を使用して新しく追加したフィールドを注釈する

@Message // Annotation
public static class MyMessage {
    // public fields are serialized.
    public String name;
    public double version;
}

@Message
public static class MyMessage2 {
    public String name;
    public double version;

    // new field
    @Optional
    public int flag = 0;
}

@Test
public void test90890() throws IOException {
    MyMessage2 src = new MyMessage2();
    src.name = "msgpack";
    src.version = 0.6;
    src.flag = 1;


    MessagePack msgpack = new MessagePack();
    // Serialize
    byte[] bytes = msgpack.write(src);


    // ， optional 
    MyMessage dst = msgpack.read(bytes, MyMessage.class);
    System.out.println(dst.name);
    System.out.println(dst.version);
}

例7:動的にシーケンス化されたタイプを決定する
主にクラスライブラリを使用して提供されるValueオブジェクト

@Test
public void test765f4f() throws IOException {
    // 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, Templates.tList(Templates.TString));

    // Or, Deserialze to Value then convert type.
    Value dynamic = msgpack.read(raw);
    System.out.println(dynamic.isArrayValue());
    List<String> dst2 = new Converter(dynamic).read(Templates.tList(Templates.TString));
}

ここでは、シーケンス化タイプを動的に決定する方法について疑問があります.??

List<String> dst2 = new Converter(dynamic).read(Templates.tList(Templates.TString));

この行のコードに名前を付けたのか、シーケンス化タイプを指定したのか、どのように動的に決定されたのか.??
実はアプリケーションでconvertオブジェクトを渡し、具体的な処理方法で対応するタイプにシーケンス化するのを見ています.(具体的な方法では、シーケンス化するタイプを決定できます)

@Test
public void test765f4f() throws IOException {
    // 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, Templates.tList(Templates.TString));

    // Or, Deserialze to Value then convert type.
    Value dynamic = msgpack.read(raw);
    System.out.println(dynamic.isArrayValue());
    Converter converter = new Converter(dynamic);
    List<String> dst2 = converter.read(Templates.tList(Templates.TString));
}

 
====END====