msgpack-java第一课

Myth丶恋晨 2022-06-18 12:14 262阅读 0赞

## msgpack-java ##

> It’s like JSON. but fast and small.

本文回答一下几个问题：  
\- 在Java中， msgpack如何实现打包，解包  
\- 在Java中，如何方便地实现对List, Map数据结构的序列化  
\- 在Java中，如果通讯双方类对象版本不统一，解包会有问题吗?

### 在Java中， msgpack如何实现打包，解包 ###

java中打包，解包相当的容易。  
引用msgpack包，包中有一个org.msgpack.annotation.Message的注解，带该注解的类即可实现打包和解包（序列化和反序列化）。

public class App 
    {
        public static void main( String[] args )
        {
            MessagePack packer = new MessagePack();
            A a = new A();
            a.setiVal(10);
            a.setsVal("Hello");
    
            try {
                byte[] adata = packer.write(a); // 打包（序列化）
                A a2 = packer.read(adata , A.class); // 解包（反序列化）
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    // 带注解的类
    @Message
    class A{
        private Integer iVal;
        private String sVal;
        public Integer getiVal() {
            return iVal;
        }
        public void setiVal(Integer iVal) {
            this.iVal = iVal;
        }
        public String getsVal() {
            return sVal;
        }
        public void setsVal(String sVal) {
            this.sVal = sVal;
        }
    }

### 在Java中，如何方便地实现对List, Map数据结构的序列化 ###

如果需要简单的原生对象的List对象，可以使用Templates下面的方法，不过最简单的方式是把List， Map对象做为属性添加到具有Message注解的类中。例如：

@Message
    class LA{
        private List<A> as;
    
        public List<A> getAs() {
            return as;
        }
    
        public void setAs(List<A> as) {
            this.as = as;
        }
    }

上面这个LA类就可以轻松实现List对象的序列化和反序列化，和普通类对象一样使用。

### 在Java中，如果通讯双方类对象版本不统一，解包会有问题吗? ###

这个问题，一般开始不会遇到。  
众所周知，像XML, JSON这样的结构化数据有一个非常大的优点就是结构的稳定性非常好，对结构的修改不会引起老版本的问题。他们结构化的数据都是基于标签访问的，而msgpack是基于数据的。如果如前面的方法实现序列化，那么序列化/反序列化是基于数据的位置进行的，如果后期数据变更，**很可能**，数据就会存在问题。  
经过测试，发现一下规律：  
1. 如果两个类变量的顺序相同，其中一个类增加了变量，多了变量的类序列化出来的数据可以放序列化到变量少的类，反之也是可以的，但必需要求所有变量都是包装类变量（是Integer, 不是int），不然就报错。  
2. 数组的数据不受此影响，数组元素必需适用规律1  
3. Map是类似于JSON的数据存储方式，兼容性好，相当于把变量名称进行传输。  
请看示例：

public class App 
    {
        public static void main( String[] args )
        {
            MessagePack packer = new MessagePack();
            A a = new A();
            a.setiVal(10);
            a.setsVal("Hello");
            B b = new B();
            b.setiVal(10);
            b.setsVal("Hello");
            b.setOk(true);
            C c = new C();
            c.setiVal(10);
            c.setsVal("Hello");
    
            LB lb = new LB();
            List<B> as = new ArrayList<B>();
            as.add(b);
            B b1 = new B();
            b1.setiVal(22);
            b1.setsVal("Hellox");
            b1.setOk(true);
            as.add(b1);
            lb.setAs(as);
    
            MA ma = new MA();
            HashMap<String, A> mamap = new HashMap<String, A>();
            mamap.put("A", a);
            mamap.put("B", a);
            ma.setMap(mamap);
    
            try {
                byte[] adata = packer.write(a);
                byte[] bdata = packer.write(b);
                byte[] cdata = packer.write(c);
                byte[] lbdata = packer.write(lb);
                byte[] madata = packer.write(ma);
                A a2 = packer.read(bdata, A.class); // 用类B的数据，反序列化A对象也是可以的
    // A a3 = packer.read(cdata, A.class); // ERROR, C的数据编码格式和A的前半部分不同
                LA la2 = packer.read(lbdata, LA.class); // 用类B 的List数据，可以反序列化LA的实例
                MA ma2 = packer.read(madata, MA.class); // Map的适用性好
                B b2 = packer.read(adata, B.class); // 如果变量都是类变量，A类的数据也可以放序列化
            } catch (IOException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
    
    @Message
    class A{
        private Integer iVal;;
        private String sVal;
        public Integer getiVal() {
            return iVal;
        }
        public void setiVal(Integer iVal) {
            this.iVal = iVal;
        }
        public String getsVal() {
            return sVal;
        }
        public void setsVal(String sVal) {
            this.sVal = sVal;
        }
    }
    
    @Message
    class LA{
        private List<A> as;
    
        public List<A> getAs() {
            return as;
        }
    
        public void setAs(List<A> as) {
            this.as = as;
        }
    }
    
    @Message
    class MA{
        private HashMap<String, A> map;
    
        public HashMap<String, A> getMap() {
            return map;
        }
    
        public void setMap(HashMap<String, A> map) {
            this.map = map;
        }
    }
    
    @Message
    class B{
        private Integer iVal;
        private String sVal;
        private Boolean isOk;
    
        public Integer getiVal() {
            return iVal;
        }
        public void setiVal(Integer iVal) {
            this.iVal = iVal;
        }
        public String getsVal() {
            return sVal;
        }
        public void setsVal(String sVal) {
            this.sVal = sVal;
        }
        public Boolean isOk() {
            return isOk;
        }
        public void setOk(Boolean isOk) {
            this.isOk = isOk;
        }
    }

**考虑兼容性，作为交互的数据类必需符合如下规则：**  
1. 类成员全部采用包装类  
2. 一定定义好类，不能删除，修改，前中部插入类成员，只允许扩容  
3. 对于数据变化较大的情况，考虑适用Map的方式更灵活。

在回答问题后，简要说明一下msgpack可以使用的场合。msgpack实现了多语言统一的序列化标准，从而可以实现在不同语言中实现结构化数据的交换。更为重要的是，msgpack有很多种语言的版本，这样跨语言的通讯就有了极大的优势。ActiveMQ通过JMS实现消息的序列化，JMS实质上也是一个标准话的数据结构。JSON也是标准话的结构，在JS王国中经常用到。阿里云的RocketMQ消息队列开源，并进入Apache孵化项目，它的消息内容是字节流，这意味着需要自己定义消息的格式。通过msgpack就可以方便的实现数据的交换。