https://shift-alt-ctrl.iteye.com/blog/2217425

    我们已经接触过很多序列化框架（或者集成系统），比如protobuf、hessian、thrift等，它们各有优缺点以及各自的实用场景，Avro也是一个序列化框架，它的设计思想、编程模式都和thirft非常相似，也都是Apache的顶级项目。Avro还提供了RPC机制，可以不需要生成额外的API代码即可使用Avro来存储数据和RPC交互，“代码生成”是可选的，这一点区别于protobuf和thrift。此外Hadoop平台上的多个项目正在使用（或者支持）Avro作为数据序列化的服务。

    Avro尽管提供了RPC机制，事实上Avro的核心特性决定了它通常用在“大数据”存储场景（Mapreduce），即我们通过借助schema将数据写入到“本地文件”或者HDFS中，然后reader再根据schema去迭代获取数据条目。它的schema可以有限度的变更、调整，而且Avro能够巧妙的兼容，这种强大的可扩展性正是“文件数据”存储所必须的。

    Avro是基于schema（模式），这和protobuf、thrift没什么区别，在schema文件中（.avsc文件）中声明数据类型或者protocol（RPC接口），那么avro在read、write时将依据schema对数据进行序列化。因为有了schema，那么Avro的读、写操作将可以使用不同的平台语言。Avro的schema是JSON格式，所以编写起来也非常简单、可读性很好。目前Avro所能支持的平台语言并不是很多，其中包括JAVA、C++、Python。

    当Avro将数据写入文件时，将会把schema连同实际数据一同存储，此后reader将可以根据这个schema处理数据，如果reader使用了不同的schema，那么Avro也提供了一些兼容机制来解决这个问题。

    在RPC中使用Avro，Client和server端将会在传输数据之前，首先通过handshake交换Schema，并在Schema一致性上达成统一。

一、Java与Avro实例

    接下来我们简单描述一下如何如果在Java平台上对Avro进行序列化、反序列化。我们以如下schema为例子(user.avsc)：Java代码  

{"namespace": "com.test.avro",  
 "type": "record",  
 "name": "User",  
 "fields": [  
     {"name": "name", "type": "string"},  
     {"name": "age",  "type": ["int", "null"]},  
     {"name": "email", "type": ["string", "null"]}  
 ]  
}  

    上述schema表示User类有三个field：“name”、“age”、“email”；“type”用来声明field的数据类型，比如“email”的type为“[“string”,”null”]”，则表示类型可以为“string”或者为null。稍后我们会详细介绍。

    首先我们需要在pom.xml文件中增加如下配置：Java代码  

<dependency>  
    <groupId>org.apache.avro</groupId>  
    <artifactId>avro</artifactId>  
    <version>1.7.7</version>  
</dependency>  
  
<dependency>  
    <groupId>org.apache.avro</groupId>  
    <artifactId>avro-tools</artifactId>  
    <version>1.7.7</version>  
</dependency>  

   avro和avro-tools两个依赖包，是avro开发的必备的基础包。如果你的项目需要让maven来根据.avsc文件生成java代码的话，还需要增加如下avro-maven-plugin依赖，否则此处是不需要的。Java代码  

<plugin>  
    <groupId>org.apache.avro</groupId>  
    <artifactId>avro-maven-plugin</artifactId>  
    <version>1.7.7</version>  
    <executions>  
        <execution>  
            <phase>generate-sources</phase>  
            <goals>  
                <goal>schema</goal>  
            </goals>  
            <configuration>  
                <sourceDirectory>${project.basedir}/src/main/resources/avro/</sourceDirectory>  
                <outputDirectory>${project.basedir}/src/main/java/</outputDirectory>  
            </configuration>  
        </execution>  
    </executions>  
</plugin>  
<plugin>  
    <groupId>org.apache.maven.plugins</groupId>  
    <artifactId>maven-compiler-plugin</artifactId>  
    <configuration>  
        <encoding>utf-8</encoding>  
    </configuration>  
</plugin>  

    1、基于“代码生成”

    这种方式是比较常见的，即根据Avro schema生成JAVA代码，然后根据JAVA API来进行数据操作。如果你在pom.xml配置了avro-maven-plugin插件，那么只需要只需要执行：Java代码  

