引言
1. Android性能优化篇之内存优化--内存泄漏
2.Android性能优化篇之内存优化--内存优化分析工具
3.Android性能优化篇之UI渲染性能优化
4.Android性能优化篇之计算性能优化
5.Android性能优化篇之电量优化(1)——电量消耗分析
6.Android性能优化篇之电量优化(2)
7.Android性能优化篇之网络优化
8.Android性能优化篇之Bitmap优化
9.Android性能优化篇之图片压缩优化
10.Android性能优化篇之多线程并发优化
11.Android性能优化篇之数据传输效率优化
12.Android性能优化篇之程序启动时间性能优化
13.Android性能优化篇之安装包性能优化
14.Android性能优化篇之服务优化
介绍
数据的序列化是程序代码里面必不可少的组成部分,这篇我们就来一起看看序列化相关的知识。
数据序列化的行为可能发生在数据传递过程中的任何阶段，例如网络传输，不同进程间数据传递，不同类之间的参数传递，把数据存储到磁盘上等等。
什么是序列化和反序列化？
简单来说就是将对象转换为可以传输的二进制流(二进制序列)的过程,这样我们就可以通过序列化,转化为可以在网络传输或者保存到本地的流(序列),从而进行传输数据 ,那反序列化就是从二进制流(序列)转化为对象的过程.
常用的序列化有哪几种？
(1).Serializable
Serializable是我们平时使用比较多的，但是这种传统的做法效率不高，实施的过程会消耗更多的内存。
使用
public class CompanyInfo implements Serializable {
序列化
out = new FileOutputStream(mSerializeFile);
CompanyInfo companyInfo = new CompanyInfo(1001, "常州网络有限公司");
objectOutputStream = new ObjectOutputStream(out);
objectOutputStream.writeObject(companyInfo);
反序列化
fIn = new FileInputStream(mSerializeFile);
objectInputStream = new ObjectInputStream(fIn);
Object object
= objectInputStream.readObject();
if(object instanceof CompanyInfo){
CompanyInfo info = (CompanyInfo) object;
}
(2).Parcelable
Parcelable是Android为我们提供的序列化的接口,Parcelable相对于Serializable的使用相对复杂一些,但Parcelable的效率相对Serializable也高很多
使用
public class PersonInfo implements Parcelable
序列化
@Override
public void writeToParcel(Parcel dest, int flags) {
dest.writeInt(id);
dest.writeString(name);
dest.writeString(love);
}
反序列化
protected PersonInfo(Parcel in) {
id = in.readInt();
name = in.readString();
love = in.readString();
}
public static final Creator<PersonInfo> CREATOR = new Creator<PersonInfo>() {
@Override
public PersonInfo createFromParcel(Parcel in) {
return new PersonInfo(in);
}
@Override
public PersonInfo[] newArray(int size) {
return new PersonInfo[size];
}
};
(3).Gson
GSON库来处理这个序列化的问题，不仅仅执行速度更快，内存的使用效率也更高。
image1.png下面介绍三个数据序列化的候选方案：
- Protocal Buffers：强大，灵活，但是对内存的消耗会比较大，并不是移动终端上的最佳选择。
- Nano-Proto-Buffers：基于Protocal，为移动终端做了特殊的优化，代码执行效率更高，内存使用效率更佳。
FlatBuffers：这个开源库最开始是由Google研发的，专注于提供更优秀的性能。
上面这些方案在性能方面的数据对比如下图所示：
image2.png
FlatBuffers 几乎从空间和时间复杂度上完胜其他技术。
FlatBuffers 是一个开源的跨平台数据序列化库，可以应用到几乎任何语言（C++, C#, Go, Java, JavaScript, PHP, Python），最开始是 Google 为游戏或者其他对性能要求很高的应用开发的。
FlatBuffers
1.FlatBuffers优点
(1).直接读取序列化数据，而不需要解析（Parsing）或者解包（Unpacking）：FlatBuffer 把数据层级结构保存在一个扁平化的二进制缓存（一维数组）中，同时能够保持直接获取里面的结构化数据，而不需要解析，并且还能保证数据结构变化的前后向兼容。
(2).高效的内存使用和速度：FlatBuffer 使用过程中，不需要额外的内存，几乎接近原始数据在内存中的大小。
(3).灵活：数据能够前后向兼容，并且能够灵活控制你的数据结构。
(4).很少的代码侵入性：使用少量的自动生成的代码即可实现。
(5).强数据类性，易于使用，跨平台，几乎语言无关。
官方提供了一个性能对比表
image4.png
在做 Android 开发的时候，JSON 是最常用的数据序列化技术。我们知道，JSON 的可读性很强，但是序列化和反序列化性能却是最差的。解析的时候，JSON 解析器首先，需要在内存中初始化一个对应的数据结构，这个事件经常会消耗 100ms ~ 200ms2；解析过程中，要产生大量的临时变量，造成 Java 虚拟机的 GC 和内存抖动，解析 20KB 的数据，大概会消耗 100KB 的临时内存2。FlatBuffers 就解决了这些问题。
2.FlatBuffers缺点
(1).FlatBuffers 需要生成代码，对代码有侵入性
(2).数据序列化没有可读性，不方便 Debug；
(3).构建 FlatBuffers 对象比较麻烦，不直观，特别是如果对象比较复杂情况下需要写大段的代码；
(4).数据的所有内容需要使用 Schema 严格定义，灵活性不如 JSON。
3.FlatBuffers原理
官方文档的介绍，FlatBuffers 就像它的名字所表示的一样，就是把结构化的对象，用一个扁平化（Flat）的缓冲区保存，简单的来说就是把内存对象数据，保存在一个一维的数组中。借用 Facebook 文章2的一张图如下：
image5.png
可见，FlatBuffers 保存在一个 byte 数组中，有一个“支点”指针（pivot point）以此为界，存储的内容分为两个部分：元数据和数据内容。其中元数据部分就是数据在前面，其长度等于对象中的字段数量，每个 byte 保存对应字段内容在数组中的索引（从支点位置开始计算）。
如图，上面的 Person 对象第一个字段是 name，其值的索引位置是 1，所以从索引位置 1 开始的字符串，就是 name 字段的值 "John"。第二个字段是 friendshipStatus，其索引值是 6，找到值为 2， 表示 NotFriend。第三个字段是 spouse，也一个 Person 对象，索引值是 12，指向的是此对象的支点位置。第四个字段是一个数组，图中表示的数组为空，所以索引值是 0。通过上面的解析，可以看出，FlatBuffers 通过自己分配和管理对象的存储，使对象在内存中就是线性结构化的，直接可以把内存内容保存或者发送出去，加载“解析”数据只需要把 byte 数组加载到内存中即可，不需要任何解析，也不产生任何中间变量。
它与具体的机器或者运行环境无关，例如在 Java 中，对象内的内存不依赖 Java 虚拟机的堆内存分配策略实现，所以也是跨平台的。
4.FlatBuffers使用步骤：
(1).定义数据结构 Schema
namespace Character;
table Items{
items:[Basic];
itemId:long;
timestemp:long;
}
table Basic{
id:long;
name:string;
email:string;
code:long;
isVip:bool;
count:int;
headUrl:string (deprecated);
carList:[Car];
}
table Car{
id:long;
number:long;
describle:string;
}
root_type Items;
(2).把 Schema 编译成 Java
flatc.exe -j -b Character.fbs
(3).把生成的文件复制到项目中
(4).编写代码
序列化
FlatBufferBuilder builder = new FlatBufferBuilder();
int car1 = Car.createCar(builder, 1000l, 8000l, builder.createString("1000的描述"));
int car2 = Car.createCar(builder, 1001l, 8001l, builder.createString("1001的描述"));
int car3 = Car.createCar(builder, 1002l, 8002l, builder.createString("1002的描述"));
int basic1 = Basic.createBasic(builder, 2000,
builder.createString("2000产品"), true,
Basic.createCarListVector(builder, new int[]{car1, car2, car3}));
int basic2 = Basic.createBasic(builder, 2001,
builder.createString("2001产品"), true,
Basic.createCarListVector(builder, new int[]{car2, car3}));
int itemListId = Items.createItemListVector(builder, new int[]{basic1, basic2});
Items.startItems(builder);
Items.addItemList(builder,itemListId);
Items.addTimestemp(builder,2017l);
int endItems = Items.endItems(builder);
Items.finishItemsBuffer(builder,endItems);
FileOutputStream out = null;
FileChannel inChannel = null;
try{
if(mSerializeFile.exists()){
mSerializeFile.delete();
}
out = new FileOutputStream(mSerializeFile);
inChannel = out.getChannel();
ByteBuffer buffer =
builder.dataBuffer();
while (buffer.hasRemaining()) {
inChannel.write(buffer);
}
Toast.makeText(this,"序列号成功",Toast.LENGTH_LONG).show();
}
反序列化
in = new FileInputStream(mSerializeFile);
outChannel = in.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(1024);
int readSize = 0;
while((readSize= outChannel.read(buffer))!=-1){
Log.e(TAG,"===>"+readSize);
}
buffer.flip();
Items rootAsItems = Items.getRootAsItems(buffer);
Log.e(TAG , "timestem ==>"+rootAsItems.timestemp());
int itemsLength
= rootAsItems.itemListLength();
for (int i = 0; i < itemsLength; i++) {
Basic basic = rootAsItems.itemList(i);
Log.e(TAG,"---id:"+basic.id()+"---name:"+basic.name());
int carListLength = basic.carListLength();
for (int i1 = 0; i1 < carListLength; i1++) {
Car car = basic.carList(i1);
Log.e(TAG,"-------------id:"+car.id()+"---describle:"+car.describle());
}
}
Toast.makeText(this,"序列号成功",Toast.LENGTH_LONG).show();
}
5.FlatBuffers使用建议：
(1).项目中有大量数据传输和解析，使用 JSON 成为了性能瓶颈时使用FlatBuffers
(2).稳定的数据结构定义,可以使用FlatBuffers
