_区长

一篇胎死腹中的Android文章——Dex文件结构解析

前言

国庆的时候，为了理解DexDiff算法，花了几天时间研究了下Dex的文件结构，算是有个整体的把握，这篇文章是在姜维的《Android逆向之旅—解析编译之后的Dex文件格式》基础上，自己对Dex格式的理解，以防忘记，做一次备忘。在理解Dex文件格式之前，需要了解两个概念：

字节序
LEB128格式

字节序

如果将值为0x12345678的32位整型从地址0x00000000开始保存，那么是如何存储的呢，有两种情况：

地址偏移	大端存储	小端存储
0x00000000	0x12	0x78
0x00000001	0x34	0x56
0x00000002	0x56	0x34
0x00000003	0x78	0x12

从上表中看到：

如果使用大端存储：较高的有效字节（0x12）存放在较低的存储器地址（0x00000000），较低的有效字节（0x78）存放在较高的存储器地址（0x00000003）。
如果使用小端存储：较高的有效字节（0x12）存放在较高的的存储器地址（0x00000003），较低的有效字节（0x78）存放在较低的存储器地址（0x00000000）。

而Dex文件格式中有一项是大小端标记，其真实值为0x12345678，但是它在文件中存储为0x78563412，因此Dex是典型的小端存储。

LEB128格式

LEB 128是一种基于1个字节的不定长度的编码方式。如果第一个字节的最高位为1，则表示还需要下一个字节来继续补充描述，直到最后一个字节的最高位为0 。这种编码方式主要为了解决内存的浪费问题，当表示一个int类型的值时，最少只需要1个字节，最多需要5个字节进行表示。

那么问题来了，如果我们用正常方式来存储值为131的int类型，则需要整整4个字节，即0b 00000000 00000000 00000000 10000011 ，可以看到高3位都是无效位，浪费内存。这时候如果用LEB128编码进行存储，则可以表示为

10000011 00000001

可以看到，只需要2个字节就可以表示131。那么如何对上面的编码进行解码呢？

初始化result=0，n=0，每操作完一个字节对n进行递增。
循环开始，读取一个字节
去除该字节最高位
将其余字节左移7*n位，然后与result进行或运算连接
递增n
判断当前字节最高位是否是1且n是否小于5，如果是的话，回到第二步继续循环，直到最高位是0或者n>=5终止循环。
这时候的result就是最终的值。

我们按照以上流程对10000011 00000001进行解码。

读一个字节字节，得到10000011，去除最高位得到0000011，左移7*n位，此时n=0，无需左移，与result进行或运算，得到result=0000011
递增n，此时n=1
10000011的最高位是1，并且n<5，继续循环读取一个字节，得到00000001
去除最高位得到0000001，左移7*n位，此时n=1，左移7位，得到00000010000000，与result进行或运算连接，得到result=00000010000011
递增n，此时n=2
00000001的最高位是0，终止循环。
此时result=00000010000011，去除高位无效位后得到result=10000011，转换为10进制就是131.

那么代码里如何对LEB128编码格式进行解码呢。简单地看下aosp的实现。

public static int readUnsignedLeb128(Buffer in) {
    int result = 0;
    int cur;
    int count = 0;
    do {
        byte b = in.readByte();//读取一个字节
        cur = b & 0xff; //该字节与0b11111111进行与操作,得到的应该还是其本身,这一步操作是否必要? 为了对齐8位？
        result |= (cur & 0x7f) << (count * 7); //该字节与0b0111111进行与操作,去除最高位,然后左移7*count位数,与result进行或运算连接,左移是因为是小端存储
        count++;
    } while (((cur & 0x80) == 0x80) && count < 5);//与0b10000000,最高位是1并且小于5个字节则一直循环

    //10000 0000 是非法的LEB128序列,0用00000000表示
    if ((cur & 0x80) == 0x80) {
        throw new DexException("invalid LEB128 sequence");
    }

    return result;
}

构造解析文件

在解析文件格式之前，需要构造一个Dex，这个Dex我们以最简单为主。

新建一个新的类Hello.java，假设该文件位于$Test目录下。

public class Hello{
    public static void main(String[] args){
        System.out.println("Hello world!");
    }
}

进入$Test 目录，将源码编译成class文件。

javac Hello.java -source 1.7 -target 1.7

通过dx命令将class转为dex文件，dx命令位于 $AndroidSDK/build-tools/$version/dx下

dx --dex --output=Hello.dex Hello.class

当然我们可以直接在手机上运行该dex，通过adb push该dex到手机上直接运行，用dalvikvm运行，dalvikvm 会在 /data/dalvik-cache/ 目录下创建 .dex 文件，因此要求 ADB 执行 Shell时对目录 /data/dalvik-cache/ 有读、写和执行的权限，因此要求手机是root的，或者用模拟器。

adb push Hellp.dex /sdcard/Hello.dex
adb root
adb shell
dalvikvm -cp /sdcard/Hello.dex Hello

效果如下，可以看到输出了Hello world!

用Beyond Compare打开，得到如图内容

具体二进制内容如下

6465780A30333500B25DC890C98FC9101D7A1C391CB10CEDF77CD758725E91ACE002000070000000785634120000000000000000400200000E0000007000000007000000A800000003000000C400000001000000E800000004000000F00000000100000010010000B001000030010000760100007E0100008C01000098010000A1010000B8010000CC010000E0010000F4010000F7010000FB01000010020000160200001B0200000300000004000000050000000600000007000000080000000A000000080000000500000000000000090000000500000068010000090000000500000070010000040001000C0000000000000000000000000002000B000000010001000D00000002000000000000000000000001000000020000000000000002000000000000003002000000000000010001000100000024020000040000007010030000000E0003000100020000002902000008000000620000001A0101006E20020010000E000100000003000000010000000600063C696E69743E000C48656C6C6F20776F726C6421000A48656C6C6F2E6A61766100074C48656C6C6F3B00154C6A6176612F696F2F5072696E7453747265616D3B00124C6A6176612F6C616E672F4F626A6563743B00124C6A6176612F6C616E672F537472696E673B00124C6A6176612F6C616E672F53797374656D3B0001560002564C00135B4C6A6176612F6C616E672F537472696E673B00046D61696E00036F757400077072696E746C6E000100070E00030100070E78000000020000818004B0020109C80200000D000000000000000100000000000000010000000E000000700000000200000007000000A80000000300000003000000C40000000400000001000000E80000000500000004000000F0000000060000000100000010010000012000000200000030010000011000000200000068010000022000000E00000076010000032000000200000024020000002000000100000030020000001000000100000040020000

得到了这个Dex文件后我们就可以开始解析了。

Dex 文件结构解析

Dex文件头由下表组成

