Android性能优化篇之数据传输效率优化

Android性能优化篇之数据传输效率优化_第1张图片
image

引言

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 CREATOR = new Creator() {
        @Override
        public PersonInfo createFromParcel(Parcel in) {
            return new PersonInfo(in);
        }
        @Override
        public PersonInfo[] newArray(int size) {
            return new PersonInfo[size];
        }
    };
(3).Gson

GSON库来处理这个序列化的问题,不仅仅执行速度更快,内存的使用效率也更高。


Android性能优化篇之数据传输效率优化_第2张图片
image1.png
下面介绍三个数据序列化的候选方案:
  • Protocal Buffers:强大,灵活,但是对内存的消耗会比较大,并不是移动终端上的最佳选择。
  • Nano-Proto-Buffers:基于Protocal,为移动终端做了特殊的优化,代码执行效率更高,内存使用效率更佳。
  • FlatBuffers:这个开源库最开始是由Google研发的,专注于提供更优秀的性能。
    上面这些方案在性能方面的数据对比如下图所示:


    Android性能优化篇之数据传输效率优化_第3张图片
    image2.png
Android性能优化篇之数据传输效率优化_第4张图片
image3.png

FlatBuffers 几乎从空间和时间复杂度上完胜其他技术。
FlatBuffers 是一个开源的跨平台数据序列化库,可以应用到几乎任何语言(C++, C#, Go, Java, JavaScript, PHP, Python),最开始是 Google 为游戏或者其他对性能要求很高的应用开发的。

FlatBuffers

1.FlatBuffers优点
(1).直接读取序列化数据,而不需要解析(Parsing)或者解包(Unpacking):FlatBuffer 把数据层级结构保存在一个扁平化的二进制缓存(一维数组)中,同时能够保持直接获取里面的结构化数据,而不需要解析,并且还能保证数据结构变化的前后向兼容。
(2).高效的内存使用和速度:FlatBuffer 使用过程中,不需要额外的内存,几乎接近原始数据在内存中的大小。
(3).灵活:数据能够前后向兼容,并且能够灵活控制你的数据结构。
(4).很少的代码侵入性:使用少量的自动生成的代码即可实现。
(5).强数据类性,易于使用,跨平台,几乎语言无关。

官方提供了一个性能对比表


Android性能优化篇之数据传输效率优化_第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的一张图如下:


Android性能优化篇之数据传输效率优化_第6张图片
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).把生成的文件复制到项目中
Android性能优化篇之数据传输效率优化_第7张图片
image6.png
(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

你可能感兴趣的:(Android性能优化篇之数据传输效率优化)