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

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

package com.insight.demo.msgpack;

import org.junit.Test;
import org.msgpack.MessagePack;
import org.msgpack.annotation.Message;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.UUID;

import static org.junit.Assert.assertEquals;

/**
 * MessagePack6Objects
 *
 * @author yhu
 */
public class MessagePack6Object {
    final Logger logger = LoggerFactory.getLogger(MessagePack6Object.class);

    /**
     * MessageData Message Object
     */
    @Message // Annotation
    public static class MessageData {
        // public fields are serialized.
        public String uuid;
        public String name;
        public double version;
    }


    /**
     * Test MessagePack6Objects
     */
    @Test
    public void testMessagePack6Objects() {
        logger.debug("MessagePack6Objects for Objects");

        String uuid = UUID.randomUUID().toString();

        // INIT OBJ
        MessageData src = new MessageData();
        src.uuid = uuid;
        src.name = "MessagePack6";
        src.version = 0.6;

        try {
            MessagePack msgPack = new MessagePack();

            // Serialization
            logger.debug("------ Serialization ------");
            byte[] bytes = msgPack.write(src);
            logger.debug("Bytes Array Length: [{}]", bytes.length);

            // Deserialization
            logger.debug("------ Deserialization ------");
            MessageData dst = msgPack.read(bytes, MessageData.class);
            logger.debug("Check Object for UUID: [{}]", dst.uuid);

            assertEquals(uuid, dst.uuid);

        } catch (Exception ex) {
            logger.error("MessagePack Serialization And Deserialization error", ex);
        }
    }
}

package com.insight.demo.msgpack;

import org.junit.Test;
import org.msgpack.MessagePack;
import org.msgpack.packer.Packer;
import org.msgpack.unpacker.Unpacker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.math.BigInteger;
import java.nio.ByteBuffer;

/**
 * MessagePack6Types
 *
 * @author yhu
 */
public class MessagePack6Types {
    final Logger logger = LoggerFactory.getLogger(MessagePack6Types.class);


    /**
     * Test MessagePack6Types
     */
    @Test
    public void testMessagePack6Types() {
        logger.debug("testMessagePack6Types for Types");

        MessagePack msgpack = new MessagePack();
        try {

            //
            // 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()_' **позволяет сериализовать данные различных типов**.

Класс `_Unpacker_' предназначен для десериализации двоичных данных в основные переменные и предоставляет метод десериализации. Например, если вы хотите десериализовать двоичные данные в переменную типа `_boolean_' (или `_int_'), вы можете использовать методы `_readBoolean_' (или '_readInt_') класса `_Unpacker_'.

`_Unpacker_' также предоставляет метод чтения для ссылочных переменных. Этот метод позволяет десериализовывать данные из двоичного формата в ссылочную переменную. При вызове метода необходимо указать тип переменной в качестве параметра.

Например, если вы хотите десериализовать двоичные данные в объект типа `_String_' (или массив типа `_byte[]_'), вам нужно определить это при вызове методов `_read(String.class)' (или '_read(byte[].class)_').

## Сериализация и десериализация объектов List и Map
Для сериализации нативных контейнерных объектов, таких как `_List_' и `_Map_' объекты, необходимо использовать класс `_Template_'.**

Объект `_Template_' является парой сериализатора и десериализатора. Например, чтобы сериализовать объект `_List_' с элементами типа `_Integer_' можно использовать следующий код для создания объекта шаблона:

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

package com.insight.demo.msgpack;

import org.junit.Test;
import org.msgpack.MessagePack;
import org.msgpack.packer.Packer;
import org.msgpack.template.Template;
import org.msgpack.unpacker.Unpacker;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.math.BigInteger;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static org.msgpack.template.Templates.*;

/**
 * MessagePack6Template
 *
 * @author yhu
 */
public class MessagePack6Template {
    final Logger logger = LoggerFactory.getLogger(MessagePack6Template.class);


    /**
     * Test MessagePack6Template
     */
    @Test
    public void testMessagePack6Template() {
        logger.debug("MessagePack6Template for Template");

        MessagePack msgpack = new MessagePack();
        try {

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

            //

``` **Сериализация**

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

// Сериализуем объект List
List<String> list = new ArrayList<String>();
list.add("msgpack");
list.add("for");
list.add("java");
packer.write(list); // Объект List

// Сериализуем объект Map
Map<String, String> map = new HashMap<String, String>();
map.put("sadayuki", "furuhashi");
map.put("muga", "nishizawa");
packer.write(map); // Объект Map

**Десериализация**

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

// В объект List
List<String> dstList = unpacker.read(listTmpl);

// В объект Map
Map<String, String> dstMap = unpacker.read(mapTmpl);

} catch (Exception ex) {
    logger.error("MessagePack Serialization And Deserialization error", ex);
}
}

*### Без использования аннотаций для сериализации*

Если вы не можете добавить @Message к своим определяемым объектам, но всё равно хотите сериализовать их, вы можете использовать метод register для включения сериализации объектов в классе.

Например, если класс MyMessage2 содержится во внешней библиотеке, и у вас нет возможности легко редактировать исходный код и добавлять '_@Message_' в исходный код.

Метод register позволяет автоматически создать пару serializer и deserializer для MyMessage2. Вы можете сериализовать объекты MyMessage2 после выполнения.

*### Необязательные поля*

Вы можете добавить новое поле для сохранения совместимости. Используйте аннотацию '_@Optional_' в новом поле.

```java
@Message
public static class MyMessage {
  public String name;
  public double version;

  // Новое поле
  @Optional
  public int flag = 0;
}

package com.insight.demo.msgpack;

import org.junit.Test;
import org.msgpack.MessagePack;
import org.msgpack.type.Value;
import org.msgpack.unpacker.Converter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.ArrayList;
import java.util.List;

import static org.msgpack.template.Templates.TString;
import static org.msgpack.template.Templates.tList;

/**
 * MessagePack6Objects
 *
 * @author yhu
 */
public class MessagePack6DynamicTyping {
  final Logger logger = LoggerFactory.getLogger(MessagePack6DynamicTyping.class);


  /**
   * Test MessagePack6Objects
   */
  @Test
  public void MessagePack6DynamicTyping() {
    logger.debug("MessagePack6Objects for Objects");

    // Create serialize objects.
    List<String> src = new ArrayList<String>();
    src.add("msgpack");
    src.add("kumofs");
    src.add("viver");

    MessagePack msgpack = new MessagePack();

    try {

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

    } catch (Exception ex) {
      logger.error("MessagePack Serialization And Deserialization error", ex);
    }
  }
}