Java的序列化

4：arvo的序列化和反序列化

使用步骤如下：

1:定义.avsc描述文件
2：通过avro-tool.jar，以.avsc描述文件作为输入生成pojo
3：通过avro.jar的API进行序列化（生成.avro文件）和反序列化
1
2
3

首先我们需要定义IDL，命名为User.avsc:

{
    "namespace": "dongshi.daddy.seriablize.avro",
    "type": "record",
    "name": "User",
    "fields": [
        {"name": "name", "type": "string"},
        {"name": "id", "type": "int"},
        {"name": "salary", "type": "int"},
        {"name": "age", "type": "int"},
        {"name": "address", "type": "string"}
    ]
}
1
2
3
4
5
6
7
8
9
10
11
12

接着通过avro-tools.jar生成pojo，如下：

$ java -jar avro-tools-1.8.2.jar compile schema User.avsc res
Input files to compile:
  User.avsc
log4j:WARN No appenders could be found for logger (AvroVelocityLogChute).
log4j:WARN Please initialize the log4j system properly.
log4j:WARN See http://logging.apache.org/log4j/1.2/faq.html#noconfig for more info.
1
2
3
4
5
6

然后我们将生成的User.java文件拷贝到classpath的dongshi.daddy.seriablize.avro目录，接着就可以执行序列化和反序列化了，首先执行序列化：

@Test
public void testAvroSerialize() throws Exception {
// 声明并初始化User对象
    // 方式一
    User user1 = new User();
    user1.setName("wqbin");
    user1.setId(1);
    user1.setSalary(1000);
    user1.setAge(20);
    user1.setAddress("beijing");

    // 方式二 使用构造函数
// Alternate constructor
    User user2 = new User("wang", 2, 1000, 19, "guangzhou");

// 方式三，使用Build方式
// Construct via builder
    User user3 = User.newBuilder()
            .setName("bin")
            .setId(3)
            .setAge(21)
            .setSalary(2000)
            .setAddress("shenzhen")
            .build();
    String userDir = System.getProperty("user.dir");
    System.out.println("userDir is: " + userDir);
    String path = userDir + "/User.avro"; // avro文件存放目录
    DatumWriter<User> userDatumWriter = new SpecificDatumWriter<User>(User.class);
    DataFileWriter<User> dataFileWriter = new DataFileWriter<User>(userDatumWriter);
    dataFileWriter.create(user1.getSchema(), new File(path));
// 把生成的user对象写入到avro文件
    dataFileWriter.append(user1);
    dataFileWriter.append(user2);
    dataFileWriter.append(user3);
    dataFileWriter.close();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

生成文件如下：

接着执行反序列化：

@Test
public void testAvroDeserialize() throws Exception {
    DatumReader<User> reader = new SpecificDatumReader<User>(User.class);
    DataFileReader<User> dataFileReader = new DataFileReader<User>(new File(System.getProperty("user.dir") + "/User.avro"), reader);
    User user = null;
    while (dataFileReader.hasNext()) {
        user = dataFileReader.next();
        System.out.println(user);
    }
}
1
2
3
4
5
6
7
8
9
10

输出如下内容则为成功：

{"name": "wqbin", "id": 1, "salary": 1000, "age": 20, "address": "beijing"}
{"name": "wang", "id": 2, "salary": 1000, "age": 19, "address": "guangzhou"}
{"name": "bin", "id": 3, "salary": 2000, "age": 21, "address": "shenzhen"}

Process finished with exit code 0
1
2
3
4
5

5：kryo的序列化和反序列化

kryo是底层使用了ASM字节码技术，所以其只能使用在基于JVM的语言上，如Java，scala，kotlin等，接下来看下其如何使用。

• 首先引入pom：

<dependency>
    <groupId>com.esotericsoftwaregroupId>
    <artifactId>kryoartifactId>
    <version>5.2.0version>
dependency>
1
2
3
4
5

• 序列化：

@Test
public void testKrypSerialize() throws Exception {
    Kryo kryo = new Kryo();
    kryo.register(SomeClass.class);

    SomeClass someClass = new SomeClass();
    someClass.value = "dongshidaddy";
    Output output = new Output(new FileOutputStream(userDir + "/someCls.bin"));
    kryo.writeObject(output, someClass);
    output.close();
}
1
2
3
4
5
6
7
8
9
10
11

运行后：

• 反序列化

@Test
public void testKrypDeserialize() throws Exception {
    Kryo kryo = new Kryo();
    kryo.register(SomeClass.class);

    Input input = new Input(new FileInputStream(userDir + "/someCls.bin"));
    SomeClass someClassFromBin = kryo.readObject(input, SomeClass.class);
    System.out.println(someClassFromBin.value);
}
1
2
3
4
5
6
7
8
9

运行后：

dongshidaddy

Process finished with exit code 0
1
2
3

6：fst的序列化和反序列化

java的序列化和反序列化方式，性能优秀（jdk原生序列化速度的10倍，序列化结果体积1/3左右），如果有序列化的需求可以考虑使用。看下如何使用。

• 引入pom

<dependency>
    <groupId>de.ruedigermoellergroupId>
    <artifactId>fstartifactId>
    <version>2.04version>
dependency>
1
2
3
4
5

• 序列化和反序列化

// fst序列化和反序列化
@Test
public void testFstSerializeAndDescrialize() {
    dongshi.daddy.seriablize.fst.User bean = new dongshi.daddy.seriablize.fst.User();
    bean.setUsername("xxxxx");
    bean.setPassword("123456");
    bean.setAge(1000000);
    byte[] byteBean = configuration.asByteArray(bean);
    System.out.println("序列化的字节大小是：" + byteBean.length);
    // 反序列化
    dongshi.daddy.seriablize.fst.User resultBean = (dongshi.daddy.seriablize.fst.User) configuration.asObject(byteBean);
    System.out.println("fst反序列化的结果是：" + resultBean);
}
1
2
3
4
5
6
7
8
9
10
11
12
13

输出如下内容则为成功：

序列化的字节大小是：68
fst反序列化的结果是：User(username=xxxxx, age=1000000, password=123456)

Process finished with exit code 0
1
2
3
4

写在后面

巨人的肩膀

再来认识一下 Java 序列化 。

Hessian序列化实例 。

Avro从入门到入土 。

深入浅出序列化（2）——Kryo序列化 。

Kryo 和 FST 序列化 。