wo0x00 文章内容

1. 编写代码
2. 测试结果

0x01 编写代码

1. 编写对象类

编写Block类

1. package com.shaonaiyi.hadoop.serialize;
3. import java.io.Serializable;
5. /**
6. * @Author shaonaiyi@163.com
7. * @Date 2019/12/13 16:18
8. * @Description 定义需要序列化的Block类
9. */
10. public class Block implements Serializable {
12. private long blockId;
13. private long numBytes;
14. private long generationStamp;
16. public Block(long blockId, long numBytes, long generationStamp) {
17. this.blockId = blockId;
18. this.numBytes = numBytes;
19. this.generationStamp = generationStamp;
20. }
22. public long getBlockId() {
23. return blockId;
24. }
26. public long getNumBytes() {
27. return numBytes;
28. }
30. public long getGenerationStamp() {
31. return generationStamp;
32. }
34. @Override
35. public String toString() {
36. return "Block{" +
37. "blockId=" + blockId +
38. ", numBytes=" + numBytes +
39. ", generationStamp=" + generationStamp +
40. '}';
41. }
43. }

2. 编写调用测试代码

编写序列化与反序列化代码

1. package com.shaonaiyi.hadoop.serialize;
3. import java.io.*;
5. /**
6. * @Author shaonaiyi@163.com
7. * @Date 2019/12/13 16:20
8. * @Description 编写序列化与反序列化测试类代码
9. */
11. public class JavaSerializableTest {
12. public static void main(String[] args) throws IOException, ClassNotFoundException {
14. String fileName = "blockByte.txt";
15. serialize(fileName);
16. // deSerialize(fileName);
18. }
20. private static void serialize(String fileName) throws IOException {
21. Block block = new Block(78062621L, 39447651L, 56737546L);
23. File file = new File(fileName);
24. if (file.exists()) {
25. file.delete();
26. }
28. file.createNewFile();
29. FileOutputStream fileOutputStream = new FileOutputStream(file);
30. ObjectOutputStream objectOutputStream = new ObjectOutputStream(fileOutputStream);
31. objectOutputStream.writeObject(block);
32. objectOutputStream.close();
34. }
36. private static void deSerialize(String fileName) throws IOException, ClassNotFoundException {
38. FileInputStream fileInputStream = new FileInputStream(fileName);
39. ObjectInputStream objectInputStream = new ObjectInputStream(fileInputStream);
40. Object object = objectInputStream.readObject();
41. Block block = (Block)object;
42. System.out.println(block);
43. }
45. }

0x02 测试结果

1. 测试序列化

a. 先把Block类的序列化代码删掉，调用序列化方法，执行发现报错！即删除 publicclassBlockimplementsSerializable{里的 implementsSerializable

b. 加回序列化代码，执行，发现项目与main文件夹同级目录下多了一个 blockbyte.txt文件，双击打开：  发现是乱码，因为此处是二进制的代码文件，但还是会有很多额外的信息的，比如说包名等等。

2. 测试反序列化

打开反序列化方法，执行：

1. // serialize(fileName);
2. deSerialize(fileName);

发现可以将Block对象反序列化出来了。

3. 查看生成的文件大小

可以看到blockByte文件大小是120字节  但是，我们定义的Block类，其实只有24个字节。Long类是8个字节，三个Long类型的属性是24个字节，120与24比较，其实生成的文件已经大了很多了。

4. 测试修改对象代码

a. 尝试修改Block类，如在里面添加一个无参数的构造方法

1. public Block() {
3. }

b. 然后再反序列化，发现已经没有办法反序列化了，这可不是我们想看到的。

0xFF 总结

1. 内置的Java序列化接口是有缺陷的，会写入额外的信息。第一，会使得数据大小膨胀；第二，只要稍微改动一下代码就无法兼容，无法反序列化。两种情形上面都已经演示了，不是我们想要的结果。
2. 下一篇我们将讲解如何引入Hadoop的序列化机制，以弥补Java内置的序列化接口的缺陷。