一张图搞懂dex
大图这里
当然也可以通过下面的图12 DexFile的文件格式，了解更清楚。
DEX文件详解
什么是dex文件？
如何生成一个dex文件
dex文件的作用
dex文件格式详解
什么是dex文件？
dex文件是Android系统中的一种文件，是一种特殊的数据格式，和APK、jar 等格式文件类似。
能够被DVM识别，加载并执行的文件格式。
简单说就是优化后的android版.exe。每个apk安装包里都有。包含应用程序的全部操作指令以及运行时数据。
相对于PC上的java虚拟机能运行.class；android上的Davlik虚拟机能运行.dex。
当java程序编译成class后，还需要使用dx工具将所有的class文件整合到一个dex文件，目的是其中各个类能够共享数据，在一定程度上降低了冗余，同时也是文件结构更加经凑，实验表明，dex文件是传统jar文件大小的50%左右
图2 apk中的dex文件
为何要研究dex格式？因为dex里面包含了所有app代码，利用反编译工具可以获取java源码。理解并修改dex文件，就能更好的apk破解和防破解。
使用dex文件的最大目的是实现安全管理，但在追求安全的前提下，一定要注意对dex文件实现优化处理。
注意：并不是只有Java才可以生成dex文件，C和C++也可以生成dex文件
如何生成一个dex文件？
通过IDE自动帮我们build生成
手动通过dx命令去生成dex文件
在待测试的class文件目录下（我将TestMain.class放到了F盘根目录下）,执行命令dx --dex --output TestMain.dex TestMain.class,就会生成TestMain.dex文件。
手动运行dex文件在手机
在待测试的dex文件目录下（我将TestMain.class放到了F盘根目录下），通过adb push TestMain.dex /storage/emulated/0命令，然后通过adb shell命令进入手机，后执行dalvikvm -cp /sdcard/TestMain.dex TestMain，就会打印出
Hello World!
如下图3所示（使用AS的终端，没有用Windows的cmd命令）
图3 手动运行dex文件
注意：
环境变量的配置，dex在SDK目录下的build-tools目录下有很多版本，这里可以选择最新版本目录下dx.bat配置到环境变量path路径下；同样，adb命令也同样配置。
运行完dex文件，可以通过exit退出手机，电脑本地盘符
查看dex文件
大图这里
图4 dex文件概貌
通过010Editor工具（图片来自网络）
大图这里
图5 注：图片来自网络
下图6是TestMain.dex通过010Editor工具得到的
大图这里
图6 010Editor 检测TestMain.dex结果
图7是通过010Editor工具检测TestMain.dex得到的 Template Result结果
大图这里
图7 010Editor检测TemplateResult结果
通过dexdump 命令查看（注意）
利用build-tools 下的dexdump 命令查看，dexdump -d -l plain TestMain.dex，得到下面的结果
F:\>dexdump -d -l plain TestMain.dex
Processing 'TestMain.dex'...
Opened 'TestMain.dex', DEX version '035'
Class #0 -
Class descriptor : 'LTestMain;'
Access flags : 0x0001 (PUBLIC)
Superclass : 'Ljava/lang/Object;'
Interfaces -
Static fields -
Instance fields -
#0 : (in LTestMain;)
name : 'mX'
type : 'I'
access : 0x0001 (PUBLIC)
Direct methods -
#0 : (in LTestMain;)
name : '<init>'
type : '()V'
access : 0x10001 (PUBLIC CONSTRUCTOR)
code -
registers : 2
ins : 1
outs : 1
insns size : 7 16-bit code units
00015c: |[00015c] TestMain.<init>:()V
00016c: 7010 0400 0100 |0000: invoke-direct {v1}, Ljava/lang/Object;.<init>:()V // method@0004
000172: 1200 |0003: const/4 v0, #int 0 // #0
000174: 5910 0000 |0004: iput v0, v1, LTestMain;.mX:I // field@0000
000178: 0e00 |0006: return-void
catches : (none)
positions :
0x0000 line=11
0x0003 line=3
0x0006 line=12
locals :
0x0000 - 0x0007 reg=1 this LTestMain;
#1 : (in LTestMain;)
name : 'main'
type : '([Ljava/lang/String;)V'
access : 0x0009 (PUBLIC STATIC)
code -
registers : 4
ins : 1
outs : 2
insns size : 16 16-bit code units
00017c: |[00017c] TestMain.main:([Ljava/lang/String;)V
00018c: 2200 0100 |0000: new-instance v0, LTestMain; // type@0001
000190: 7010 0000 0000 |0002: invoke-direct {v0}, LTestMain;.<init>:()V // method@0000
000196: 6e10 0200 0000 |0005: invoke-virtual {v0}, LTestMain;.test:()V // method@0002
00019c: 6201 0100 |0008: sget-object v1, Ljava/lang/System;.out:Ljava/io/PrintStream; // field@0001
0001a0: 1a02 0100 |000a: const-string v2, "Hello World!" // string@0001
0001a4: 6e20 0300 2100 |000c: invoke-virtual {v1, v2}, Ljava/io/PrintStream;.println:(Ljava/lang/String;)V // method@0003
0001aa: 0e00 |000f: return-void
catches : (none)
positions :
0x0000 line=6
0x0005 line=7
0x0008 line=8
0x000f line=9
locals :
0x0005 - 0x0010 reg=0 testMainObject LTestMain;
0x0000 - 0x0010 reg=3 args [Ljava/lang/String;
Virtual methods -
#0 : (in LTestMain;)
name : 'test'
type : '()V'
access : 0x0001 (PUBLIC)
code -
registers : 1
ins : 1
outs : 0
insns size : 1 16-bit code units
0001ac: |[0001ac] TestMain.test:()V
0001bc: 0e00 |0000: return-void
catches : (none)
positions :
0x0000 line=15
locals :
0x0000 - 0x0001 reg=0 this LTestMain;
source_file_idx : 8 (TestMain.java)
registers:Dalvik 最初目标是运行在以ARM 做CPU 的机器上的，ARM 芯片的一个主要特点是寄存器多。寄存器多的话有好处，就是可以把操作数放在寄存器里，而不是像传统VM 一样放在栈中。自然，操作寄存器是比操作内存（栈嘛，其实就是一块内存区域）快。registers 变量表示该方法运行过程中会使用多少个寄存器。
ins：输入参数对应的个数
outs：此函数内部调用其他函数，需要的参数个数。
insns size：以4 字节为单位，代表该函数字节码的长度（类似Class 文件的code[]数组）
更多内容参考：官网介绍----->Dalvik 可执行文件格式
dex文件的作用
记录整个工程中所有类的信息，记住的整个工程所有类的信息
dex文件格式详解
一种8位字节的二进制流文件
各个数据按顺序紧密的排列，无间隙
整个应用中所有的Java源文件都放在一个dex中
大图这里
图8 dex文件结构
上图中的文件头部分，记录了dex文件的信息，所有字段大致的一个分部；索引区部分，主要包含字符串、类型、方法原型、域、方法的索引；索引区最终又被存储在数据区，其中链接数据区，主要存储动态链接库，so库的信息。
源码：/dalvik/libdex/DexFile.h:DexFile
struct DexFile {
/* directly-mapped "opt" header */
const DexOptHeader* pOptHeader;
/* pointers to directly-mapped structs and arrays in base DEX */
const DexHeader* pHeader;
const DexStringId* pStringIds;
const DexTypeId* pTypeIds;
const DexFieldId* pFieldIds;
const DexMethodId* pMethodIds;
const DexProtoId* pProtoIds;
const DexClassDef* pClassDefs;
const DexLink* pLinkData;
};
具体可查看Android源码官网的关于dex文件结构的详解，如下图9（大图这里）
图9 dex文件结构详解
总结：
数据名称 解释
header dex 文件头部，记录整个dex文件的相关属性
string_ids 字符串数据索引，记录了每个字符串在数据区的偏移量
type_ids
| 数据名称 | 解释 |
|---|---|
| header dex | 文件头部，记录整个dex文件的相关属性 |
| string_ids | 字符串数据索引，记录了每个字符串在数据区的偏移量 |
| type_ids | 类似数据索引，记录了每个类型的字符串索引 |
| proto_ids | 原型数据索引，记录了方法声明的字符串，返回类型字符串，参数列表 |
| field_ids | 字段数据索引，记录了所属类，类型以及方法名 |
| method_ids | 类方法索引，记录方法所属类名，方法声明以及方法名等信息 |
| class_defs | 类定义数据索引，记录指定类各类信息，包括接口，超类，类数据偏移量 |
| data | 数据区，保存了各个类的真是数据 |
| link_data | 连接数据区 |
DEX 文件中会出现的数据类型
类型 含义
u1 等同于uint8_t，表示 1 字节的无符号 数
u2 等同于 uint16_t，表示 2 字节的无符号数
u4 等同于 uint32_t，表示 4 字节的无符号数
u8 等同于 uint64_t，表示 8 字节的无符号数
sleb128 有符号 LEB128，可变长度 1~5 字节
uleb128 无符号 LEB128，可变长度 1~5 字节
uleb128p1 无符号 LEB128 值加1，可变长 1~5 字节
/dalvik/libdex/DexFile.h中定义如下
typedef uint8_t u1;
typedef uint16_t u2;
typedef uint32_t u4;
typedef uint64_t u8;
typedef int8_t s1;
typedef int16_t s2;
typedef int32_t s4;
typedef int64_t s8;
LEB128
LEB128（“Little-Endian Base 128”）表示任意有符号或无符号整数的可变长度编码。该格式借鉴了 DWARF3 规范。在 .dex 文件中，LEB128 仅用于对 32 位数字进行编码。
每个 LEB128 编码值均由 1-5 个字节组成，共同表示一个 32 位的值。每个字节均已设置其最高有效位（序列中的最后一个字节除外，其最高有效位已清除）。每个字节的剩余 7 位均为有效负荷，即第一个字节中有 7 个最低有效位，第二个字节中也是 7 个，依此类推。对于有符号 LEB128 (sleb128)，序列中最后一个字节的最高有效负荷位会进行符号扩展，以生成最终值。在无符号情况 (uleb128) 下，任何未明确表示的位都会被解译为 0。
大图这里
图10 双字节 LEB128 值的按位图
变量 uleb128p1 用于表示一个有符号值，其表示法是编码为 uleb128 的值加 1。这使得编码 -1（或被视为无符号值 0xffffffff）成为一个单字节（但没有任何其他负数），并且该编码在下面这些明确说明的情况下非常实用：所表示的数值必须为非负数或 -1（或 0xffffffff）；不允许任何其他负值（或不太可能需要使用较大的无符号值）。
以下是这类格式的一些示例：
编码序列 As sleb128 As uleb128 As uleb128p1
00 0 0 -1
01 1 1 0
7f -1 127 126
80 7f -128 16256
dex文件头
Dex文件头主要包括校验和以及其他结构的偏移地址和长度信息。
源码位于 /dalvik/libdex/DexFile.h:DexHeader
struct DexHeader {
u1 magic[8]; /* includes version number */
u4 checksum; /* adler32 checksum */
u1 signature[kSHA1DigestLen]; /* SHA-1 hash */
u4 fileSize; /* length of entire file */
u4 headerSize; /* offset to start of next section */
u4 endianTag;
u4 linkSize;
u4 linkOff;
u4 mapOff;
u4 stringIdsSize;
u4 stringIdsOff;
u4 typeIdsSize;
u4 typeIdsOff;
u4 protoIdsSize;
u4 protoIdsOff;
u4 fieldIdsSize;
u4 fieldIdsOff;
u4 methodIdsSize;
u4 methodIdsOff;
u4 classDefsSize;
u4 classDefsOff;
u4 dataSize;
u4 dataOff;
};
具体详解如下图5所示
大图这里
图11 dex文件头信息
各个字段详解摘要
mapOff 字段
指定 DexMapList 结构距离 Dex 头的偏移
DexMapList 结构体：
struct DexMapList
{
u4 size; // DexMapItem 的个数
DexMapItem list[1]; // DexMapItem 结构
};
size：表示接下来有多少个 DexMapItem
list：是一个 DexMapItem 结构体数组
DexMapItem 结构体：
struct DexMapItem
{
u2 type; // kDexType 开头的类型
u2 unused; // 未使用，用于对齐
u4 size; // 指定类型的个数
u4 offset; // 指定类型数据的文件偏移
};
type：一个枚举常量
enum
{
kDexTypeHeaderItem = 0x0000, // 对应 DexHeader
kDexTypeStringIdItem = 0x0001, // 对应 stringIdsSize 与 stringIdsOff 字段
kDexTypeTypeIdItem = 0x0002, // 对应 typeIdsSize 与 typeIdsOff 字段
kDexTypeProtoIdItem = 0x0003, // 对应 protoIdsSize 与 protoIdsOff 字段
kDexTypeFieldIdItem = 0x0004, // 对应 fieldIdsSize 与 fieldIdsOff 字段
kDexTypeMethodIdItem = 0x0005, // 对应 methodIdsSize 与 methodIdsOff 字段
kDexTypeClassDefItem = 0x0006, // 对应 classDefsSize 与 classDefsOff 字段
kDexTypeMapList = 0x1000,
kDexTypeTypeList = 0x1001,
kDexTypeAnnotationSetRefList = 0x1002,
kDexTypeAnnotationSetItem = 0x1003,
kDexTypeClassDataItem = 0x2000,
kDexTypeCodeItem = 0x2001,
kDexTypeStringDataItem = 0x2002,
kDexTypeDebugInfoItem = 0x2003,
kDexTypeAnnotationItem = 0x2004,
kDexTypeEncodeArrayItem = 0x2005,
kDexTypeAnnotationsDirectoryItem = 0x2006
};
size：指定类型的个数
offset：指定类型数据的偏移
DexStringId 结构体（stringIdsSize 与 stringIdsOff 字段）
typedef struct _DexStringId
{
u4 stringDataOff; // 指向 MUTF-8 字符串的偏移
}DexStringId, *PDexStringId;
MUTF-8 编码：
使用 1~3 字节编码长度
大于 16 位的 Unicode 编码 U+10000~U+10FFFF 使用 3 字节来编码
U+0000 采用 2 字节编码
采用空字符 null 作为结尾
第一个字节存放字节个数（不包含自已）
DexTypeId 结构体（typeIdsSize 与 typeIdsOff 字段）
是一个类型结构体
typedef struct _DexTypeId
{
u4 descriptorIdx; // 指向 DexStringId 列表的索引
}DexTypeId, *PDexTypeId;
descriptorIdx：指向 DexStringId 列表的索引，它对应的字符串代表了具体类的类型
DexProtoId 结构体（protoIdsSize 与 protoIdsOff 字段）
是一个方法声明结构体，方法声明 = 返回类型 + 参数列表
typedef struct _DexProtoId
{
u4 shortyIdx; // 方法声明字符串，指向 DexStringId 列表的索引
u4 returnTypeIdx; // 方法返回类型字符串，指向 DexStringId 列表的索引
u4 parametersOff; // 方法的参数列表，指向 DexTypeList 结构体的偏移
}DexProtoId, *PDexProtoId;
shortyIdx：方法声明字符串，方法声明 = 返回类型 + 参数列表
returnTypeIdx：方法返回类型字符串
parametersOff：指向一个 DexTypeList 结构体，存放了方法的参数列表
DexTypeList 结构体：
typedef struct _DexTypeList
{
u4 size; // 接下来 DexTypeItem 的个数
DexTypeItem* list; // DexTypeItem 结构
}DexTypeList, *PDexTypeList;
size：接下来 DexTypeItem 的个数
list：是一个 DexTypeItem 结构体数组
DexTypeItem 结构体：
typedef struct _DexTypeItem
{
u2 typeIdx; // 指向 DexTypeId 列表的索引
}DexTypeItem, *PDexTypeItem;
typeIdx：DexTypeId 列表的索引
DexFieldId 结构体（fieldIdsSize 与 fieldIdsOff 字段）
指明了字段所有的类、字段的类型以及字段名
typedef struct _DexFieldId
{
u2 classIdx; // 类的类型，指向 DexTypeId 列表的索引
u2 typeIdx; // 字段的类型，指向 DexTypeId 列表的索引
u4 nameIdx; // 字段名，指向 DexStringId 列表的索引
}DexFieldId, *PDexFieldId;
classIdx：类的类型
typeIdx：字段的类型
nameIdx：字段名
DexMethodId 结构体（methodIdsSize 与 methodIdsOff 字段）
方法结构体
typedef struct _DexMethodId
{
u2 classIdx; // 类的类型，指向 DexTypeId 列表的索引
u2 protoIdx; // 声明的类型，指向 DexProtoId 列表的索引
u4 nameIdx; // 方法名，指向 DexStringId 列表的索引
}DexMethodId, *PDexMethodId;
classIdx：类的类型
protoIdx：声明的类型
nameIdx：方法名
DexClassDef 结构体（classDefsSize 和 classDefsOff 字段）
类结构体
typedef struct _DexClassDef
{
u4 classIdx; // 类的类型，指向 DexTypeId 列表的索引
u4 accessFlags; // 访问标志
u4 superclassIdx; // 父类类型，指向 DexTypeId 列表的索引
u4 interfacesOff; // 接口，指向 DexTypeList 的偏移，否则为0
u4 sourceFileIdx; // 源文件名，指向 DexStringId 列表的索引
u4 annotationsOff; // 注解，指向 DexAnnotationsDirectoryItem 结构，或者为 0
u4 classDataOff; // 指向 DexClassData 结构的偏移，类的数据部分
u4 staticValuesOff; // 指向 DexEncodedArray 结构的偏移，记录了类中的静态数据，主要是静态方法
}DexClassDef, *PDexClassDef;
classIdx：类的类型，指向 DexTypeId 列表的索引
accessFlags：访问标志，它是以ACC_开头的枚举值
superclassIdx：父类类型，指向 DexTypeId 列表的索引
interfacesOff：接口，指向 DexTypeList 的偏移，如果没有，则为 0
sourceFileIdx：源文件名，指向 DexStringId 列表的索引
annotationsOff：注解，指向 DexAnnotationsDirectoryItem 结构，或者为 0
classDataOff：指向 DexClassData 结构的偏移，类的数据部分
staticValuesOff：指向 DexEncodeArray 结构的偏移，记录了类中的静态数据，没有则为 0
DexClassData 结构体：
typedef struct _DexClassData
{
DexClassDataHeader header; // 指定字段与方法的个数
DexField* staticFields; // 静态字段，DexField 结构
DexField* instanceFields; // 实例字段，DexField 结构
DexMethod* directMethods; // 直接方法，DexMethod 结构
DexMethod* virtualMethods; // 虚方法，DexMethod 结构
}DexClassData, *PDexClassData;
header：DexClassDataHeader 结构体，指定字段与方法的个数
staticFields：静态字段，DexField 结构体数组
instanceFields：实例字段，DexField 结构体数组
directMethods：直接方法，DexMthod 结构体数组
virtualMethods：虚方法，DexMethod 结构体数组
DexClassDataHeader 结构体：
typedef struct _DexClassDataHeader
{
uleb128 staticFieldsSize; // 静态字段个数
uleb128 instanceFieldsSize; // 实例字段个数
uleb128 directMethodsSize; // 直接方法个数
uleb128 virtualMethodsSize; // 虚方法个数
}DexClassDataHeader, *PDexClassDataHeader;
staticFieldsSize：静态字段个数
instanceFieldsSize：实例字段个数
directMethodsSize：直接方法个数
virtualMethodsSize：虚方法个数
DexField 结构体：
typedef struct _DexField
{
uleb128 fieldIdx; // 指向 DexFieldId 的索引
uleb128 accessFlags; // 访问标志
}DexField, *PDexField;
fieldIdx：字段描述，指向 DexFieldId 的索引
accessFlags：访问标志
DexMethod 结构体：
typedef struct _DexMethod
{
uleb128 methodIdx; // 指向 DexMethodId 的索引
uleb128 accessFlags; // 访问标志
uleb128 codeOff; // 指向 DexCode 结构的偏移
}DexMethod, *PDexMethod;
methodIdx：方法描述，指向 DexMethodId 的索引
accessFlags：访问标志
codeOff：指向 DexCode 结构的偏移
DexCode 结构体：
typedef struct _DexCode
{
u2 registersSize; // 使用的寄存器个数
u2 insSize; // 参数个数
u2 outsSize; // 调用其他方法时使用的寄存器个数
u2 triesSize; // Try/Catch 个数
u4 debbugInfoOff; // 指向调试信息的偏移
u4 insnsSize; // 指令集个数，以 2 字节为单位
u2* insns; // 指令集
}DexCode, *PDexCode;
还有一些不太常见的结构体，要用的时候再去看看就行了。Dex 文件的整体结构就这样，就是一个多层索引的结构。
string_ids（字符串索引）
这一区域存储的是Dex文件字符串资源的索引信息，该索引信息是目标字符串在Dex文件数据区所在的真实物理偏移量。
源码位于 /dalvik/libdex/DexFile.h:DexStringId
struct DexStringId {
u4 stringDataOff; /* file offset to string_data_item */
};
stringDataOff记录了目标字符串在Dex文件中的实际偏移量，虚拟机想读取该字符串时，只需将Dex文件在内存中的起始地址加上stringDataOff所指的偏移量，就是该字符串在内存中的实际物理地址。
在Dex文件中，每个每个字符串对应一个DexStringId,大小4B。另外虚拟机通过DexHeader中的String_ids_size获得当前Dex文件中的字符串的总数,通过乘法就可对该索引资源进行访问。
DexLink
struct DexLink {
u1 bleargh;
};
DexFile 在内存中的映射
在Android系统中， java 源文件会被编译为“ .jar ” 格式的dex类型文件， 在代码中称为dexfile 。在加载Class 之前， 必先读取相应的jar文件。通常我们使用read（）函数来读取文件中的内容。但在Dalvik中使用mmap（） 函数。和read（）不同， mmap（）函数会将dex文件映射到内存中，这样通过普通的内存读取操作即可访问dexfile中的内容。
Dexfile的文件格式如图12 所示， 主要有三部分组成：头部，索引，数据。通过头部可知索引的位置和数同，可知数据区的起始位置。其中classDefsOff 指定了ClassDef 在文件的起始位置， dataOff 指定了数据在文件的起始位置， ClassDef 即可理解为Class 的索引。通过读取ClassDef 可获知Class 的基本信息，其中classDataOff 指定了Class 数据在数据区的位置。
大图这里
图12 DexFile的文件格式
在将dexfile文件映射到内存后，会调用dexFileParse（）函数对其分析，分析的结果存放于名为DexFile的数据结构中。DexFile 中的baseAddr指向映射区的起始位置， pClassDefs 指向ClassDefs（即class索引）的起始位置。由于在查找class 时，都是使用class的名字进行查找的，所以为了加快查找速度， 创建了一个hash表。在hash表中对class 名字进行hash，并生成index。这些操作都是在对文件解析时所完成的，这样虽然在加载过程中比较耗时，但是在运行过程中可节省大量查找时间。
解析完后， 接下来开始加载class文件。在此需要将加载类用ClassObject来保存，所以在此需要先分析和ClassObject 相关的几个数据结构。
首先在文件Object.h 中可以看到如下对结构体Object 的定义。（android2.3.7源码）
typedef struct Object {
/* ptr to class object /
ClassObject clazz;
/*
* A word containing either a "thin" lock or a "fat" monitor. See
* the comments in Sync.c for a description of its layout.
*/
u4 lock;
} Object;
通过结构体Object定义了基本类的实现，这里有如下两个变量。
lock ： 对应Obejct 对象中的锁实现，即notify wait 的处理。
clazz ： 是结构体指针，姑且不看结构体内容，这里用了指针的定义。
下面会有更多的结构体定义：
struct DataObject {
Object obj; /* MUST be first item /
/ variable #of u4 slots; u8 uses 2 slots /
u4 instanceData[1];
};
struct StringObject {
Object obj; / MUST be first item /
/ variable #of u4 slots; u8 uses 2 slots */
u4 instanceData[1];
};
我们看到最熟悉的一个词StringObject ，把这个结构体展开后是下面的样子。
struct StringObject {
/* ptr t o class object /
ClassObject clazz ;
/* variable #of u4 slots; u8 uses 2 slots */
u4 lock;
u4 instanceData[1];
};
由此不难发现， 任何对象的内存结构体中第一行都是Object结构体，而这个结构体第一个总是一个ClassObejct，第二个总是lock 。按照C++中的技巧，这些结构体可以当成Object结构体使用，因此所有的类在内存中都具有“对象”的功能，即可以找到一个类（ClassObject），可以有一个锁(lock） 。
StringObject是对String类进行管理的数据对象，ArrayObejct是数据相关的管理。
ClassObject-Class 在加载后的表现形式
在解析完文件后， 接下来需要加载Class 的具体内容。在Dalvik中， 由数据结构ClassObject负责存放加载的信息。如图13所示，加载过程会在内存中alloc几个区域，分别存放directMethods 、virtualMethods 、sfields 、ifields 。这些信息是从dex 文件的数据区中读取的，首先会读取Class 的详细信息，从中获得directMethod 、virtua!Method 、sfield 、ifield 等的信息，然后再读取。在此需要注意， 在C lassObj ect 结构中有个名为super 的成员，通过super成员可以指向它的超类。
大图这里
图13 加载过程
Android dex 文件优化
对Android dex 文件进行优化来说， 需要注意的一点是dex文件的结构是紧凑的，但是我们还是要想方设法地进行提高程序的运行速度，我们就仍然需要对dex文件进行进一步优化。
调整所有字段的字节序（ LITTLE_ENDIAN），和对齐结构中的每一个域来验证dex文件中的所有类，并对一些特定的类进行优化或对方法里的操作码进行优化。优化后的文件大小会有所增加， 大约是原Android dex文件的1～4 倍。
优化时机
优化发生的时机有两个：
对于预置应用来说，可以在系统编译后，生成优化文件，以ODEX 结尾。这样在发布时除APK文件（不包含dex）以外，还有一个相应的Android dex 文件。
对于非预置应用， 包含在APK文件里的dex 文件会在运行时被优化，优化后的文件将被保存在缓存中。
如下图14所示代码调用流程
图14 代码调用流程
每一个Android应用都运行在一个Dalvik虚拟机实例里，而每一个虚拟机实例都是一个独立的进程空间。虚拟机的线程机制，内存分配和管理， Mutex等都是依赖底层操作系统而实现的。
所有Android应用的线程都对应一个Linux线程（可参考----理解Android线程创建流程），虚拟机因而可以更多地依赖操作系统的线程调度和管理机制。不同的应用在不同的进程空间里运行，加之对不同来源的应用都使用不同的Linux用户来运行，可以最大限度地保护应用的安全和独立运行。
Zygote是一个虚拟机进程，同时也是一个虚拟机实例的孵化器，每当系统要求执行一个Android应用程序，Zygote就会孵化出一个子进程来执行该应用程序。这样做的好处显而易见：Zygote进程是在系统启动时产生的，它会完成虚拟机的初始化，库的载，预置类库的加载和初始化等操作，而在系统需要一个新的虚拟机实例时，Zygote通过复制自身，最快速地提供一个虚拟机实例。另外，对于一些只读的系统库，所有虚拟机实例都和Zygote 共享一块内存区域，大大节省了内存开销。
Android 应用所使用的编程语言是Java语言，和Java SE 一样，编译时使用Oracle JDK 将Java源程序编程成标准的Java 字节码文件（. class 文件）。而后通过工具软件DX 把所有的字节码文件转成Android dex 文件（classes . dex） 。最后使用Android 打包工具（aapt）将dex 文件、资源文件以及AndroidManifest.xml 文件（二进制格式）组合成一个应用程序包（APK） 。应用程序包可以被发布到手机上运行。
图15 Android应用编译及运行流程
odex 介绍
odex 是Optimized dex 的简写，也就是优化后的dex 文件。为什么要优化呢？主要还是为了提高Dalvik 虚拟机的运行速度。但是odex 不是简单的、通用的优化，而是在其优化过程中，依赖系统已经编译好的其他模块，简单点说：
从Class 文件到dex 文件是针对Android 平台的一种优化，是一种通用的优化。优化过程中，唯一的输入是Class 文件。
odex 文件就是dex 文件具体在某个系统（不同手机，不同手机的OS，不同版本的OS 等）上的优化。odex 文件的优化依赖系统上的几个核心模块（ 由BOOTCLASSPATH 环境变量给出， 一般是/system/framework/下的jar 包，尤其是core.jar）。odex 的优化就好像是把中那些本来需要在执行过程中做的类校验、调用其他类函数时的解析等工作给提前处理了。
通过利用dexopt得到test.odex，接着利用dexdump得到其内容，最后可以利用Beyond Compare比较这两个文件的差异。
如下图所示
图16 test.dex 和test.odex 差异
图16中，绿色框中是test.dex的内容，红色框中是test.odex的内容，这也是两个文件的差异内容：
test.dex中，TestMain类仅仅是PUBLIC的，但test.odex则增加了VERIFIED和OPTIMIZED两项。VERIFIED是表示该类被校验过了，至于校验什么东西，以后再说。
然后就是一些方法的不同了。优化后的odex文件，一些字节码指令变成了xxx-quick。比如图中最后一句代码对于的字节码中，未优化前invoke-virtual指令表示从method table指定项（图中是0002）里找到目标函数，而优化后的odex使用了invoke-virtual-quick表示从vtable中找到目标函数（图中是000b）。
vtable是虚表的意思，一般在OOP实现中用得很多。vtable一定比methodtable快么？那倒是有可能。我个人猜测：
method表应该是每个dex文件独有的，即它是基于dex文件的。
根据odex文件的生成方法（后面会讲），我觉得vtable恐怕是把dex文件及依赖的类（比如Java基础类，如Object类等）放一起进行了处理，最终得到一张大的vtable。这个odex文件依赖的一些函数都放在vtable中。运行时直接调用指定位置的函数就好，不需要再解析了。以上仅是我的猜测。
注意：
odex文件由dexopt生成，这个工具在SDK里没有，只能由源码生成。odex文件的生成有三种方式：
preopt：即OEM厂商（比如手机厂商），在制作镜像的时候，就把那些需要放到镜像文件里的jar包，APK等预先生成对应的odex文件，然后再把classes.dex文件从jar包和APK中去掉以节省文件体积。
installd：当一个apk安装的时候，PackageManagerService会调用installd的服务，将apk中的class.dex进行处理。当然，这种情况下，APK中的class.dex不会被剔除。
dalvik VM：preopt是厂商的行为，可做可不做。如果没有做的话，dalvik VM在加载一个dex文件的时候，会先生成odex。所以，dalvik VM实际上用得是odex文件。以后我们研究dalvik VM的时候会看到这部分内容。
实际上dex转odex是利用了dalvik vm，里边也会运行dalvik vm的相关方法。
总结：
以标准角度来看，Class文件是由Java VM规范定义的，所以通用性更广。dex或者是odex只不过是规范在Android平台上的一种具体实现罢了，而且dex/odex在很多地方也需要遵守规范。因为dex文件的来源其实还是Class文件。
对于初学者而言，我建议了解Class文件的结构为主。另外，关于dex/odex的文件结构，除非有明确需求（比如要自己修改字节码等），否则以了解原理就可以。而且，将来我们看到dalvik vm的实际代码后，你会发现dex的文件内容还是会转换成代码里的那些你很熟悉的类型，数据结构。比如dex存储字符串是一种优化后的方法，但是到vm代码中，还不是只能用字符串来表示吗？
另外，你还会发现，Class、dex还是odex文件都存储了很多源码中的信息，比如类名、函数名、参数信息、成员变量信息等，而且直接用得是字符串。这和Native的二进制比起来，就容易看懂多了。
参考链接
深入理解Android之Java虚拟机Dalvik
Androidsource之Dalvik 字节码
Androidsource之Dalvik 可执行文件格式（dex文件）
Android安全–Dex文件格式详解
详细描述了dex/odex指令的格式----->Dalvik opcodes
解释器中对 标号 的使用
A deep dive into DEX file format
Dex文件格式详解
android中Dex文件结构详解
Dex文件及Dalvik字节码格式解析
Dex 文件格式详解
Dex文件格式详解
Android关于Dex拆分(MultiDex)技术详解
498
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