偏移地址	字节大小	备注
0x00	8	Magic，Dex文件魔数，值为 “dex\n035\0”或”dex\n037\0”
0x08	4	Checksum，使用alder32算法校验文件除去 maigc ，checksum 外余下的所有文件区域
0x0C	20	Signature，使用 SHA-1 算法 hash 除去 magic ,checksum 和 signature 外余下的所有文件区域
0x20	4	File Size，Dex文件大小
0x24	4	Header Size，Dex文件头大小,一般目前是0x70
0x28	4	Endian Tag，大小端标记，值为0x12345678，由于Dex是小端存储，所以Dex文件中保存为0x78563412
0x2C	4	Link Size，链接数据的大小
0x30	4	Link Off ，链接数据的偏移
0x34	4	Map Off，Map Item 的偏移地址，后面细说
0x38	4	String Ids Size ，所有用到的字符串大小
0x3C	4	String Ids Off，所有用到的字符串偏移
0x40	4	Type Ids Size，Dex中类型数据结构的大小
0x44	4	Type Ids Off，Dex中类型数据结构的偏移
0x48	4	Proto Ids Size，Dex中元数据信息数据结构的大小
0x4C	4	Proto Ids Off，Dex中元数据信息数据结构的偏移
0x50	4	Field Ids Size，Dex中字段信息数据结构的大小
0x54	4	Field Ids Off，Dex中字段信息数据结构的偏移
0x58	4	Method Ids Size，Dex中方法信息数据结构的大小
0x5C	4	Method Ids Off，Dex中方法信息数据结构的偏移
0x60	4	Class Defs Size，Dex中类信息数据结构的大小
0x64	4	Class Defs Off，Dex中类信息数据结构的偏移
0x68	4	Data Size，Dex中数据区域的大小
0x6C	4	Data Off，Dex中数据区域的偏移

有了上面这张表，接下来我们对刚才编译出来的Dex文件进行解析。为了便于输出一些内容，这里使用Okio读取Dex文件。引入依赖：

   compile 'com.squareup.okio:okio:1.11.0'

约定全局静态常量File类型的DEX指向刚才的Dex文件

private static final File DEX = new File("path/to/Hello.dex");

读取魔数

魔数占8个字节，读取开始地址的8个字节即为魔数。

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
//8个字节
byte[] bytes = bufferedSource.readByteArray(8);
Buffer buffer = new Buffer();
buffer.write(bytes);
ByteString byteString = buffer.readByteString();
//输出16进制
Logger.e(TAG, "magic hex: %s", byteString.hex());
//输出文本内容
Logger.e(TAG, "magic string: %s", byteString.utf8());

输出结果：

可以看到，我们这个Dex的魔数值为dex\n035\0

读取CheckSum

CheckSum 占4个字节，继魔数后读取4个字节即可。

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
//忽略魔数8个字节
bufferedSource.skip(8);
//4个字节
byte[] bytes = bufferedSource.readByteArray(4);
Buffer buffer = new Buffer();
buffer.write(bytes);
ByteString byteString = buffer.readByteString();
//输出16进制
Logger.e(TAG, "CheckSum hex: %s", byteString.hex());

输出结果：

这个值是如何计算而来的呢，其实就是Dex文件除了魔数和checksum的8+4个字节外的其他字节的adler32的值。计算算法如下：

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);

Adler32 adler32 = new Adler32();
adler32.update(bufferedSource.readByteArray());
long value = adler32.getValue();
Buffer buffer = new Buffer();
buffer.writeIntLe((int) value);
ByteString byteString = buffer.readByteString();
Logger.e(TAG, "checksum hex: %s", byteString.hex());

得到的结果和直接从Dex中读取的Checksum值是一样的。

读取Signature

Signature占的字节数比较大，有20个字节，读完Checksum后读取20个字节即Signature的值。

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
//忽略魔数8个字节
bufferedSource.skip(8);
//忽略CheckSum 4个字节
bufferedSource.skip(4);
//20个字节
byte[] bytes = bufferedSource.readByteArray(20);
Buffer buffer = new Buffer();
buffer.write(bytes);
ByteString byteString = buffer.readByteString();
//输出16进制
Logger.e(TAG, "Signature hex: %s", byteString.hex());

输出结果：

同理，这个值是如何计算而来的呢，其实就是Dex文件除了魔数、checksum和Signature的8+4+4个字节外的其他字节的SHA-1的值。计算算法如下：

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
Buffer buffer = new Buffer();
buffer.writeAll(bufferedSource);
ByteString signature = buffer.sha1();
Logger.e(TAG, "signature hex: %s", signature.hex());

得到的结果和直接从Dex中读取的Signature值是一样的。

读取Dex文件大小

Dex文件大小占4个字节，读完Signature后读取4个字节即为值。

Logger.e(TAG, "file size from file: %s", DEX.length());
BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
int readIntLe = bufferedSource.readIntLe();
Logger.e(TAG, "file size: %s", readIntLe);

Buffer fileBuffer = new Buffer();
fileBuffer.writeIntLe(readIntLe);
ByteString fileByteString = fileBuffer.readByteString();

Logger.e(TAG, "file size hex: %s", fileByteString);

输出结果

可以看到直接读取Dex的File文件大小和直接读取Dex中二进制文件大小值是一样的。

这里需要注意一点，Dex是小端存储，所以读取short，int，long等数据类型，都需要调用readShortLe、readIntLe、readLongLe等方法还原原始数据。

读取Dex文件头大小

Dex文件头大小占4个字节，读完Dex文件大小后读取4个字节即为值。

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
bufferedSource.skip(4);
int readIntLe = bufferedSource.readIntLe();
Logger.e(TAG, "header size: %s", readIntLe);
Buffer buffer = new Buffer();
buffer.writeIntLe(readIntLe);
ByteString byteString = buffer.readByteString();
Logger.e(TAG, "header size hex: %s", byteString);

输出结果：

读取Dex大小端标记

大小端标记位于Dex文件头后的4个字节，值为常量0x12345678，由于是Dex是小端存储，所以文件中存储为0x78563412，可以使用readIntLe方法还原为0x12345678常量。

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
bufferedSource.skip(4);
bufferedSource.skip(4);
Buffer buffer = new Buffer();
//还原小端存储的原始数据
buffer.writeInt(bufferedSource.readIntLe());
ByteString byteString = buffer.readByteString();
Logger.e(TAG, "endian tag hex: %s", byteString);

读取Link Size和Link Off

Link Size和Link Off各占4个字节，紧跟大小端标记后面。

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
int readIntLe = bufferedSource.readIntLe();
Logger.e(TAG, "link size: %s", readIntLe);
Buffer buffer = new Buffer();
buffer.writeInt(readIntLe);
ByteString byteString = buffer.readByteString();
Logger.e(TAG, "link size hex: %s", byteString);

buffer.writeInt(bufferedSource.readIntLe());
byteString = buffer.readByteString();
Logger.e(TAG, "link off hex: %s", byteString);

运行结果：

说明这个Dex没有link段内容。

读取Map off

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
Buffer buffer = new Buffer();
buffer.writeInt(bufferedSource.readIntLe());
ByteString byteString = buffer.readByteString();
Logger.e(TAG, "map off: %s", byteString);

运行结果:

读取剩下的Dex文件头内容

剩下的Dex文件头都是成对存在的，分别是大小和偏移，有了上面的经验，这次我们直接读取整个文件头内容。