maven compile  

    此后插件将会根据user.avsc文件在project指定的package目录下生成java代码。此外如果你的项目不是基于maven的，或者你不希望maven来做这件事，也可以使用如下命令生成java代码，此后只需要将代码copy到项目中即可：Java代码  java -jar /path/to/avro-tools1.7.7.jar compile schema <schema file> <code destination> 

java -jar /path/to/avro-tools-1.7.7.jar compile schema <schema file> <code destination>  
  
//例如  
java -jar avro-tools-1.7.7.jar compile schema user.avsc ./  

java -jar avro-tools-1.7.7.jar compile schema user.avsc ./  

    序列化、发序列化Java代码样例Java代码  

User.Builder builder = User.newBuilder();  
builder.setName("张三");  
builder.setAge(30);  
builder.setEmail("zhangsan@*.com");  
User user = builder.build();  
  
//序列化  
File diskFile = new File("/data/users.avro");  
DatumWriter<User> userDatumWriter = new SpecificDatumWriter<User>(User.class);  
DataFileWriter<User> dataFileWriter = new DataFileWriter<User>(userDatumWriter);  
//指定schema  
dataFileWriter.create(User.getClassSchema(), diskFile);  
dataFileWriter.append(user);  
dataFileWriter.fSync();//多次写入之后，可以调用fsync将数据同步写入磁盘(IO)通道  
user.setName("李四");  
user.setEmail("lisi@*.com");  
dataFileWriter.append(user);  
dataFileWriter.close();  
  
//反序列化  
DatumReader<User> userDatumReader = new SpecificDatumReader<User>(User.class);  
// 也可以使用DataFileStream  
// DataFileStream<User> dataFileStream = new DataFileStream<User>(new FileInputStream(diskFile),userDatumReader);  
DataFileReader<User> dataFileReader = new DataFileReader<User>(diskFile, userDatumReader);  
User _current = null;  
while (dataFileReader.hasNext()) {  
  
    //注意:avro为了提升性能，_current对象只会被创建一次，且每次遍历都会重用此对象  
    //next方法只是给_current对象的各个属性赋值，而不是重新new。  
    _current = dataFileReader.next(_current);  
    //toString方法被重写，将获得JSON格式  
    System.out.println(_current);  
}  
dataFileReader.close();  

    代码很简单，描述了将User通过avro schema写入文件，我们可以通过二进制文本编辑器查看这个结果文件，会发现文件的开头部分是schema，后续是逐个user序列化的二进制结果。我们在稍后介绍encoding format，你会知道文件的数据结构。

    在reader迭代读取数据时，“_current”对象不能在while循环之外的其他地方使用，这样是不安全的。

    原理：代码生成时，User的Schema信息已经作为一个静态常量写入了User.java中，同时根据schema中fields的列表严格顺序，显式的生成Fields数组，数组的index为schema中filed的声明的位置，比如name字段为0，age为1，email为2。这个严格有序性，保证了writer按照field的顺序依次编码，同时reader也按照此顺序依次解码；这也意味着开发工程者不能随意更改filed在Schema中的顺序，这个特性和protobuf、thrift都一样。

    在writer写入实际数据之前，首先把schema作为header写入文件，这个header将作为Avro数据文件的合法性校验提供帮助，如果reader和writer使用的schema无法兼容（通过此Header校验），将导致数据文件无法读取；当user对象被写入文件时，将会依次遍历user的每个filed，并根据filed的数据类型对值进行encoder，然后将bytes写入通道，编码由BinaryEncoder来实现，具体format稍后详解。

    在创建reader时会指定Schema，这个Schema称为“expected”，那么writer写入文件中还有一个Schema，这个称为“actual”，那么在reader读取数据时，究竟哪个生效呢？如果“expected”没有指定，那么将使用“actual”，否则最终的Schema将会是这两个Schema互相兼容的结果：Avro约定，Filed顺序不能更改，即相应的index上Filed的Type必须兼容（一致，或者兼容，比如long兼容int），如果对应index上的Filed名称不同，那么它们应该可以通过“别名”（aliase）互相兼容，即filed的name可以不一样，但是允许使用aliase来声明它的曾用名。

    那么在迭代时（next方法）也需要传递一个“_current”对象，如果_current与“expected”的Schema不一样（==）,即它们的Class类型不同，如果_current为”expected”的父类，则使用_current类型，否则尝试根据其实际的class类型与expected，通过反射机制的方式构建一个实例。next方法的迭代过程，将根据上述“兼容”后的Schema，使用BinaryDecoder逐个解析Filed。

    由此可见，保持Avro Schema的设计严谨性是非常重要的，这可以避免解析过程带来的困惑。如果Schema有了巨大的变化，我们通常将数据写入新的文件，并更新解析器的API。（而不是将它们混淆在一起）

    2、非“代码生成”情况：无需通过Schema生成java代码，开发者需要在运行时指定Schema。Java代码  

