Avro：入门例子

最新推荐文章于 2024-08-07 09:07:56 发布

花飘万家雪

最新推荐文章于 2024-08-07 09:07:56 发布

阅读量479

点赞数

分类专栏： java

java 专栏收录该内容

50 篇文章 0 订阅

订阅专栏

Avro是由Hadoop创始人Doug Cutting创建的一种语言无关的数据序列化和RPC框架，用于解决Hadoop中Writable序列化机制的缺点：缺少跨语言特性，与Java绑的太紧，数据格式很难被JVM外的语言进行处理。

本文使用Specific API和Generic API来展示Avro的序列化和反序列化。

创建Maven项目

pom文件如下：

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>me.lin.avro</groupId>
    <artifactId>avro-started</artifactId>
    <version>0.0.1-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>org.apache.avro</groupId>
            <artifactId>avro</artifactId>
            <version>1.8.1</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.avro</groupId>
                <artifactId>avro-maven-plugin</artifactId>
                <version>1.8.1</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>
                    <source>1.7</source>
                    <target>1.7</target>
                </configuration>
            </plugin>

        </plugins>
        <pluginManagement>
            <plugins>
                <!--This plugin's configuration is used to store Eclipse m2e settings
                    only. It has no influence on the Maven build itself. -->
                <plugin>
                    <groupId>org.eclipse.m2e</groupId>
                    <artifactId>lifecycle-mapping</artifactId>
                    <version>1.0.0</version>
                    <configuration>
                        <lifecycleMappingMetadata>
                            <pluginExecutions>
                                <pluginExecution>
                                    <pluginExecutionFilter>
                                        <groupId>
                                            org.apache.avro
                                        </groupId>
                                        <artifactId>
                                            avro-maven-plugin
                                        </artifactId>
                                        <versionRange>
                                            [1.8.1,)
                                        </versionRange>
                                        <goals>
                                            <goal>schema</goal>
                                        </goals>
                                    </pluginExecutionFilter>
                                    <action>
                                        <ignore></ignore>
                                    </action>
                                </pluginExecution>
                            </pluginExecutions>
                        </lifecycleMappingMetadata>
                    </configuration>
                </plugin>
            </plugins>
        </pluginManagement>
    </build>
</project>

定义Schema

Avro的数据格式，即schema采用JSON定义，shcema由原始类型（null，boolean，int，long，float，double，bytes，string）和复杂类型（record，enum，array，map，union，fixed）组成，schema文件通常以.avsc结尾，代表avro schema。例如我们定义一个代表User的schema，文件名为user.avsc,放在src/main/resources/avro目录下:

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

上述定义中，namespace和name共同组成schema 的全称: me.lin.avro.User。type指定类型为复杂类型record，fileds数组定义record的字段。字段中的type指定为数组，代表该字段可以是int或者null类型。每一种数据类型可以定义哪一些参数，由Avro规范定义，也就是规范了定义Scheme中JSON需要遵循的JSON Schema。

Specific Mapping

生成代码

定义完Schema后，我们使用avro的maven插件生成代码，项目右键，Run As–>maven generate-sources.
运行之后在src/main/java中生成了一个User类，位于me.lin这个包中。User类内部生成了一个Builder类，用于构建User对象。

序列化：保存User到磁盘

我们使用不同的方式创建3个User对象：

User user1 = new User();
user1.setName("Alyssa");
user1.setFavoriteNumber(256);

User user2 = new User("Bean", 7, "red");

User user3 = User.newBuilder().setName("Braney")        .setFavoriteColor("blue").setFavoriteNumber(null).build();

使用构造器创建对象的效率比使用Builder高，但是Builder的方式会把Schema设置的默认值赋给对象相应的属性，并且校验数据是否符合schema。但是构造器不会做这些校验工作，直到对象被序列化的时候才会校验。接下来写入数据到本地磁盘文件：

DatumWriter<User> writer = new SpecificDatumWriter<User>(User.class);
DataFileWriter<User> dataFileWriter = new DataFileWriter<User>(writer);

dataFileWriter.create(user1.getSchema(), new File("users.avro"));
dataFileWriter.append(user1);
dataFileWriter.append(user2);
dataFileWriter.append(user3);

dataFileWriter.close();

放在main方法运行之后，在项目的跟目录下生成了users.avro文件：

这里写图片描述

反序列化：从文件中读取User

接着我们从刚才写入的文件中读取用户：

private static void readUsers() throws IOException {

DatumReader<User> reader = new SpecificDatumReader<User>(User.class);
DataFileReader<User> fileReader = new DataFileReader<User>(new File(
                "users.avro"), reader);

User user = null;
while (fileReader.hasNext()) {
    // 复用user对象，避免重复分配内存和GC
    user = fileReader.next(user);
    System.out.println(user);
}
}

运行输出如下：

{"name": "Alyssa", "favorite_number": 256, "favorite_color": null}
{"name": "Bean", "favorite_number": 7, "favorite_color": "red"}
{"name": "Braney", "favorite_number": null, "favorite_color": "blue"}

DatumReader将文件中读出的序列化文件转化成User对象，DataFileReader是个遍历器，用于遍历其中的User对象，循环中我们复用了user对象，如果性能不关心，完全可以用下面的形式：

for(User user : fileReader){
    System.out.println(user);
}

Generic Mapping

上述的读写操作，我们都是基于Schema生成的User类进行操作，这被称为Specific Mapping。事实上，Avro文件中总是包含对应的schema，作为元数据存在。因此在读取之前，我们完全可以不用知道schema，这种数据映射相应地被称为Generic Mapping。接下来我们不使用生成代码完成同样的读写：

创建用户

Schema schema = new  Schema.Parser().parse( new File("src/main/resources/avro/user.avsc")); 
GenericRecord user1 = new GenericData.Record(schema);
user1.put("name", "Ben");
user1.put("favorite_number", 256);

GenericRecord user2 = new GenericData.Record(schema);
user2.put("name", "Alyssa");
user2.put("favorite_number", 7);
user2.put("favorite_color", "red");

首先我们从shema文件中解析出Schema，然后用这个Schema构造GenericRecord，在设置user的属性值时，GenericRecord会根据schema做相应的校验工作。如果我们尝试put一个没有定义的字段，例如test_filed，则运行程序的时候会抛出AvroRuntimeException异常。

写入数据到文件

File file = new File("users-generic.avro");
DatumWriter<GenericRecord> datumWriter = new GenericDatumWriter<GenericRecord>(
                schema);
DataFileWriter<GenericRecord> writer = new DataFileWriter(datumWriter);

writer.create(schema, file);
writer.append(user1);
writer.append(user2);
writer.close();

读出数据

Schema schema = new Schema.Parser().parse(new File(
                "src/main/resources/avro/user.avsc"));
DatumReader<GenericRecord> datumReader = new GenericDatumReader<GenericRecord>(
                schema);
File file = new File("users-generic.avro");
DataFileReader<GenericRecord> reader = new DataFileReader<GenericRecord>(file, datumReader);
GenericRecord user = null;

while (reader.hasNext()) {
    user = reader.next(user);
    System.out.println(user);
}

运行输出如下：

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

可以看到，第二种基于通用记录的操作，没有跟具体的生成代码（User）打交道，而是跟Schema和GenericRecord这些通用的数据结构打交道。而第一种方式中，我们没有跟Schema打交道，而是直接跟生成的User类打交道。当领域相关性很强的时候，第一种SpecificReader/Writer的操作各适合。

转自：http://blog.csdn.net/bingduanlbd/article/details/52006520