BufferedSource buffer = Okio.buffer(Okio.source(DEX));
byte[] bytes = null;
ByteString of = null;

bytes = buffer.readByteArray(8);
of = ByteString.of(bytes);
Logger.e(TAG, "magic: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "checksum: %s", of);

bytes = buffer.readByteArray(20);
of = ByteString.of(bytes);
Logger.e(TAG, "signature: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "file size: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "header size: %s", of);


bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "endian_tag: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "link_size: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "link_off: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "map_off: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "string_ids_size: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "string_ids_off: %s", of);


bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "type_ids_size: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "type_ids_off: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "proto_ids_size: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "proto_ids_off: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "field_ids_size: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "field_ids_off: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "method_ids_size: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "method_ids_off: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "class_defs_size: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "class_defs_off: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "data_size: %s", of);

bytes = buffer.readByteArray(4);
of = ByteString.of(bytes);
Logger.e(TAG, "data_off: %s", of);

输出结果：

解析Map off中的内容

读取到Map off的偏移地址后，该地址指向的是一个map items数据结构区域，从该地址开始的4个字节是Map items的大小n，之后跟着n个map item数据结构，而map item则是由四部分组成，分别是short类型的type，short类型的unuse，int类型的size，int类型offset。而map off中所有的map item，其实是有一部分内容和Dex 文件头中定义的size和off是重复冗余的。

map items可以用以下两张表总结：

名称	数据类型	大小
map items size	int	4字节
map item	n个map item	map item 数据结构大小*(map items size)

map items的数据结构总结为：

名称	数据类型	大小
type	short	2字节
unuse	short	2字节
size	int	4字节
offset	int	4字节

type主要就是Dex文件头中的几个类型，可总结为下表

type值	type对应的数据结构
0x0000	Header
0x0001	String Ids
0x0002	Type Ids
0x0003	Proto Ids
0x0004	Field Id
0x0005	Methos Ids
0x0006	Class Defs
0x1000	Map List
0x1001	Type Lists
0x1002	Annotation Set Ref Lists
0x1003	Annotation Sets
0x2000	Class Datas
0x2001	Codes
0x2002	StringDatas
0x2003	DebugInfos
0x2004	Annotations
0x2005	EncodedArrays
0x2006	AnnotationsDirectories

接下来来读取map items中的数据结构

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
int readIntLe = bufferedSource.readIntLe();
Logger.e(TAG, "map off: %s", readIntLe);


bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(readIntLe);
int mapSize = bufferedSource.readIntLe();
Logger.e(TAG, "map size: %s", mapSize);


for (int i = 0; i < mapSize; i++) {
    short type = bufferedSource.readShortLe();
    short unused = bufferedSource.readShortLe();
    int size = bufferedSource.readIntLe();
    int offset = bufferedSource.readIntLe();
    Logger.e(TAG, "type:0x%04x", type);
    Logger.e(TAG, "unused: %s", unused);
    Logger.e(TAG, "size: %s", size);
    Logger.e(TAG, "offset: %s", offset);
}

输出结果：

解析String Ids区中的内容

这个区域中的数据非常重要，里面存储了整个Dex会用到的字符串资源。该区域存储的是size个字符串索引，真正的字符串存在对应的索引上。读取这n个offset很简单，只需要将string ids size和string ids off读出来，然后从string ids off处开始读取string ids size个int型数据就可以了。

BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);


//获得string size
int size = bufferedSource.readIntLe();
//获得string off
int offset = bufferedSource.readIntLe();


//移动到offset处
bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(offset);

//读取size个offset
List<Integer> list = new ArrayList<>();
Buffer buffer = new Buffer();
for (int i = 0; i < size; i++) {
    int readIntLe = bufferedSource.readIntLe();
    Logger.e(TAG, "offset:0x%08x", readIntLe);
    list.add(readIntLe);
    buffer.writeInt(readIntLe);
}

输出结果

之后我们移动到第一个索引处开始读取真正的string，其数据结构为一个LEB 128编码的int型，之后跟着该int型的就是对应的字符串。因为后面会不断用到这些字符串，这里将其封装成函数。


public HashMap getStringTable() throws IOException {
    BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
    bufferedSource.skip(8);
    bufferedSource.skip(4);
    bufferedSource.skip(20);
    bufferedSource.skip(4);
    bufferedSource.skip(4);
    bufferedSource.skip(4);
    bufferedSource.skip(4);
    bufferedSource.skip(4);
    bufferedSource.skip(4);


    //获得string size
    int size = bufferedSource.readIntLe();
    //获得string off
    int offset = bufferedSource.readIntLe();


    //移动到offset处
    bufferedSource = Okio.buffer(Okio.source(DEX));
    bufferedSource.skip(offset);

    //读取size个offset
    List list = new ArrayList<>();
    Buffer buffer = new Buffer();
    for (int i = 0; i < size; i++) {
        int readIntLe = bufferedSource.readIntLe();
        list.add(readIntLe);
        buffer.writeInt(readIntLe);
    }

    //移动到第一个索引开始解析
    int offset0 = list.get(0);
    bufferedSource = Okio.buffer(Okio.source(DEX));
    bufferedSource.skip(offset0);

    buffer = new Buffer();
    buffer.writeAll(bufferedSource);

    HashMap hashMap = new HashMap();
    for (int i = 0; i < list.size(); i++) {
        //读LEB 128,表示字符串长度
        int leb128 = readUnsignedLeb128(buffer);
        //解析真正的字符串
        String decode = decode(buffer, new char[leb128]);
        hashMap.put(i, decode);
    }
    return hashMap;
}

 public static int readUnsignedLeb128(Buffer in) {
    int result = 0;
    int cur;
    int count = 0;

    do {
        byte b = in.readByte();//读取一个字节
        cur = b & 0xff; //该字节与0b11111111进行与操作,得到的应该还是其本身,这一步操作是否必要? 为了对齐8位？
        result |= (cur & 0x7f) << (count * 7); //该字节与0b0111111进行与操作,去除最高位,然后左移7*count位数,与result进行或运算连接,左移是因为是小端存储
        count++;
    } while (((cur & 0x80) == 0x80) && count < 5);//与0b10000000,最高位是1并且小于5个字节则一直循环

    //10000 0000 是非法的LEB128序列,0用00000000表示
    if ((cur & 0x80) == 0x80) {
        throw new DexException("invalid LEB128 sequence");
    }

    return result;
}

public static String decode(Buffer in, char[] out) throws IOException {
    int s = 0;
    while (true) {
        char a = (char) (in.readByte() & 0xff);
        if (a == 0) {
            //字符串以\0结尾
            return new String(out, 0, s);
        }
        out[s] = a;
        if (a < '\u0080') {
            s++;
        } else if ((a & 0xe0) == 0xc0) {
            int b = in.readByte() & 0xff;
            if ((b & 0xC0) != 0x80) {
                throw new UTFDataFormatException("bad second byte");
            }
            out[s++] = (char) (((a & 0x1F) << 6) | (b & 0x3F));
        } else if ((a & 0xf0) == 0xe0) {
            int b = in.readByte() & 0xff;
            int c = in.readByte() & 0xff;
            if (((b & 0xC0) != 0x80) || ((c & 0xC0) != 0x80)) {
                throw new UTFDataFormatException("bad second or third byte");
            }
            out[s++] = (char) (((a & 0x0F) << 12) | ((b & 0x3F) << 6) | (c & 0x3F));
        } else {
            throw new UTFDataFormatException("bad byte");
        }
    }
}