//user.avsc放置在“resources/avro”目录下  
InputStream inputStream = ClassLoader.getSystemResourceAsStream("avro/user.avsc");  
Schema schema = new Schema.Parser().parse(inputStream);  
  
GenericRecord user = new GenericData.Record(schema);  
user.put("name", "张三");  
user.put("age", 30);  
user.put("email","zhangsan@*.com");  
  
File diskFile = new File("/data/users.avro");  
DatumWriter<GenericRecord> datumWriter = new GenericDatumWriter<GenericRecord>(schema);  
DataFileWriter<GenericRecord> dataFileWriter = new DataFileWriter<GenericRecord>(datumWriter);  
dataFileWriter.create(schema, diskFile);  
dataFileWriter.append(user);  
dataFileWriter.close();  
  
DatumReader<GenericRecord> datumReader = new GenericDatumReader<GenericRecord>(schema);  
DataFileReader<GenericRecord> dataFileReader = new DataFileReader<GenericRecord>(diskFile, datumReader);  
GenericRecord _current = null;  
while (dataFileReader.hasNext()) {  
    _current = dataFileReader.next(_current);  
    System.out.println(user);  
}  
  
dataFileReader.close();  

    这种情况下，没有生成JAVA API，那么序列化过程就需要开发者预先熟悉Schema的结构，创建User的过程就像构建JSON字符串一样，通过put操作来“赋值”。反序列化也是一样，需要指定schema。

    GenericRecord接口提供了根据“field”名称获取值的方法：Object get(String fieldName)；不过需要声明，这内部实现并不是基于map，而是一个数组，数组和Schema声明的Fileds按照index对应。put操作根据field名称找到对应的index，然后赋值；get反之。那么在对待Schema兼容性上和“代码生成”基本一致。

    3、其他：将Avro信息序列化到文件，这是我们在大数据存储和“数据迁移”、“分析”时常用的手段，有可能数据文件是多次append的结果（但不可能是多个线程同时append），那么开发者需要注意这一点，那么每次append时，我们需要首先seek到文件的尾部。Avro提供了内部的SeekableInput类，可以封装File。（其实最常用的办法是，每次都新建数据文件）Java代码  

File diskFile = new File("/data/users.avro");  
long length = diskFile.length();  
DatumWriter<User> userDatumWriter = new SpecificDatumWriter<User>(User.class);  
DataFileWriter<User> dataFileWriter = new DataFileWriter<User>(userDatumWriter);  
if(length == 0) {  
    dataFileWriter.create(user.getSchema(), diskFile);//如果是新文件，则插入Schema  
}else {  
    dataFileWriter.appendTo(diskFile);//对于现有文件，则直接追加到文件的尾部  
}  
//....  

二、Avro数据结构

     通过上述实例，我们已经知道了Avro Schema格式是JSON，所以编写起来非常简单，只需要了解Avro的规范即可，接下来简单介绍一些Avro的数据结构。

    Primitive Types（原生类型） ：“null”，“boolean”，“int”，“long”，“float”，“double”，“bytes”，“string”；这些数据类型和JAVA基本没有太大区别。

     复合类型：包括6种“record”，“enum”，“array”，“map”，“union”，“fixed”。

    1、record：这个和java中的“class”有同等的意义，它支持如下属性：

        1）name：必要属性，表示record的名称，在java生成代码时作为类的名称。

        2）namespace：限定名，在java生成代码时作为package的名字。其中namespace + name最终构成record的全名。

        3）doc：可选，文档信息，备注信息。

        4）aliases：别名

        5）fields：field列表，严格有序。每个filed又包括“name”、“doc”、“type”、“default”、“order”、“aliases”几个属性。

    其中在fields列表中每个filed应该拥有不重复的name，“type”表示field的数据类型。

    “default”很明显，用来表示field的默认值，当reader读取时，当没有此field时将会采用默认值；“order”：可选值，排序（ascending、descending、ignore），在Mapreduce集成时有用。

    “aliases”别名，JSON Array，表示此field的别名列表。Java代码  

