下面介绍三个数据序列化的候选方案：
• Protocal Buffers：强大，灵活，但是对内存的消耗会比较大，并不是移动终端上的最佳选择。
• Nano-Proto-Buffers：基于Protocal，为移动终端做了特殊的优化，代码执行效率更高，内存使用效率更佳。
• FlatBuffers：这个开源库最开始是由Google研发的，专注于提供更优秀的性能。
FlatBuffers 是一个开源的跨平台数据序列化库，可以应用到几乎任何语言（C++, C#, Go, Java, JavaScript, PHP, Python），最开始是 Google 为游戏或者其他对性能要求很高的应用开发的。项目地址在 GitHub 上。官方的文档在 这里。
基本原理
如官方文档的介绍，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 虚拟机的堆内存分配策略实现，所以也是跨平台的。
1、数据的序列化和反序列化
服务器对象Object----流--->客户端Object对象
- 序列化： Serializable/Parcelable
- 时间：1ms * 10 * 50 * 20 = 10000ms
- 性能：内存的浪费和CPU计算时间的占用。
- 格式：json/xml（json序列化的工具GSON/fastjson）
2、FlatBuffer的优点
FlatBuffer 相对于其他序列化技术，例如 XML，JSON，Protocol Buffers 等，有哪些优势呢？官方文档的说法如下：
直接读取序列化数据，而不需要解析（Parsing）或者解包（Unpacking）：FlatBuffer 把数据层级结构保存在一个扁平化的二进制缓存（一维数组）中，同时能够保持直接获取里面的结构化数据，而不需要解析，并且还能保证数据结构变化的前后向兼容。
高效的内存使用和速度：FlatBuffer 使用过程中，不需要额外的内存，几乎接近原始数据在内存中的大小。
灵活：数据能够前后向兼容，并且能够灵活控制你的数据结构。很少的代码侵入性：使用少量的自动生成的代码即可实现。强数据类性，易于使用，跨平台，几乎语言无关。
3、 FlatBuffers 的缺点：
- FlatBuffers 需要生成代码，对代码有侵入性；
- 数据序列化没有可读性，不方便 Debug；
- 构建 FlatBuffers 对象比较麻烦，不直观，特别是如果对象比较复杂情况下需要写大段的代码；
- 数据的所有内容需要使用 Schema 严格定义，灵活性不如 JSON。
所以，在什么情况下选择使用 FlatBuffers 呢？个人感觉需要满足以下几点：
- 项目中有大量数据传输和解析，使用 JSON 成为了性能瓶颈；
- 稳定的数据结构定义。
4、FlatBuffer的使用
FlatBuffer:基于二进制的文件。
json：基于字符串的
- 获取flatbuffers代码
首先，我们需要得到 flatc，这个需要从源码编辑得到。从GitHub 上
Clone 代码
$ git clone https://github.com/google/flatbuffers
- 编写Schema
要使用 FlatBuffers 的 IDL 定义好数据结构 Schema，编写 Schema 的详细文档。其语法和 C 语言类似，比较容易上手。我们这里引用一个简单的例子2，假设数据结构如下：
class Person {
String name;
int friendshipStatus;
Person spouse;
List<Person>friends;
}
编写成 Schema 如下，文件名为 Person.fbs：
namespace com.race604.fbs;
enum FriendshipStatus: int {Friend = 1, NotFriend}
table Person {
name: string;
friendshipStatus: FriendshipStatus = Friend;
spouse: Person;
friends: [Person];
}
root_type Person;
然后，使用 flatc 可以把 Schema 编译成多种编程语言，我们仅仅讨论 Android 平台，所以把 Schema 编译成 Java，找到flatc.exe执行命令如下：
$ ./flatc –j -b Person.fbs
描述文件
namespace com.dn.ricky.performance.flatbuffer.lsn13_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;
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("jack@qq.com");
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<length; i++){
Car car = basic2.carList(i);
Log.i(TAG,"car.number:"+car.number());
Log.i(TAG,"car.describle:"+car.describle());
}
} catch (Exception e) {
e.printStackTrace();
}finally {
try {
if(readChannel!=null){
readChannel.close();
}
if(fis!=null){
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