输出如下：

String data段主要知道对应索引的字符串即可，比如0x0000000d对应的是println字符串。

解析Type ids区中的内容

这个数据结构中存放的数据主要是描述dex中所有的类型，比如类类型，基本类型等信息。type_ids 区索引了 dex 文件里的所有数据类型，包括 class 类型，数组类型和基本类型。我们从文件头中读取到size和off数据后，从off开始的地址读取size个数据即可，而off指向的地址，对应的数据结构是type在string table中的索引值。由于type区域后续还要用到，这里也封装成函数。

 public HashMap<Integer, String> getTypesIds() throws IOException {

        //获得刚才解析的字符串区域的内容
        HashMap<Integer, String> stringTable = getStringTable();

        BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
        bufferedSource.skip(8);
        bufferedSource.skip(4);
        bufferedSource.skip(20);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);

        //获得type索引个数
        int size = bufferedSource.readIntLe();
        //获取type偏移地址
        int offset = bufferedSource.readIntLe();
        //移动到索引处
        bufferedSource = Okio.buffer(Okio.source(DEX));
        bufferedSource.skip(offset);


        HashMap<Integer, String> hashMap = new HashMap<Integer, String>();
        for (int i = 0; i < size; i++) {
            //off开始的地址是int类型的数据结构
            int readIntLe = bufferedSource.readIntLe();
            //从字符串区域中获取type对应的字符串
            String typeString = stringTable.get(readIntLe);
            hashMap.put(i, typeString);
        }
        return hashMap;
    }

输出结果如下：

解析Proto Ids区中的内容

这个区域的数据 method 的函数原型。proto_ids 里的元素为 proto_id_item , 结构如下：

名称	数据类型	大小
shorty_idx	int	4字节
return_type_idx	int	4字节
parameters_off	int	4字节

parameters_off值如果大于0，则表示有参数，执行参数的偏移地址，前面四个自己表示参数个数n，后面紧跟n个short类型的type 索引。

解析代码如下：

 public HashMap<Integer, String> getProtoIds() throws IOException {
        // 获取字符串区域数据
        HashMap<Integer, String> stringTable = getStringTable();
        //获取类型区域数据
        HashMap<Integer, String> typesIds = getTypesIds();
        BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
        bufferedSource.skip(8);
        bufferedSource.skip(4);
        bufferedSource.skip(20);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);

        //读取Proto size
        int size = bufferedSource.readIntLe();
        //读取Proto off
        int offset = bufferedSource.readIntLe();

        //移动到偏移地址
        bufferedSource = Okio.buffer(Okio.source(DEX));
        bufferedSource.skip(offset);

        HashMap<Integer, String> hashMap = new HashMap<Integer, String>();
        for (int i = 0; i < size; i++) {
            //读取shorty_idx
            int shorty_idx = bufferedSource.readIntLe();
            //读取return_type_idx
            int return_type_idx = bufferedSource.readIntLe();
            //读取parameters_off
            int parameters_off = bufferedSource.readIntLe();

            String shortyString = stringTable.get(shorty_idx);
            String returnTypeString = typesIds.get(return_type_idx);

            List<String> parametersString = new ArrayList<>();
            //如果parameters_off大于0，则有参数
            if (parameters_off > 0) {
                BufferedSource source = Okio.buffer(Okio.source(DEX));
                //移动到偏移处
                source.skip(parameters_off);
                //第一个自己是参数个数
                int parameterSize = source.readIntLe();
                for (int j = 0; j < parameterSize; j++) {
                    //循环读取参数类型
                    int typeIds = source.readShortLe();
                    String s = typesIds.get(typeIds);
                    parametersString.add(s);
                }
            }
            String format = String.format("%s %s %s", shortyString, returnTypeString, parametersString);
            hashMap.put(i, format);
        }
        return hashMap;
    }

输出结果：

解析Field ids区中的内容

这个区域存储着Dex中所用Field。它指向的数据结构如下表所示：

名称	数据类型	大小
class_idx	short	2字节
type_idx	short	2字节
name_idx	int	4字节

解析代码如下：

//获取字符串内容
HashMap<Integer, String> stringTable = getStringTable();
//获取type内容
HashMap<Integer, String> typesIds = getTypesIds();
BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);

//field 大小
int size = bufferedSource.readIntLe();
//field 索引
int offset = bufferedSource.readIntLe();
Logger.e(TAG, "field size: %s", size);
Logger.e(TAG, "field offset: %s", offset);

//移动到索引
bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(offset);

//循环读取size个field
for (int i = 0; i < size; i++) {
    //读取class_idx
    int class_idx = bufferedSource.readShortLe();
    //读取type_idx
    int type_idx = bufferedSource.readShortLe();
    //读取name_idx
    int name_idx = bufferedSource.readIntLe();

    Logger.e(TAG, "index %s: %s %s %s", i, class_idx, type_idx, name_idx);

    String classString = typesIds.get(class_idx);
    String typeString = typesIds.get(type_idx);
    String nameString = stringTable.get(name_idx);

    Logger.e(TAG, "string %s: %s %s %s", i, classString, typeString, nameString);
}

输出结果：

解析Method Ids区中的内容

这个区索引了整个Dex中的方法。其指向的数据结构如下表所示

名称	数据类型	大小
class_idx	short	2字节
proto_idx	short	2字节
name_idx	int	4字节

class_idx是type ids的一索引。proto_idx是proto ids的一个索引。name_idx是string区的一个索引。

解析代码如下：

public HashMap<Integer, String> getMethodIds() throws IOException {
        //获取字符串索引表
        HashMap<Integer, String> stringTable = getStringTable();
        //获取类型索引表
        HashMap<Integer, String> typesIds = getTypesIds();
        //获得原型索引表
        HashMap<Integer, String> protoIds = getProtoIds();
        BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
        bufferedSource.skip(8);
        bufferedSource.skip(4);
        bufferedSource.skip(20);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);
        bufferedSource.skip(4);

        //读取方法个数
        int size = bufferedSource.readIntLe();
        //读取偏移地址
        int offset = bufferedSource.readIntLe();

        //移动到偏移地址处
        bufferedSource = Okio.buffer(Okio.source(DEX));
        bufferedSource.skip(offset);

        HashMap<Integer, String> hashMap = new HashMap<Integer, String>();

        for (int i = 0; i < size; i++) {
            int class_idx = bufferedSource.readShortLe();
            int proto_idx = bufferedSource.readShortLe();
            int name_idx = bufferedSource.readIntLe();

            //获得class名
            String classString = typesIds.get(class_idx);
            //获得原型字符串
            String protoString = protoIds.get(proto_idx);
            //获得函数名
            String nameString = stringTable.get(name_idx);

            hashMap.put(i, String.format("%s %s %s", classString, protoString, nameString));
        }

        return hashMap;
    }