{  
  "type": "record",   
  "name": "User",  
  "namespace":"com.test.avro",  
  "aliases": ["User1","User2"],                        
  "fields" : [  
    {"name": "age", "type": "int","default":10},               
    {"name": "email", "type": ["null", "string"]}  
  ]  
}  

    2、enum：枚举类型。Java代码  

{ "type": "enum",  
  "name": "Suit",  
  "symbols" : ["SPADES", "HEARTS", "DIAMONDS", "CLUBS"]  
}  

    “symbols”属性即位enum的常量值列表。值不能重复。

    3、array：数组，和java中的数组没有区别。其item属性表示数组的item的类型。Java代码  

1. {“type”:”array”,”items”:”string”}  

    4、map：跟java中的map一样，只是key必须为string（无法声明key的类型），“values”属性声明value的类型。Java代码  

1. {“type”:”map”,”values”:”long”}  

    5、union：集合，数学意义上的“集合”，集合中的数据不能重复。如果对“type”使用union类型，那么其default值必须和union的第一个类型匹配。Java代码  

1. {“type”:[“int”,”null”],”default”:10}  

    6、fixed：表示field的值的长度为“固定值”，“size”属性表示值的字节长度。Java代码  

1. {“type”:”fixed”,”size”:16,”name”:”md5″}  

    record、enum、fixed、field属性，都可以声明aliases，别名–曾用名，这在schema兼容机制中非常重要。对于reader而言可以使用aliases来映射writer的schema，就像模式演变一样来处理不同的数据集。比如writer schema中有个filed命名为“Foo”，reader schema中有个filed为“Bar”并且有个别名为“Foo”,那么在reader处理数据时Bar将可以与数据中“Foo”映射并正常处理。如果schema中有多个Field重名，那么可以借助“namespace”来组合成全限定名（full namespace-qualified）。

三、编码

    Avro实现了两种encoding：BinaryEncoder、JsonEncoder（有兴趣可以看看其java实现），对于数据存储或者RPC通常使用BinaryEncoder，这意味着数据尺寸小而且处理更加快速；不过对于debugging或者基于web的应用，JsonEncoding通常比较便捷（即数据格式采用JSON，借助jackson）。

    Binary Encoding：

    对于primitive类型，binary编码规则如下：“null”值将会写入0字节，“boolean”写入一个单独的字节表示0或者1；“int”和“long”采用“varint”编码技巧；“float”为4个字节，“double”为8个字节，“bytes”的编码是[long数字表示长度] + 字节数组；“string”编码类似于bytes，只是字节是UTF-8编码之后的。比较有意思的是，avro编码并不会把字段的索引号、field类型输出到流中，这一点区别于protobuf。

    对于复合类型record，则不会将record的结构编码，只会依次编码filed，即record编码的结果其实就是所有fields依次编码的整合体。解析的过程将交给schema逻辑，而非将record结构信息编码到结果中。enum有一序列symbols，那么编码时只需要将enum的值所在的index作为结果即可，比如enum有[“A”,”b”,”C”]三个可选值，如果其值为A，那么只需要用0来表示即可，所以这也要求开发者不能随意变更enum类型的值列表。

    array类型的编码稍有复杂，一个array可能包含多个item值，那么这些item将会被编码成一序列的blocks，每个block包含几个item，数量不等，具体一个block包含几个item，有writer的buffer决定，即writer的buffer满时将会写入一个block。所以对于reader而言，是不能预先知道array有多少个item。一个block是由一个long计数值和多个item构成，这个long计数值表示当前block中item的个数；如果一个block的long计数值为0，则表示array的结束。item的type决定它使用何种具体的编码（参见primitive）。

    对于union编码，首先union的schema声明中包含多个值比如{“type”:[“null”,”string”]}，那么编码是，首先输出值所属type在union数组的位置（起始位0），然后输出值的二进制。比如“null”则会输出“00”，如果值为“a”，则会输出“02 02 61”（02表示string在union的索引位置为1，第二个02表示string的长度为1，这上string的编码结构）。

    fixed：这个很简单，因为fixed本身不是一种数据结构，仅仅表示字节长度，那么直接生成将bytes输出即可。

    JSON Encoding：将数据输出为json结构的字符串，key-value结构。需要注意一下，null将会输出“null”字符串，这个是由json决定。

    avro输出的数据文件，也是格式严谨的。它由header和多个file data block构成。其中header包括“magic”、“meta”、“sync”三个属性，magic通常为魔法数字：四个字节，ASII  ‘0’ ‘b’ ‘j’ 然后紧跟一个数字1（参看源码）；meta即为schema信息，sync为同步点，目前为16个字节的随机sync标记。

    file data block包含：1）此block中包含的avro对象的个数（object counts），long型 2） 此block中data序列化的长度（block size），long型 3）序列化的对象列表，如果制定了codec，那么此对象列表是经过压缩的。 4）一个16字节的sync标记。

    之所以将数据以block的方式组织，可以非常高效的“提取”或者skipped某个block（由sync判定）而不需要反序列化它的全部内容。将“block size”、“object counts”、“sync标记”组合在一起，也可以帮助检测block是否损坏，以确保数据的完整性。（参见DataFileReader，nextBlock等API）

    目前支持的codec有“null”、“deflate”，可选“snappy”（需要手动安装和指定）。

