Apache Avro 的基本功能

刺骨的言语ヽ痛彻心扉 2022-05-30 06:50 206阅读 0赞

## 介绍 ##

Apache Avro™是一个数据序列化系统。

Avro提供：

*  丰富的数据结构。
 *  紧凑，快速的二进制数据格式。
 *  一个容器文件，用于存储持久性数据。
 *  远程过程调用（RPC）。
 *  与动态语言的简单集成。读取或写入数据文件不需要代码生成，也不需要使用或实现RPC协议。代码生成是一种可选的优化，只有静态类型语言才值得实现。

##  ##

## Schemas ##

所谓shemas，就是一种描述文件，能够说清楚你的对象的描述文件。可能有你对象里面有什么，他们之间的逻辑关系，数据的统计信息。比如说对人的描述包括身高、体重、三维、性别等，只要他的格式确定，就可以叫做shemas。

Avro也是依赖于schemas的（为了夸语言，也为了持久化，总要有二进制数据解析的指导）。当读取Avro数据的时候需要使用到schemas， 当写数据的时候也需要有schema的指导。这样就允许了每个数据都没有前缀开销（因为可以用schema来理解数据），这就会使得序列化很快而且数据会比较小。

当把Avro数据存储到文件的时候，会把他的schema数据一起存储，这样数据就可以被接下来的任意程序使用了。如果程序希望用其他的schema来读取数据，是很简单的，因为你可以同个比较两个schema来看能不能读取数据

当Avro用于RPC的时候，客户端和服务端可以在连接握手的阶段进行schema交换。（这种方式是可以被优化的，因为对于很多schema来说，是没有schema的交换的）由于两边都有对方完整的schema存在了，所有可以比较出同名域、缺少的域、多余的域。

avro的schema是用json定义的。这样有json包的语言就会比较容易实现了。

## 与其他系统比较 ##

Avro提供的功能类似于[Thrift][]， [Protocol Buffers][]等系统。Avro在以下基本方面与这些系统不同。

*  *动态输入*：Avro不需要生成代码。数据总是伴随着一个模式，允许在不生成代码的情况下完全处理该数据，静态数据类型等。这有助于构建通用数据处理系统和语言。
 *  *未标记的数据*：由于在读取数据时存在模式，因此需要使用数据编码少得多的类型信息，从而导致更小的序列化大小。
 *  *没有手动分配的字段ID*：当模式更改时，旧数据和新模式在处理数据时总是存在，因此可以使用字段名称以符号方式解析差异。
 *  语言无关的数据序列化和[RPC][]框架，用于解决Hadoop中Writable序列化机制的缺点：缺少跨语言特性，与Java绑的太紧，数据格式很难被JVM外的语言进行处理。

## 基本功能 ##

**1.序列化和反序列化**

## Serializing and deserializing with code generation ##

## Download ##

<dependency>
      <groupId>org.apache.avro</groupId>
      <artifactId>avro</artifactId>
      <version>1.8.2</version>
    </dependency>

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

##  ##

## Defining a schema ##

{"namespace": "example.avro",
     "type": "record",
     "name": "User",
     "fields": [
         {"name": "name", "type": "string"},
         {"name": "favorite_number",  "type": ["int", "null"]},
         {"name": "favorite_color", "type": ["string", "null"]}
     ]
    }

### Compiling the schema ###

java -jar /path/to/avro-tools-1.8.2.jar compile schema user.avsc .

### Creating Users ###

User user1 = new User();
    user1.setName("Alyssa");
    user1.setFavoriteNumber(256);
    // Leave favorite color null
    
    // Alternate constructor
    User user2 = new User("Ben", 7, "red");
    
    // Construct via builder
    User user3 = User.newBuilder()
                 .setName("Charlie")
                 .setFavoriteColor("blue")
                 .setFavoriteNumber(null)
                 .build();

### Serializing ###

// Serialize user1, user2 and user3 to disk
    DatumWriter<User> userDatumWriter = new SpecificDatumWriter<User>(User.class);
    DataFileWriter<User> dataFileWriter = new DataFileWriter<User>(userDatumWriter);
    dataFileWriter.create(user1.getSchema(), new File("users.avro"));
    dataFileWriter.append(user1);
    dataFileWriter.append(user2);
    dataFileWriter.append(user3);
    dataFileWriter.close();

### Deserializing ###

// Deserialize Users from disk
    DatumReader<User> userDatumReader = new SpecificDatumReader<User>(User.class);
    DataFileReader<User> dataFileReader = new DataFileReader<User>(file, userDatumReader);
    User user = null;
    while (dataFileReader.hasNext()) {
    // Reuse user object by passing it to next(). This saves us from
    // allocating and garbage collecting many objects for files with
    // many items.
    user = dataFileReader.next(user);
    System.out.println(user);
    }

This snippet will output:

{"name": "Alyssa", "favorite_number": 256, "favorite_color": null}
    {"name": "Ben", "favorite_number": 7, "favorite_color": "red"}
    {"name": "Charlie", "favorite_number": null, "favorite_color": "blue"}

## Serializing and deserializing without code generation ##

### Creating users ###

First, we use a Parser to read our schema definition and create a Schema object.

Schema schema = new Schema.Parser().parse(new File("user.avsc"));

Using this schema, let's create some users.

GenericRecord user1 = new GenericData.Record(schema);
    user1.put("name", "Alyssa");
    user1.put("favorite_number", 256);
    // Leave favorite color null
    
    GenericRecord user2 = new GenericData.Record(schema);
    user2.put("name", "Ben");
    user2.put("favorite_number", 7);
    user2.put("favorite_color", "red");

### Serializing ###

// Serialize user1 and user2 to disk
    File file = new File("users.avro");
    DatumWriter<GenericRecord> datumWriter = new GenericDatumWriter<GenericRecord>(schema);
    DataFileWriter<GenericRecord> dataFileWriter = new DataFileWriter<GenericRecord>(datumWriter);
    dataFileWriter.create(schema, file);
    dataFileWriter.append(user1);
    dataFileWriter.append(user2);
    dataFileWriter.close();

### Deserializing ###

Finally, we'll deserialize the data file we just created.

// Deserialize users from disk
    DatumReader<GenericRecord> datumReader = new GenericDatumReader<GenericRecord>(schema);
    DataFileReader<GenericRecord> dataFileReader = new DataFileReader<GenericRecord>(file, datumReader);
    GenericRecord user = null;
    while (dataFileReader.hasNext()) {
    // Reuse user object by passing it to next(). This saves us from
    // allocating and garbage collecting many objects for files with
    // many items.
    user = dataFileReader.next(user);
    System.out.println(user);

This outputs:

{"name": "Alyssa", "favorite_number": 256, "favorite_color": null}
    {"name": "Ben", "favorite_number": 7, "favorite_color": "red"}

**2.RPC**

[Thrift]: http://thrift.apache.org/
[Protocol Buffers]: http://code.google.com/p/protobuf/
[RPC]: https://github.com/phunt/avro-rpc-quickstart