输出结果：

解析class_defs区中的内容

这个区非常复杂，简单过一下。

名称	数据类型	大小
class_idx	int	4字节
access_flags	int	4字节
superclass_idx	int	4字节
iterfaces_off	int	4字节
source_file_idx	int	4字节
annotations_off	int	4字节
class_data_off	int	4字节
static_value_off	int	4字节

解析代码如下：

HashMap stringTable = getStringTable();
HashMap typesIds = getTypesIds();
HashMap protoIds = getProtoIds();
HashMap methodIds = getMethodIds();
BufferedSource bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(8);
bufferedSource.skip(4);
bufferedSource.skip(20);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);
bufferedSource.skip(4);

int size = bufferedSource.readIntLe();
int offset = bufferedSource.readIntLe();
Logger.e(TAG, "class def size: %s", size);
Logger.e(TAG, "class def offset: %s", offset);

bufferedSource = Okio.buffer(Okio.source(DEX));
bufferedSource.skip(offset);


for (int i = 0; i < size; i++) {
    int class_idx = bufferedSource.readIntLe();
    int access_flags = bufferedSource.readIntLe();
    int superclass_idx = bufferedSource.readIntLe();
    int iterfaces_off = bufferedSource.readIntLe();
    int source_file_idx = bufferedSource.readIntLe();
    int annotations_off = bufferedSource.readIntLe();
    int class_data_off = bufferedSource.readIntLe();
    int static_value_off = bufferedSource.readIntLe();

    Logger.e(TAG, "class_idx: %s", typesIds.get(class_idx));
    Logger.e(TAG, "access_flags: %s", access_flags);
    Logger.e(TAG, "superclass_idx: %s", typesIds.get(superclass_idx));
    Logger.e(TAG, "iterfaces_off: %s", iterfaces_off);
    Logger.e(TAG, "source_file_idx: %s", stringTable.get(source_file_idx));
    Logger.e(TAG, "annotations_off: %s", annotations_off);
    Logger.e(TAG, "class_data_off: %s", class_data_off);
    Logger.e(TAG, "static_value_off: %s", static_value_off);

    if (iterfaces_off > 0) {
        BufferedSource interfaceBuffer = Okio.buffer(Okio.source(DEX));
        interfaceBuffer.skip(iterfaces_off);
        int interfacesSize = interfaceBuffer.readIntLe();
        Logger.e(TAG, "interfacesSize: %s", interfacesSize);

        for (int j = 0; j < interfacesSize; j++) {
            int interfaceIndex = interfaceBuffer.readIntLe();
            String interfacesString = typesIds.get(interfaceIndex);
            Logger.e(TAG, "interfacesString: %s", interfacesString);
        }

    }

    if (annotations_off > 0) {

    }

    if (class_data_off > 0) {
        BufferedSource classDataBuffer = Okio.buffer(Okio.source(DEX));
        classDataBuffer.skip(class_data_off);
        Buffer buffer = new Buffer();
        buffer.writeAll(classDataBuffer);


        int staticFieldsSize = readUnsignedLeb128(buffer);
        int instanceFieldsSize = readUnsignedLeb128(buffer);
        int directMethodsSize = readUnsignedLeb128(buffer);
        int virtualMethodsSize = readUnsignedLeb128(buffer);

        Logger.e(TAG, "staticFieldsSize: %s", staticFieldsSize);
        Logger.e(TAG, "instanceFieldsSize: %s", instanceFieldsSize);
        Logger.e(TAG, "directMethodsSize: %s", directMethodsSize);
        Logger.e(TAG, "virtualMethodsSize: %s", virtualMethodsSize);


        int fieldIndex = 0;
        for (int j = 0; j < staticFieldsSize; j++) {
            fieldIndex += readUnsignedLeb128(buffer); // field index diff
            int accessFlags = readUnsignedLeb128(buffer);

            Logger.e(TAG, "field index diff: %s", fieldIndex);
            Logger.e(TAG, "accessFlags: %s", accessFlags);

        }


        fieldIndex = 0;
        for (int j = 0; j < instanceFieldsSize; j++) {
            fieldIndex += readUnsignedLeb128(buffer); // field index diff
            int accessFlags = readUnsignedLeb128(buffer);

            Logger.e(TAG, "field index diff: %s", fieldIndex);
            Logger.e(TAG, "accessFlags: %s", accessFlags);

        }

        int methodIndex = 0;
        for (int j = 0; j < directMethodsSize; j++) {
            methodIndex += readUnsignedLeb128(buffer);// method index diff
            int accessFlags = readUnsignedLeb128(buffer);
            int codeOff = readUnsignedLeb128(buffer);

            Logger.e(TAG, "methodIndex: %s", methodIndex);
            Logger.e(TAG, "methodIndexString: %s", methodIds.get(methodIndex));
            Logger.e(TAG, "accessFlags: %s", accessFlags);
            Logger.e(TAG, "codeOff: %s", codeOff);


            BufferedSource codeOffBuffer = Okio.buffer(Okio.source(DEX));
            codeOffBuffer.skip(codeOff);

            short registersSize = codeOffBuffer.readShortLe();
            short insSize = codeOffBuffer.readShortLe();
            short outsSize = codeOffBuffer.readShortLe();
            short triesSize = codeOffBuffer.readShortLe();
            int debugInfoOff = codeOffBuffer.readIntLe();
            int insnsSize = codeOffBuffer.readIntLe();
            byte[] bytes = codeOffBuffer.readByteArray(insnsSize * 2);
            Buffer insnsBuffer = new Buffer();
            insnsBuffer.write(bytes);

            Logger.e(TAG, "registersSize: %s", registersSize);
            Logger.e(TAG, "insSize: %s", insSize);
            Logger.e(TAG, "outsSize: %s", outsSize);
            Logger.e(TAG, "triesSize: %s", triesSize);
            Logger.e(TAG, "debugInfoOff: %s", debugInfoOff);
            Logger.e(TAG, "insnsSize: %s", insnsSize);
            Logger.e(TAG, "insnsBuffer: %s", insnsBuffer);

        }

        methodIndex = 0;
        for (int j = 0; j < virtualMethodsSize; j++) {
            methodIndex += readUnsignedLeb128(buffer);// method index diff
            int accessFlags = readUnsignedLeb128(buffer);
            int codeOff = readUnsignedLeb128(buffer);

            Logger.e(TAG, "methodIndex: %s", methodIndex);
            Logger.e(TAG, "methodIndexString: %s", methodIds.get(methodIndex));
            Logger.e(TAG, "accessFlags: %s", accessFlags);
            Logger.e(TAG, "codeOff: %s", codeOff);

            BufferedSource codeOffBuffer = Okio.buffer(Okio.source(DEX));
            codeOffBuffer.skip(codeOff);
        }
    }


    if (static_value_off > 0) {

    }


}