四、Protocol与RPC

    Protocol就像Java中interface，定义RPC操作。一个protocol包含如下属性：

    1）protocol：protocol的名字，必要属性，对于java而言就是interface的名字。

    2）namespace：可选属性，类似于package名称。

    3）doc：备注，注释

    4）types：用于定义protocol中所涉及到的数据类型（包括record，enum，fixed，error）。error的定义和record一样，其实它在语义上也是一个record，用来表示protocol的exception信息。

    5）messages：类似于JAVA中的方法（method）列表。它有几个属性：doc、request、response、error。

其中doc还是表示注释；request为JSON数组，用于声明此message的请求参数列表，结构类似于record；response表示响应的数据类型，如果为“null”表示无需响应值；error是一个可选项，声明可能的exception类型列表，union类型的数据结构。

    代码实例，首先需要增加一个avro-ipc依赖，同时修改插件的配置（pom.xml）：

    1、pom.xmlJava代码  

<dependency>  
  <groupId>org.apache.avro</groupId>  
  <artifactId>avro-ipc</artifactId>  
  <version>1.7.7</version>  
</dependency>  

Java代码  

<plugin>  
    <groupId>org.apache.avro</groupId>  
    <artifactId>avro-maven-plugin</artifactId>  
    <version>1.7.7</version>  
    <executions>  
        <execution>  
            <phase>generate-sources</phase>  
            <goals>  
                <goal>schema</goal>  
                <goal>protocol</goal>  
                <goal>idl-protocol</goal>  
            </goals>  
            <configuration>  
                <sourceDirectory>${project.basedir}/src/main/resources/avro/</sourceDirectory>  
                <outputDirectory>${project.basedir}/src/main/java/</outputDirectory>  
            </configuration>  
        </execution>  
    </executions>  
</plugin>  

    2、helloworld.avpr：此文件用于声明protocol schemaJava代码  

{  
  "namespace": "com.test.avro.rpc",  
  "protocol": "HelloWorld",  
  "doc": "Protocol Greetings",  
  
  "types": [  
    {"name": "Greeting", "type": "record", "fields": [  
      {"name": "message", "type": "string"}]},  
    {"name": "Curse", "type": "error", "fields": [  
      {"name": "message", "type": "string"}]}  
  ],  
  
  "messages": {  
    "hello": {  
      "doc": "Say hello.",  
      "request": [{"name": "greeting", "type": "Greeting" }],  
      "response": "Greeting",  
      "errors": ["Curse"]  
    }  
  }  
}  

    然后像普通的avro生成代码一样，执行“maven compile”即可生成protocol所需要的java代码。

    3、HelloWorldImpl.java：我们声明了一个Portocol为HelloWorld，代码生成后，那么HelloWorld就是一个接口，我们需要继承此接口实现真正的业务逻辑。Java代码  

public class HelloWorldImpl implements HelloWorld {  
  
    @Override  
    public Greeting hello(Greeting greeting) throws AvroRemoteException, Curse {  
        System.out.println(greeting.getMessage());  
        greeting.setMessage("From Server");  
        return greeting;  
    }  
}  

    4、测试代码Java代码  

