1.数据传输如何优化
- 数据的序列化和反序列化
- 当前常见的数据传输的方式
2.FlatBuffers
- 数据的序列化
- 传统的做法效率问题
- 序列化方案对比
- FlatBuffers优点
- FlatBuffers使用
- FlatBuffers原理
- FlatBuffers选择
- 实例
1.数据传输如何优化
数据传输效率主要体现在：
- 程序内部的数据传输
- 程序外部的网络数据传输
1.1.数据的序列化和反序列化
数据传输的流程：
服务器对象Object----流--->客户端Object对象
序列化：Serializable/Parcelable，这是java中常用的，效率不高
有必要进行序列化的优化吗？
应用的数据传输会导致对象的大量序列化和反序列化，如果应用的传输效率要求不高，基本的序列化方法可以满足（比如现在常用的json）。但是应用的数据传输量大，响应要求高，在这方面的优化也是相当重要的。
优化的好处：
- 时间方面：1ms * 10 * 50 * 20 = 10000ms
- 性能方面：内存的浪费和CPU计算时间的占用。
1.2.当前常见的数据传输的方式：
json/xml
json序列化的工具GSON/fastjson
FlatBuffer：基于二进制的文件。
json：基于字符串的
json传输的过程解析：
8583协议
2.FlatBuffers(数据序列化的性能优化)
2.1.数据的序列化
数据的序列化是程序代码里面必不可少的组成部分，当我们讨论到数据序列化的性能的时候，需要了解有哪些候选的方案，他们各自的优缺点是什么。首先什么是序列化？用下面的图来解释一下：
2.2.传统的做法效率问题
数据序列化的行为可能发生在数据传递过程中的任何阶段，例如：
- 网络传输，
- 不同进程间数据传递，
- 不同类之间的参数传递，
- 把数据存储到磁盘上等等。
通常情况下，我们会把那些需要序列化的类实现Serializable接口(如下图所示)，但是这种传统的做法效率不高，实施的过程会消耗更多的内存。
但是我们如果使用GSON库来处理这个序列化的问题，不仅仅执行速度更快，内存的使用效率也更高。Android的XML布局文件会在编译的阶段被转换成更加复杂的格式，具备更加高效的执行性能与更高的内存使用效率。
2.3.序列化方案对比
- Protocal Buffers：强大，灵活，但是对内存的消耗会比较大，并不是移动终端上的最佳选择。
- Nano-Proto-Buffers：基于Protocal，为移动终端做了特殊的优化，代码执行效率更高，内存使用效率更佳。
- FlatBuffers：这个开源库最开始是由Google研发的，专注于提供更优秀的性能。
上面这些方案在性能方面的数据对比如下图所示：
可见，FlatBuffers 几乎从空间和时间复杂度上完胜其他技术。
FlatBuffers 是一个开源的跨平台数据序列化库，可以应用到几乎任何语言（C++, C#, Go, Java, JavaScript, PHP, Python），最开始是 Google 为游戏或者其他对性能要求很高的应用开发的。项目地址在 GitHub 上。官方的文档在 这里。
2.4.FlatBuffer的优点
FlatBuffer 相对于其他序列化技术，例如 XML，JSON，Protocol Buffers 等，有哪些优势呢？官方文档的说法如下：
-
- 直接读取序列化数据，而不需要解析（Parsing）或者解包（Unpacking）：FlatBuffer 把数据层级结构保存在一个扁平化的二进制缓存（一维数组）中，同时能够保持直接获取里面的结构化数据，而不需要解析，并且还能保证数据结构变化的前后向兼容。
-
- 高效的内存使用和速度：FlatBuffer 使用过程中，不需要额外的内存，几乎接近原始数据在内存中的大小。
-
- 灵活：数据能够前后向兼容，并且能够灵活控制你的数据结构。
-
- 很少的代码侵入性：使用少量的自动生成的代码即可实现。
-
- 强数据类性，易于使用，跨平台，几乎语言无关。
官方提供了一个性能对比表如下：
对比JSON
在做 Android 开发的时候，JSON 是最常用的数据序列化技术。我们知道，JSON 的可读性很强，但是序列化和反序列化性能却是最差的。解析的时候，JSON 解析器首先，需要在内存中初始化一个对应的数据结构，这个事件经常会消耗 100ms ~ 200ms2；解析过程中，要产生大量的临时变量，造成 Java 虚拟机的 GC 和内存抖动，解析 20KB 的数据，大概会消耗 100KB 的临时内存。FlatBuffers 就解决了这些问题。
2.4.使用方法
简单来说，FlatBuffers 的使用方法是：
- 首先按照使用特定的 IDL 定义数据结构 schema；
- 然后使用编译工具 flatc 编译 schema 生成对应的代码，把生成的代码应用到工程中即可。
具体使用请参考
2.5. 基本原理
如官方文档的介绍，FlatBuffers 就像它的名字所表示的一样，就是把结构化的对象，用一个扁平化（Flat）的缓冲区保存，简单的来说就是把内存对象数据，保存在一个一维的数组中。借用 Facebook 文章2的一张图如下：
可见，FlatBuffers 保存在一个 byte 数组中，有一个“支点”指针（pivot point）以此为界，存储的内容分为两个部分：元数据和数据内容。其中元数据部分就是数据在前面，其长度等于对象中的字段数量，每个 byte 保存对应字段内容在数组中的索引（从支点位置开始计算）。
如图，上面的 Person 对象第一个字段是 name，其值的索引位置是 1，所以从索引位置 1 开始的字符串，就是 name 字段的值 "John"。第二个字段是 friendshipStatus，其索引值是 6，找到值为 2， 表示 NotFriend。第三个字段是 spouse，也一个 Person 对象，索引值是 12，指向的是此对象的支点位置。第四个字段是一个数组，图中表示的数组为空，所以索引值是 0。
通过上面的解析，可以看出，FlatBuffers 通过自己分配和管理对象的存储，使对象在内存中就是线性结构化的，直接可以把内存内容保存或者发送出去，加载“解析”数据只需要把 byte 数组加载到内存中即可，不需要任何解析，也不产生任何中间变量。
它与具体的机器或者运行环境无关，例如在 Java 中，对象内的内存不依赖 Java 虚拟机的堆内存分配策略实现，所以也是跨平台的。
2.6. 使用建议
通过前面的体验，FlatBuffers 几乎秒杀了 JSON，我也尝试使用到现在的项目中，但是最后还是放弃了，下面说说 FlatBuffers 的几点缺点：
- 1.FlatBuffers 需要生成代码，对代码有侵入性；
- 2.数据序列化没有可读性，不方便 Debug；
- 3.构建 FlatBuffers 对象比较麻烦，不直观，特别是如果对象比较复杂情况下需要写大段的代码；
- 4.数据的所有内容需要使用 Schema 严格定义，灵活性不如 JSON。
我最后在项目中放弃是因为上面的第 4 点，因为在我的项目中，数据结构变化很大，不方便使用 Schema 完全定义。话又说回来，FlatBuffers 这么多好处，还是很吸引我的，可能会在其他的项目中尝试。
所以，在什么情况下选择使用 FlatBuffers 呢？个人感觉需要满足以下几点：
- 项目中有大量数据传输和解析，使用 JSON 成为了性能瓶颈；
- 稳定的数据结构定义。
2.7.实例
1.item.fbs
namespace com.test.flatbuffer;
table Items {
ItemId : long;
timestemp : int;
basic:[Basic];
}
table Basic{
id:int;
name:string;
email:int;
code:long;
isVip:bool;
count:int;
carList:[Car];
}
table Car{
id:long;
number:long;
describle:string;
}
root_type Items;
2.数据类：
3.activity
public void serialize(View v){
//==================序列化========================
FlatBufferBuilder builder = new FlatBufferBuilder();
int id1 = builder.createString("兰博基尼");
//准备Car对象
int car1 = Car.createCar(builder,10001L,88888L,id1);
int id2 = builder.createString("奥迪A8");
//准备Car对象
int car2 = Car.createCar(builder,10001L,88888L,id2);
int id3 = builder.createString("奥迪A9");
//准备Car对象
int car3 = Car.createCar(builder,10001L,88888L,id3);
int[] cars = new int[3];
cars[0]= car1;
cars[1] = car2;
cars[2] = car3;
//创建Basic对象里面的Car集合
int carList = Basic.createCarListVector(builder,cars);
int name = builder.createString("jack");
int email = builder.createString("[email protected]");
int basic = Basic.createBasic(builder,10,name,email,100L,true,100,carList);
int basicOffset = Items.createBasicVector(builder,new int[]{basic});
/**
* table Items {
ItemId : long;
timestemp : int;
basic:[Basic];
}
*/
Items.startItems(builder);
Items.addItemId(builder,1000L);
Items.addTimestemp(builder,2016);
Items.addBasic(builder,basicOffset);
int rootItems = Items.endItems(builder);
Items.finishItemsBuffer(builder,rootItems);
//============保存数据到文件=================
File sdcard = Environment.getExternalStorageDirectory();
//保存的路径
File file = new File(sdcard,"Items.txt");
if(file.exists()){
file.delete();
}
ByteBuffer data = builder.dataBuffer();
FileOutputStream out = null;
FileChannel channel = null;
try {
out = new FileOutputStream(file);
channel = out.getChannel();
while(data.hasRemaining()){
channel.write(data);
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(out!=null){
out.close();
}
if(channel!=null){
channel.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
//===================反序列化=============================
FileInputStream fis = null;
FileChannel readChannel = null;
try {
fis = new FileInputStream(file);
ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
readChannel = fis.getChannel();
int readBytes = 0;
while ((readBytes=readChannel.read(byteBuffer))!=-1){
System.out.println("读取数据个数："+readBytes);
}
//把指针回到最初的状态，准备从byteBuffer当中读取数据
byteBuffer.flip();
//解析出二进制为Items对象。
Items items = Items.getRootAsItems(byteBuffer);
//读取数据测试看看是否跟保存的一致
Log.i(TAG,"items.id:"+items.ItemId());
Log.i(TAG,"items.timestemp:"+items.timestemp());
Basic basic2 = items.basic(0);
Log.i(TAG,"basic2.name:"+basic2.name());
Log.i(TAG,"basic2.email:"+basic2.email());
//carList
int length = basic2.carListLength();
for (int i=0;i