介绍语

本来想详细写下Dex文件结构的，没想到写着写着，越写越多，越写越不想写，于是这篇文章算半成品吧，胎死腹中了。。。。呵呵！

你可能感兴趣的:(【Android,基础】)

android系统selinux中添加新属性property 辉色投像
1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update iBaoxing github
如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
Python教程：一文了解使用Python处理XPath 旦莫 Python进阶 python 开发语言
目录1.环境准备1.1安装lxml1.2验证安装2.XPath基础2.1什么是XPath？2.2XPath语法2.3示例XML文档3.使用lxml解析XML3.1解析XML文档3.2查看解析结果4.XPath查询4.1基本路径查询4.2使用属性查询4.3查询多个节点5.XPath的高级用法5.1使用逻辑运算符5.2使用函数6.实战案例6.1从网页抓取数据6.1.1安装Requests库6.1.2代
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
从0到500+，我是如何利用自媒体赚钱？一列脚印
运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
数组去重好奇的猫猫猫
整理自js中基础数据结构数组去重问题思考？如何去除数组中重复的项例如数组：[1,3,4,3,5]我们在做去重的时候，一开始想到的肯定是，逐个比较，外面一层循环，内层后一个与前一个一比较，如果是久不将当前这一项放进新的数组，挨个比较完之后返回一个新的去过重复的数组不好的实践方式上述方法效率极低，代码量还多，思考？有没有更好的方法这时候不禁一想当然有了！！！hashtable啊，通过对象的hash办法
关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript 二挡起步 web前端期末大作业 javascript html css 旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
HTML网页设计制作大作业（div+css）云南我的家乡旅游景点带文字滚动二挡起步 web前端期末大作业 web设计网页规划与设计 html css javascript dreamweaver 前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
大伟说成语之唉声叹气求索大伟
＊大伟说成语＊【唉声叹气】叹气：因心里不痛快或不如意而吐出长气，发出声音。因为痛苦、憋闷或感伤而发出叹息的声音。【大伟说】情绪外露，非人类所特有，动物亦有情绪，悲哀和欢乐所表示的情绪亦是不一样的，会嗷嗷大叫也会低吟痛哭。不同的是，人类的情绪更复杂，更多样，更丰富。唉声叹气，可以说是最基础的情绪，因为无奈而举足无措，不知该如何如何化解，只有独自一人慢慢承受，长吁短叹不知如何是好，其实是无能无力的表现
Python快速入门 —— 第三节：类与对象孤华暗香 Python快速入门 python 开发语言
第三节：类与对象目标：了解面向对象编程的基础概念，并学会如何定义类和创建对象。内容：类与对象：定义类：class关键字。类的构造函数：__init__()。类的属性和方法。对象的创建与使用。示例：classStudent:def__init__(self,name,age,major):self.name&#
MongoDB Oplog 窗口喝醉酒的小白 MongoDB 运维
在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
高级 ECharts 技巧：自定义图表主题与样式 SnowMan1993 echarts 信息可视化数据分析
ECharts是一个强大的数据可视化库，提供了多种内置主题和样式，但你也可以根据项目的设计需求，自定义图表的主题与样式。本文将介绍如何使用ECharts自定义图表主题，以提升数据可视化的吸引力和一致性。1.什么是ECharts主题？ECharts的主题是指定义图表样式的配置项，包括颜色、字体、线条样式等。通过预设主题，你可以快速更改图表的整体风格，而自定义主题则允许你在此基础上进行个性化设置。2.
01-Git初识 Meereen Git git
01-Git初识概念：一个免费开源，分布式的代码版本控制系统，帮助开发团队维护代码作用：记录代码内容。切换代码版本，多人开发时高效合并代码内容如何学：个人本机使用：Git基础命令和概念多人共享使用：团队开发同一个项目的代码版本管理Git配置用户信息配置：用户名和邮箱，应用在每次提交代码版本时表明自己的身份命令：查看git版本号git-v配置用户名gitconfig--globaluser.name
ARM驱动学习之基础小知识 JT灬新一 ARM 嵌入式 arm开发学习
ARM驱动学习之基础小知识•sch原理图工程师工作内容–方案–元器件选型–采购（能不能买到，价格）–原理图（涉及到稳定性）•layout画板工程师–layout（封装、布局，布线，log）（涉及到稳定性）–焊接的一部分工作（调试阶段板子的焊接）•驱动工程师–驱动，原理图，layout三部分的交集容易发生矛盾•PCB研发流程介绍–方案，原理图(网表)–layout工程师（gerber文件）–PCB板
Rust基础知识 GRKF15 rust 开发语言后端
1.Rust语言简介1.1基础语法变量声明：let关键字用于声明变量，可以指定或不指定类型，如leta=10;和letmutc=30i32;。函数定义：使用fn关键字定义函数，并指定参数类型及返回类型，如fnadd(i:i32,j:i32)->i32{i+j}。控制流：包括if、else等，控制语句后需要使用;来结束语句。1.2数据类型整数类型：i8、i16、i32、i64、i128，以及无符号的
18、架构-可观测性之聚合度量大树~~ 架构 java python 后端架构
聚合度量聚合度量是指对系统运行时产生的各种指标数据进行收集、聚合和分析，以了解系统的健康状况和性能表现。聚合度量是可观测性的关键组成部分，通过对度量数据的分析，可以及时发现系统中的异常和瓶颈。以下是对聚合度量各个方面的详细解析，并结合具体的数据案例和技术支撑。指标收集收集系统运行时产生的各种指标数据是聚合度量的基础。常见的指标包括CPU使用率、内存使用率、请求处理时间、请求数、错误率等。以下是指标
Python开发常用的三方模块如下：换个网名有点难 python 开发语言
Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
ExpRe[25] bash外的其它shell：zsh和fish tritone ExpRe bash linux ubuntu shell
文章目录zsh基础配置实用特性插件`autojump`语法高亮自动补全fish优点缺点时效性本篇撰写时间为2021.12.15，由于计算机技术日新月异，博客中所有内容都有时效和版本限制，具体做法不一定总行得通，链接可能改动失效，各种软件的用法可能有修改。但是其中透露的思想往往是值得学习的。本篇前置：ExpRe[10]Ubuntu[2]准备神秘软件、备份恢复软件https://www.cnblogs
网络编程基础记得开心一点啊网络
目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
2.2.6 通知类控件 Toast、Menu 常思行
本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
2021-01-24 9ce517ee104c
【打卡素材】《香帅金融学讲义》【标题】公司治理：怎样同床异梦地过下去【日期】2021.1.24【字数】公司本质上是一连串的合约关系。降低合同执行中的各种摩擦是公司正常有效运行的基础。协同各方的利益、制衡各方的权力是关键。为解决利益冲突问题、协同各方利益，进行权力制衡的机制设计就是公司治理机制。001什么是公司治理治理是管理的基础，治理机制越好，权、责、利就越清晰，管理的目标也就会更容易实现。002
如何在心上用功？余超林AIA财富管家
思考：如何在心上用功？学习心得：心-道-德-事的理解心-道-德-事这四部曲，本质上就是一个人的思维智慧的四个层面：事是最底层，这是所有人在这个社会谋求生存的基础，一个人能够把事情彻底做好，保质保量的完成，才会有真正的结果，但是这个层面要获得真正成功很困难，因为会做事的人很多，最终会出现恶性竞争；德是第三层，如果说整个社会做事的竞争激烈程度为100%，那么上升到德上的竞争激烈程度降低为80%，德是一
白骑士的Java教学基础篇 2.5 控制流语句白骑士所长 Java 教学 java 开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
第二十 python基础--语句九樱MOL
目录具体内容1：if语句的使用格式判断语句2：if-else的使用格式3：if-elif-else的使用格式4：if嵌套1：while循环的格式循环语句2：while循环嵌套3：for循环的格式一、判断语句在程序中如果某些条件满足，才能做某件事情，而不满足时不允许做，这就是所谓的判断1.1if语句的使用格式if要判断的条件:条件成立时，要做的事情案例:判断年纪，如果age大于18，输入成年age=
(179)时序收敛---＞(29)时序收敛二九 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛二九（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
(180)时序收敛---＞(30)时序收敛三十 FPGA系统设计指南针 FPGA系统设计(内训)fpga开发时序收敛
1目录（a）FPGA简介（b）Verilog简介（c）时钟简介（d）时序收敛三十（e）结束1FPGA简介（a）FPGA（FieldProgrammableGateArray）是在PAL（可编程阵列逻辑）、GAL（通用阵列逻辑）等可编程器件的基础上进一步发展的产物。它是作为专用集成电路（ASIC）领域中的一种半定制电路而出现的，既解决了定制电路的不足，又克服了原有可编程器件门电路数有限的缺点。（b）
Spring中@Value注解，需要注意的地方无量 spring bean @Value xml
Spring 3以后,支持@Value注解的方式获取properties文件中的配置值，简化了读取配置文件的复杂操作 1、在applicationContext.xml文件(或引用文件中)中配置properties文件 <bean id="appProperty" class="org.springframework.beans.fac
mongoDB 分片开窍的石头 mongodb
mongoDB的分片。要mongos查询数据时候先查询configsvr看数据在那台shard上，configsvr上边放的是metar信息，指的是那条数据在那个片上。由此可以看出mongo在做分片的时候咱们至少要有一个configsvr,和两个以上的shard（片）信息。第一步启动两台以上的mongo服务 &nb
OVER(PARTITION BY)函数用法 0624chenhong oracle
这篇写得很好，引自 http://www.cnblogs.com/lanzi/archive/2010/10/26/1861338.html OVER(PARTITION BY)函数用法 2010年10月26日 OVER(PARTITION BY)函数介绍开窗函数 &nb
Android开发中，ADB server didn't ACK 解决方法一炮送你回车库 Android开发
首先通知：凡是安装360、豌豆荚、腾讯管家的全部卸载，然后再尝试。一直没搞明白这个问题咋出现的，但今天看到一个方法，搞定了！原来是豌豆荚占用了 5037 端口导致。参见原文章：一个豌豆荚引发的血案——关于ADB server didn't ACK的问题简单来讲，首先将Windows任务进程中的豌豆荚干掉，如果还是不行，再继续按下列步骤排查。 &nb
canvas中的像素绘制问题换个号韩国红果果 JavaScript canvas
pixl的绘制，1.如果绘制点正处于相邻像素交叉线，绘制x像素的线宽，则从交叉线分别向前向后绘制x/2个像素，如果x/2是整数，则刚好填满x个像素，如果是小数，则先把整数格填满，再去绘制剩下的小数部分，绘制时，是将小数部分的颜色用来除以一个像素的宽度，颜色会变淡。所以要用整数坐标来画的话（即绘制点正处于相邻像素交叉线时），线宽必须是2的整数倍。否则会出现不饱满的像素。 2.如果绘制点为一个像素的
编码乱码问题灵静志远 java jvm jsp 编码
1、JVM中单个字符占用的字节长度跟编码方式有关，而默认编码方式又跟平台是一一对应的或说平台决定了默认字符编码方式；2、对于单个字符：ISO-8859-1单字节编码，GBK双字节编码，UTF-8三字节编码；因此中文平台(中文平台默认字符集编码GBK)下一个中文字符占2个字节，而英文平台(英文平台默认字符集编码Cp1252(类似于ISO-8859-1))。 3、getBytes()、getByte
java 求几个月后的日期 darkranger calendar getinstance
Date plandate = planDate.toDate(); SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd"); Calendar cal = Calendar.getInstance(); cal.setTime(plandate); // 取得三个月后时间 cal.add(Calendar.M
数据库设计的三大范式（通俗易懂） aijuans 数据库复习
关系数据库中的关系必须满足一定的要求。满足不同程度要求的为不同范式。数据库的设计范式是数据库设计所需要满足的规范。只有理解数据库的设计范式，才能设计出高效率、优雅的数据库，否则可能会设计出错误的数据库. 目前，主要有六种范式：第一范式、第二范式、第三范式、BC范式、第四范式和第五范式。满足最低要求的叫第一范式，简称1NF。在第一范式基础上进一步满足一些要求的为第二范式，简称2NF。其余依此类推。
想学工作流怎么入手 atongyeye jbpm
工作流在工作中变得越来越重要，很多朋友想学工作流却不知如何入手。很多朋友习惯性的这看一点，那了解一点，既不系统，也容易半途而废。好比学武功，最好的办法是有一本武功秘籍。研究明白，则犹如打通任督二脉。系统学习工作流，很重要的一本书《JBPM工作流开发指南》。本人苦苦学习两个月，基本上可以解决大部分流程问题。整理一下学习思路，有兴趣的朋友可以参考下。 1 首先要
Context和SQLiteOpenHelper创建数据库百合不是茶 android Context创建数据库
一直以为安卓数据库的创建就是使用SQLiteOpenHelper创建,但是最近在android的一本书上看到了Context也可以创建数据库,下面我们一起分析这两种方式创建数据库的方式和区别,重点在SQLiteOpenHelper 一:SQLiteOpenHelper创建数据库: 1,SQLi
浅谈group by和distinct bijian1013 oracle 数据库 group by distinct
group by和distinct只了去重意义一样，但是group by应用范围更广泛些，如分组汇总或者从聚合函数里筛选数据等。譬如：统计每id数并且只显示数大于3 select id ,count(id) from ta
vi opertion 征客丶 mac opration vi
进入 command mode （命令行模式）按 esc 键再按 shift + 冒号注：以下命令中带 $ 【在命令行模式下进行】，不带 $ 【在非命令行模式下进行】一、文件操作 1.1、强制退出不保存 $ q! 1.2、保存 $ w 1.3、保存并退出 $ wq 1.4、刷新或重新加载已打开的文件 $ e 二、光标移动 2.1、跳到指定行数字
【Spark十四】深入Spark RDD第三部分RDD基本API bit1129 spark
对于K/V类型的RDD,如下操作是什么含义？ val rdd = sc.parallelize(List(("A",3),("C",6),("A",1),("B",5)) rdd.reduceByKey(_+_).collect reduceByKey在这里的操作，是把
java类加载机制 BlueSkator java 虚拟机
java类加载机制 1.java类加载器的树状结构引导类加载器 ^ | 扩展类加载器 ^ | 系统类加载器 java使用代理模式来完成类加载，java的类加载器也有类似于继承的关系，引导类是最顶层的加载器，它是所有类的根加载器，它负责加载java核心库。当一个类加载器接到装载类到虚拟机的请求时，通常会代理给父类加载器，若已经是根加载器了，就自己完成加载。虚拟机区分一个Cla
动态添加文本框 BreakingBad 文本框
<script> var num=1; function AddInput() { var str=""; str+="<input
读《研磨设计模式》-代码笔记-单例模式 bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ public class Singleton { } /* * 懒汉模式。注意，getInstance如果在多线程环境中调用，需要加上synchronized，否则存在线程不安全问题 */ class LazySingleton
iOS应用打包发布常见问题 chenhbc ios iOS发布 iOS上传 iOS打包
这个月公司安排我一个人做iOS客户端开发，由于急着用，我先发布一个版本，由于第一次发布iOS应用，期间出了不少问题，记录于此。 1、使用Application Loader 发布时报错：Communication error.please use diagnostic mode to check connectivity.you need to have outbound acc
工作流复杂拓扑结构处理新思路 comsci 设计模式工作算法企业应用 OO
我们走的设计路线和国外的产品不太一样，不一样在哪里呢？国外的流程的设计思路是通过事先定义一整套规则(类似XPDL)来约束和控制流程图的复杂度(我对国外的产品了解不够多，仅仅是在有限的了解程度上面提出这样的看法)，从而避免在流程引擎中处理这些复杂的图的问题，而我们却没有通过事先定义这样的复杂的规则来约束和降低用户自定义流程图的灵活性，这样一来，在引擎和流程流转控制这一个层面就会遇到很
oracle 11g新特性Flashback data archive daizj oracle
1. 什么是flashback data archive Flashback data archive是oracle 11g中引入的一个新特性。Flashback archive是一个新的数据库对象，用于存储一个或多表的历史数据。Flashback archive是一个逻辑对象，概念上类似于表空间。实际上flashback archive可以看作是存储一个或多个表的所有事务变化的逻辑空间。
多叉树:2-3-4树 dieslrae 树
平衡树多叉树,每个节点最多有4个子节点和3个数据项,2,3,4的含义是指一个节点可能含有的子节点的个数,效率比红黑树稍差.一般不允许出现重复关键字值.2-3-4树有以下特征: 1、有一个数据项的节点总是有2个子节点(称为2-节点) 2、有两个数据项的节点总是有3个子节点(称为3-节
C语言学习七动态分配 malloc的使用 dcj3sjt126com c language malloc
/* 2013年3月15日15:16:24 malloc 就memory(内存) allocate(分配)的缩写本程序没有实际含义，只是理解使用 */ # include <stdio.h> # include <malloc.h> int main(void) { int i = 5; //分配了4个字节静态分配 int * p
Objective-C编码规范[译] dcj3sjt126com 代码规范
原文链接 : The official raywenderlich.com Objective-C style guide 原文作者 : raywenderlich.com Team 译文出自 : raywenderlich.com Objective-C编码规范译者 : Sam Lau
0.性能优化-目录 frank1234 性能优化
从今天开始笔者陆续发表一些性能测试相关的文章，主要是对自己前段时间学习的总结，由于水平有限，性能测试领域很深，本人理解的也比较浅，欢迎各位大咖批评指正。主要内容包括：一、性能测试指标吞吐量、TPS、响应时间、负载、可扩展性、PV、思考时间 http://frank1234.iteye.com/blog/2180305 二、性能测试策略生产环境相同基准测试预热等 htt
Java父类取得子类传递的泛型参数Class类型 happyqing java 泛型父类子类 Class
import java.lang.reflect.ParameterizedType; import java.lang.reflect.Type; import org.junit.Test; abstract class BaseDao<T> { public void getType() { //Class<E> clazz =
跟我学SpringMVC目录汇总贴、PDF下载、源码下载 jinnianshilongnian springMVC
----广告-------------------------------------------------------------- 网站核心商详页开发掌握Java技术，掌握并发/异步工具使用，熟悉spring、ibatis框架；掌握数据库技术，表设计和索引优化，分库分表/读写分离；了解缓存技术，熟练使用如Redis/Memcached等主流技术；了解Ngin
the HTTP rewrite module requires the PCRE library 流浪鱼 rewrite
./configure: error: the HTTP rewrite module requires the PCRE library. 模块依赖性Nginx需要依赖下面3个包 1. gzip 模块需要 zlib 库 ( 下载: http://www.zlib.net/ ) 2. rewrite 模块需要 pcre 库 ( 下载: http://www.pcre.org/ ) 3. s
第12章 Ajax（中） onestopweb Ajax
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Optimize query with Query Stripping in Web Intelligence blueoxygen BO
http://wiki.sdn.sap.com/wiki/display/BOBJ/Optimize+query+with+Query+Stripping+in+Web+Intelligence and a very straightfoward video http://www.sdn.sap.com/irj/scn/events?rid=/library/uuid/40ec3a0c-936
Java开发者写SQL时常犯的10个错误 tomcat_oracle java sql
1、不用PreparedStatements 　　有意思的是，在JDBC出现了许多年后的今天，这个错误依然出现在博客、论坛和邮件列表中，即便要记住和理解它是一件很简单的事。开发者不使用PreparedStatements的原因可能有如下几个：　　他们对PreparedStatements不了解　　他们认为使用PreparedStatements太慢了　　他们认为写Prepar
世纪互联与结盟有感阿尔萨斯
10月10日，世纪互联与（Foxcon）签约成立合资公司，有感。全球电子制造业巨头（全球500强企业）与世纪互联共同看好IDC、云计算等业务在中国的增长空间，双方迅速果断出手，在资本层面上达成合作，此举体现了全球电子制造业巨头对世纪互联IDC业务的欣赏与信任，另一方面反映出世纪互联目前良好的运营状况与广阔的发展前景。众所周知，精于电子产品制造（世界第一），对于世纪互联而言，能够与结盟

一篇胎死腹中的Android文章——Dex文件结构解析

前言

相关链接

字节序

LEB128格式

构造解析文件

Dex 文件结构解析

读取魔数

读取CheckSum

读取Signature

读取Dex文件大小

读取Dex文件头大小

读取Dex大小端标记

读取Link Size和Link Off

读取Map off

读取剩下的Dex文件头内容

解析Map off中的内容

解析String Ids区中的内容

解析Type ids区中的内容

解析Proto Ids区中的内容

解析Field ids区中的内容

解析Method Ids区中的内容

解析class_defs区中的内容

介绍语

你可能感兴趣的:(【Android,基础】)