public static void main(String[] args) throws Exception{  
  
    Server server = new NettyServer(new SpecificResponder(HelloWorld.class, new HelloWorldImpl()), new InetSocketAddress(8080));  
    server.start();  
    Thread.sleep(3000);  
  
    NettyTransceiver client = new NettyTransceiver(new InetSocketAddress(8080));  
    // client code - attach to the server and send a message  
    HelloWorld proxy = (HelloWorld) SpecificRequestor.getClient(HelloWorld.class, client);  
    Greeting request = new Greeting();  
    request.setMessage("From client");  
    Greeting response = proxy.hello(request);  
    System.out.println(response.getMessage());  
  
    client.close();  
    server.close();  
  
}  

    过程非常简单，我们看到Avro-ipc其实是依赖了netty的相关jar，其实通过netty来实现底层的IO通讯是一个不错的选择。avro-ipc还有多种方式，比如HttpServer，SaslSocketServer，DatagramServer，大家可以根据实际情况选择合适的通讯方式。 它们的内部实现基本类似，基于动态代理 + 反射机制 ，因为RPC都是“交互式”操作，如果在production环境中使用，通常开发者还需要考虑对client端、server端使用连接池机制，以提高吞吐能力，不过这些在avro-ipc中并没有提供，需要开发者自己实现；同时需要注意NettyTransceiver本身不能在多线程环境中使用，开发者需要将请求队列化，或者为每个request分配一个唯一的ID，以避免消息的错乱。

    当使用Http协议时，Avro通过request、response来交换消息，一个protocol通常由一个URL表达，Http的Content-type需要为“avro/binary”，并且client端需要通过post方式发送。

    “handshake”：“握手”的主要目的就是确保client和server端都能够持有对方的protocol声明，那么client可以正确的反序列化response，server端可以正确的反序列化request。client、server在进行实际操作之前，首先会通过handshake交换（确认）protocol schema，对于Http而言，是无状态的，那么也意味着每次请求都会进行handshake。对于有状态的通道，比如TCP，handshake只需要在connection建立之后进行一次即可，那么protocol schema将会被双方缓存起来。Java代码  

{  
  "type": "record",  
  "name": "HandshakeRequest", "namespace":"org.apache.avro.ipc",  
  "fields": [  
    {"name": "clientHash",  
     "type": {"type": "fixed", "name": "MD5", "size": 16}},  
    {"name": "clientProtocol", "type": ["null", "string"]},  
    {"name": "serverHash", "type": "MD5"},  
    {"name": "meta", "type": ["null", {"type": "map", "values": "bytes"}]}  
  ]  
}  
{  
  "type": "record",  
  "name": "HandshakeResponse", "namespace": "org.apache.avro.ipc",  
  "fields": [  
    {"name": "match",  
     "type": {"type": "enum", "name": "HandshakeMatch",  
              "symbols": ["BOTH", "CLIENT", "NONE"]}},  
    {"name": "serverProtocol",  
     "type": ["null", "string"]},  
    {"name": "serverHash",  
     "type": ["null", {"type": "fixed", "name": "MD5", "size": 16}]},  
    {"name": "meta",  
     "type": ["null", {"type": "map", "values": "bytes"}]}  
  ]  
}  

    上述即为handshake的schema，即client和server端交换protocol schema时所使用的“schema”，一个是client request，一个是server response。

    client请求时将会发送其本地protocol的hash值（clientHash），如果它已经获得过server端的hash值，此时也会传递过去（serverHash）。此后server端将会响应，如果client发送的hash值与server端计算的一致，返回结构为（match=BOTH,serverProtocol=null,serverHash=null）；如果不一致，这就意味着client和server端schema不同，那么server将会把自己的protocol反馈给client，响应结果为（match=CLIENT,serverProtocol!=null,serverHash!=null），client必须使用server返回的protocol处理此后的响应并将此protocol缓存起来。

    上述中提到需要client与server端的schema必须一致，MD5值一样；这个计算过程则需要非常的精细。如果断言2个schema在语义上是一致的？比如client schema中包含doc属性，而server端没有，但是这个doc并不影响语义上的解析，在逻辑上这两个schema仍然是“一致的”，但是MD5的计算值则不同（字面值不同）。这就引入了“解析范式”。（比较复杂，参见官网详解）

    至此，我们基本了解了avro的核心特性，以及如何使用avro实现简单的应用。我个人认为avro在RPC层面和thrift还有很大的差距，在使用thrift做RPC应用时非常简单而且是production级别可用。本人更加倾向于使用avro做数据存储和解析。