MultiDex工作原理分析和优化方案

动态加载技术(插件化)系列已经坑了有一段时间了，不过UP主我并没有放弃治疗哈，相信在不就的未来就可以看到“系统Api Hook模式”和插件化框架Frontia的更新了。今天要讲的是动态加载技术的亲戚 —— multidex。他们的核心原理之一都是dex文件的加载。

成都创新互联成立于2013年，先为图们等服务建站，图们等地企业，进行企业商务咨询服务。为图们企业网站制作PC+手机+微官网三网同步一站式服务解决您的所有建站问题。

MultiDex是Google为了解决“65535方法数超标”以及“INSTALL_FAILED_DEXOPT”问题而开发的一个Support库，具体如何使用MultiDex现在市面已经有一大堆教程(可以参考给 App 启用 MultiDex 功能)，这里不再赘述。这篇日志主要是配合源码分析MultiDex的工作原理，以及提供一些MultiDex优化的方案。

Dex的工作机制

等等，这个章节讲的不是MultiDex吗，怎么变成Dex了?没错哈，没有Dex，哪来的MultiDex。在Android中，对Dex文件操作对应的类叫做DexFile。在CLASSLOADER 的工作机制中，我们说到：

对于 Java 程序来说，编写程序就是编写类，运行程序也就是运行类(编译得到的class文件)，其中起到关键作用的就是类加载器 ClassLoader。

Android程序的每一个Class都是由ClassLoader#loadClass方法加载进内存的，更准确来说，一个ClassLoader实例会有一个或者多个DexFile实例，调用了ClassLoader#loadClass之后，ClassLoader会通过类名，在自己的DexFile数组里面查找有没有那个DexFile对象里面存在这个类，如果都没有就抛ClassNotFound异常。ClassLoader通过调用DexFile的一个叫defineClass的Native方法去加载指定的类，这点与JVM略有不同，后者是直接调用ClassLoader#defineCLass方法，反正最后实际加载类的方法都叫defineClass就没错了。

创建DexFile对象

首先来看看造DexFile对象的构方法。

 
 
 
 
    
  
  
  
  
  1. public final class DexFile { 
    2.   
  
  
  
  2.     private int mCookie; 
    3.   
  
  
  
  3.     private final String mFileName; 
    4.   
  
  
  
  4.     ... 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.     public DexFile(File file) throws IOException { 
    7.   
  
  
  
  7.         this(file.getPath()); 
    8.   
  
  
  
  8.     } 
    9.   
  
  
  
  9.     
    10.   
  
  
  
  10.     public DexFile(String fileName) throws IOException { 
    11.   
  
  
  
  11.         mCookie = openDexFile(fileName, null, 0); 
    12.   
  
  
  
  12.         mFileName = fileName; 
    13.   
  
  
  
  13.         guard.open("close"); 
    14.   
  
  
  
  14.     } 
    15.   
  
  
  
  15.     
    16.   
  
  
  
  16.     private DexFile(String sourceName, String outputName, int flags) throws IOException { 
    17.   
  
  
  
  17.         mCookie = openDexFile(sourceName, outputName, flags); 
    18.   
  
  
  
  18.         mFileName = sourceName; 
    19.   
  
  
  
  19.         guard.open("close"); 
    20.   
  
  
  
  20.     } 
    21.   
  
  
  
  21.  
    22.   
  
  
  
  22.     static public DexFile loadDex(String sourcePathName, String outputPathName, 
    23.   
  
  
  
  23.         int flags) throws IOException { 
    24.   
  
  
  
  24.         return new DexFile(sourcePathName, outputPathName, flags); 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26.    
    27.   
  
  
  
  27.     public Class loadClass(String name, ClassLoader loader) { 
    28.   
  
  
  
  28.         String slashName = name.replace('.', '/'); 
    29.   
  
  
  
  29.         return loadClassBinaryName(slashName, loader); 
    30.   
  
  
  
  30.     } 
    31.   
  
  
  
  31.    
    32.   
  
  
  
  32.     public Class loadClassBinaryName(String name, ClassLoader loader) { 
    33.   
  
  
  
  33.         return defineClass(name, loader, mCookie); 
    34.   
  
  
  
  34.     } 
    35.   
  
  
  
  35.     private native static Class defineClass(String name, ClassLoader loader, int cookie); 
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37.     native private static int openDexFile(String sourceName, String outputName, 
    38.   
  
  
  
  38.         int flags) throws IOException; 
    39.   
  
  
  
  39.  
    40.   
  
  
  
  40.     native private static int openDexFile(byte[] fileContents) 
    41.   
  
  
  
  41.     ... 
    42.   
  
  
  
  42. }  
    43.

通过以前分析过的源码，我们知道ClassLoader主要是通过DexFile.loadDex这个静态方法来创建它需要的DexFile实例的，这里创建DexFile的时候，保存了Dex文件的文件路径mFileName，同时调用了openDexFile的Native方法打开Dex文件并返回了一个mCookie的整型变量(我不知道这个干啥用的，我猜它是一个C++用的资源句柄，用于Native层访问具体的Dex文件)。在Native层的openDexFile方法里，主要做了检查当前创建来的Dex文件是否是有效的Dex文件，还是是一个带有Dex文件的压缩包，还是一个无效的Dex文件。

加载Dex文件里的类

加载类的时候，ClassLoader又是通过DexFile#loadClass这个方法来完成的，这个方法里调用了defineClass这个Native方法，看来DexFile才是加载Class的具体API，加载Dex文件和加载具体Class都是通过Native方法完成，ClassLoader有点名不副实啊。

MultiDex的工作机制

当一个Dex文件太肥的时候(方法数目太多、文件太大)，在打包Apk文件的时候就会出问题，就算打包的时候不出问题，在Android 5.0以下设备上安装或运行Apk也会出问题(具体原因可以参考给 App 启用 MultiDex 功能)。既然一个Dex文件不行的话，那就把这个硕大的Dex文件拆分成若干个小的Dex文件，刚好一个ClassLoader可以有多个DexFile，这就是MultiDex的基本设计思路。

工作流程

MultiDex的工作流程具体分为两个部分，一个部分是打包构建Apk的时候，将Dex文件拆分成若干个小的Dex文件，这个Android Studio已经帮我们做了(设置 “multiDexEnabled true”)，另一部分就是在启动Apk的时候，同时加载多个Dex文件(具体是加载Dex文件优化后的Odex文件，不过文件名还是.dex)，这一部分工作从Android 5.0开始系统已经帮我们做了，但是在Android 5.0以前还是需要通过MultiDex Support库来支持(MultiDex.install(Context))。

所以我们需要关心的是第二部分，这个过程的简单示意流程图如下。 

 

 

(图中红色部分为耗时比较大的地方)

源码分析

现在官方已经部署的MultiDex Support版本是com.android.support:multidex:1.0.1，但是现在仓库的master分支已经有了许多新的提交(其中最明显的区别是加入了FileLock来控制多进程同步问题)，所以这里分析的源码都是最新的master分支上的。

MultiDex Support的入口是MultiDex.install(Context)，先从这里入手吧。(这次我把具体的分析都写在代码的注释了，这样看是不是更简洁明了些?)

 
 
 
 
    
  
  
  
  
  1. public static void install(Context context) { 
    2.   
  
  
  
  2.         Log.i(TAG, "install"); 
    3.   
  
  
  
  3.          
    4.   
  
  
  
  4.         // 1. 判读是否需要执行MultiDex。 
    5.   
  
  
  
  5.         if (IS_VM_MULTIDEX_CAPABLE) { 
    6.   
  
  
  
  6.             Log.i(TAG, "VM has multidex support, MultiDex support library is disabled."); 
    7.   
  
  
  
  7.             return; 
    8.   
  
  
  
  8.         } 
    9.   
  
  
  
  9.         if (Build.VERSION.SDK_INT < MIN_SDK_VERSION) { 
    10.   
  
  
  
  10.             throw new RuntimeException("Multi dex installation failed. SDK " + Build.VERSION.SDK_INT 
    11.   
  
  
  
  11.                     + " is unsupported. Min SDK version is " + MIN_SDK_VERSION + "."); 
    12.   
  
  
  
  12.         } 
    13.   
  
  
  
  13.         try { 
    14.   
  
  
  
  14.             ApplicationInfo applicationInfo = getApplicationInfo(context); 
    15.   
  
  
  
  15.             if (applicationInfo == null) { 
    16.   
  
  
  
  16.                 // Looks like running on a test Context, so just return without patching. 
    17.   
  
  
  
  17.                 return; 
    18.   
  
  
  
  18.             } 
    19.   
  
  
  
  19.              
    20.   
  
  
  
  20.             // 2. 如果这个方法已经调用过一次，就不能再调用了。 
    21.   
  
  
  
  21.             synchronized (installedApk) { 
    22.   
  
  
  
  22.                 String apkPath = applicationInfo.sourceDir; 
    23.   
  
  
  
  23.                 if (installedApk.contains(apkPath)) { 
    24.   
  
  
  
  24.                     return; 
    25.   
  
  
  
  25.                 } 
    26.   
  
  
  
  26.                 installedApk.add(apkPath); 
    27.   
  
  
  
  27.                  
    28.   
  
  
  
  28.                 // 3. 如果当前Android版本已经自身支持了MultiDex，依然可以执行MultiDex操作， 
    29.   
  
  
  
  29.                 // 但是会有警告。 
    30.   
  
  
  
  30.                 if (Build.VERSION.SDK_INT > MAX_SUPPORTED_SDK_VERSION) { 
    31.   
  
  
  
  31.                     Log.w(TAG, "MultiDex is not guaranteed to work in SDK version " 
    32.   
  
  
  
  32.                             + Build.VERSION.SDK_INT + ": SDK version higher than " 
    33.   
  
  
  
  33.                             + MAX_SUPPORTED_SDK_VERSION + " should be backed by " 
    34.   
  
  
  
  34.                             + "runtime with built-in multidex capabilty but it's not the " 
    35.   
  
  
  
  35.                             + "case here: java.vm.version=\"" 
    36.   
  
  
  
  36.                             + System.getProperty("java.vm.version") + "\""); 
    37.   
  
  
  
  37.                 } 
    38.   
  
  
  
  38.          
    39.   
  
  
  
  39.                 // 4. 获取当前的ClassLoader实例，后面要做的工作，就是把其他dex文件加载后， 
    40.   
  
  
  
  40.                 // 把其DexFile对象添加到这个ClassLoader实例里就完事了。 
    41.   
  
  
  
  41.                 ClassLoader loader; 
    42.   
  
  
  
  42.                 try { 
    43.   
  
  
  
  43.                     loader = context.getClassLoader(); 
    44.   
  
  
  
  44.                 } catch (RuntimeException e) { 
    45.   
  
  
  
  45.                     Log.w(TAG, "Failure while trying to obtain Context class loader. " + 
    46.   
  
  
  
  46.                             "Must be running in test mode. Skip patching.", e); 
    47.   
  
  
  
  47.                     return; 
    48.   
  
  
  
  48.                 } 
    49.   
  
  
  
  49.                 if (loader == null) { 
    50.   
  
  
  
  50.                     Log.e(TAG, 
    51.   
  
  
  
  51.                             "Context class loader is null. Must be running in test mode. " 
    52.   
  
  
  
  52.                             + "Skip patching."); 
    53.   
  
  
  
  53.                     return; 
    54.   
  
  
  
  54.                 } 
    55.   
  
  
  
  55.                 try { 
    56.   
  
  
  
  56.                   // 5. 清除旧的dex文件，注意这里不是清除上次加载的dex文件缓存。 
    57.   
  
  
  
  57.                   // 获取dex缓存目录是，会优先获取/data/data//code-cache作为缓存目录。 
    58.   
  
  
  
  58.                   // 如果获取失败，则使用/data/data//files/code-cache目录。 
    59.   
  
  
  
  59.                   // 这里清除的是第二个目录。 
    60.   
  
  
  
  60.                   clearOldDexDir(context); 
    61.   
  
  
  
  61.                 } catch (Throwable t) { 
    62.   
  
  
  
  62.                   Log.w(TAG, "Something went wrong when trying to clear old MultiDex extraction, " 
    63.   
  
  
  
  63.                       + "continuing without cleaning.", t); 
    64.   
  
  
  
  64.                 } 
    65.   
  
  
  
  65.                  
    66.   
  
  
  
  66.                 // 6. 获取缓存目录（/data/data//code-cache）。 
    67.   
  
  
  
  67.                 File dexDir = getDexDir(context, applicationInfo); 
    68.   
  
  
  
  68.                  
    69.   
  
  
  
  69.                 // 7. 加载缓存文件（如果有）。 
    70.   
  
  
  
  70.                 List files = MultiDexExtractor.load(context, applicationInfo, dexDir, false); 
    71.   
  
  
  
  71.                  
    72.   
  
  
  
  72.                 // 8. 检查缓存的dex是否安全 
    73.   
  
  
  
  73.                 if (checkValidZipFiles(files)) { 
    74.   
  
  
  
  74.                     // 9. 安装缓存的dex 
    75.   
  
  
  
  75.                     installSecondaryDexes(loader, dexDir, files); 
    76.   
  
  
  
  76.                 } else { 
    77.   
  
  
  
  77.                     // 9. 从apk压缩包里面提取dex文件 
    78.   
  
  
  
  78.                     Log.w(TAG, "Files were not valid zip files.  Forcing a reload."); 
    79.   
  
  
  
  79.                     files = MultiDexExtractor.load(context, applicationInfo, dexDir, true); 
    80.   
  
  
  
  80.                     if (checkValidZipFiles(files)) { 
    81.   
  
  
  
  81.                         // 10. 安装提取的dex 
    82.   
  
  
  
  82.                         installSecondaryDexes(loader, dexDir, files); 
    83.   
  
  
  
  83.                     } else { 
    84.   
  
  
  
  84.                         throw new RuntimeException("Zip files were not valid."); 
    85.   
  
  
  
  85.                     } 
    86.   
  
  
  
  86.                 } 
    87.   
  
  
  
  87.             } 
    88.   
  
  
  
  88.         } catch (Exception e) { 
    89.   
  
  
  
  89.             Log.e(TAG, "Multidex installation failure", e); 
    90.   
  
  
  
  90.             throw new RuntimeException("Multi dex installation failed (" + e.getMessage() + ")."); 
    91.   
  
  
  
  91.         } 
    92.   
  
  
  
  92.         Log.i(TAG, "install done"); 
    93.   
  
  
  
  93.     }  
    94.

具体代码的分析已经在上面代码的注释里给出了，从这里我们也可以看出，整个MultiDex.install(Context)的过程中，关键的步骤就是MultiDexExtractor#load方法和MultiDex#installSecondaryDexes方法。

(这部分是题外话)其中有个MultiDex#clearOldDexDir(Context)方法，这个方法的作用是删除/data/data//files/code-cache，一开始我以为这个方法是删除上一次执行MultiDex后的缓存文件，不过这明显不对，不可能每次MultiDex都重新解压dex文件一边，这样每次启动会很耗时，只有第一次冷启动的时候才需要解压dex文件。后来我又想是不是以前旧版的MultiDex曾经把缓存文件放在这个目录里，现在新版本只是清除以前旧版的遗留文件?但是我找遍了整个MultiDex Repo的提交也没有见过类似的旧版本代码。后面我仔细看MultiDex#getDexDir这个方法才发现，原来MultiDex在获取dex缓存目录是，会优先获取/data/data//code-cache作为缓存目录，如果获取失败，则使用/data/data//files/code-cache目录，而后者的缓存文件会在每次App重新启动的时候被清除。感觉MultiDex获取缓存目录的逻辑不是很严谨，而获取缓存目录失败也是MultiDex工作工程中少数有重试机制的地方，看来MultiDex真的是一个临时的兼容方案，Google也许并不打算认真处理这些历史的黑锅。

接下来再看看MultiDexExtractor#load这个方法。 

 
 
 
 
    
  
  
  
  
  1. static List load(Context context, ApplicationInfo applicationInfo, File dexDir, 
    2.   
  
  
  
  2.             boolean forceReload) throws IOException { 
    3.   
  
  
  
  3.         Log.i(TAG, "MultiDexExtractor.load(" + applicationInfo.sourceDir + ", " + forceReload + ")"); 
    4.   
  
  
  
  4.         final File sourceApk = new File(applicationInfo.sourceDir); 
    5.   
  
  
  
  5.          
    6.   
  
  
  
  6.         // 1. 获取当前Apk文件的crc值。 
    7.   
  
  
  
  7.         long currentCrc = getZipCrc(sourceApk); 
    8.   
  
  
  
  8.         // Validity check and extraction must be done only while the lock file has been taken. 
    9.   
  
  
  
  9.         File lockFile = new File(dexDir, LOCK_FILENAME); 
    10.   
  
  
  
  10.         RandomAccessFile lockRaf = new RandomAccessFile(lockFile, "rw"); 
    11.   
  
  
  
  11.         FileChannel lockChannel = null; 
    12.   
  
  
  
  12.         FileLock cacheLock = null; 
    13.   
  
  
  
  13.         List files; 
    14.   
  
  
  
  14.         IOException releaseLockException = null; 
    15.   
  
  
  
  15.         try { 
    16.   
  
  
  
  16.             lockChannel = lockRaf.getChannel(); 
    17.   
  
  
  
  17.             Log.i(TAG, "Blocking on lock " + lockFile.getPath()); 
    18.   
  
  
  
  18.              
    19.   
  
  
  
  19.             // 2. 加上文件锁，防止多进程冲突。 
    20.   
  
  
  
  20.             cacheLock = lockChannel.lock(); 
    21.   
  
  
  
  21.             Log.i(TAG, lockFile.getPath() + " locked"); 
    22.   
  
  
  
  22.              
    23.   
  
  
  
  23.             // 3. 先判断是否强制重新解压，这里第一次会优先使用已解压过的dex文件，如果加载失败就强制重新解压。 
    24.   
  
  
  
  24.             // 此外，通过crc和文件修改时间，判断如果Apk文件已经被修改（覆盖安装），就会跳过缓存重新解压dex文件。 
    25.   
  
  
  
  25.             if (!forceReload && !isModified(context, sourceApk, currentCrc)) { 
    26.   
  
  
  
  26.                 try { 
    27.   
  
  
  
  27.                  
    28.   
  
  
  
  28.                     // 4. 加载缓存的dex文件 
    29.   
  
  
  
  29.                     files = loadExistingExtractions(context, sourceApk, dexDir); 
    30.   
  
  
  
  30.                 } catch (IOException ioe) { 
    31.   
  
  
  
  31.                     Log.w(TAG, "Failed to reload existing extracted secondary dex files," 
    32.   
  
  
  
  32.                             + " falling back to fresh extraction", ioe); 
    33.   
  
  
  
  33.                      
    34.   
  
  
  
  34.                     // 5. 加载失败的话重新解压，并保存解压出来的dex文件的信息。 
    35.   
  
  
  
  35.                     files = performExtractions(sourceApk, dexDir); 
    36.   
  
  
  
  36.                     putStoredApkInfo(context, 
    37.   
  
  
  
  37.                             getTimeStamp(sourceApk), currentCrc, files.size() + 1); 
    38.   
  
  
  
  38.                 } 
    39.   
  
  
  
  39.             } else { 
    40.   
  
  
  
  40.                 // 4. 重新解压，并保存解压出来的dex文件的信息。 
    41.   
  
  
  
  41.                 Log.i(TAG, "Detected that extraction must be performed."); 
    42.   
  
  
  
  42.                 files = performExtractions(sourceApk, dexDir); 
    43.   
  
  
  
  43.                 putStoredApkInfo(context, getTimeStamp(sourceApk), currentCrc, files.size() + 1); 
    44.   
  
  
  
  44.             } 
    45.   
  
  
  
  45.         } finally { 
    46.   
  
  
  
  46.             if (cacheLock != null) { 
    47.   
  
  
  
  47.                 try { 
    48.   
  
  
  
  48.                     cacheLock.release(); 
    49.   
  
  
  
  49.                 } catch (IOException e) { 
    50.   
  
  
  
  50.                     Log.e(TAG, "Failed to release lock on " + lockFile.getPath()); 
    51.   
  
  
  
  51.                     // Exception while releasing the lock is bad, we want to report it, but not at 
    52.   
  
  
  
  52.                     // the price of overriding any already pending exception. 
    53.   
  
  
  
  53.                     releaseLockException = e; 
    54.   
  
  
  
  54.                 } 
    55.   
  
  
  
  55.             } 
    56.   
  
  
  
  56.             if (lockChannel != null) { 
    57.   
  
  
  
  57.                 closeQuietly(lockChannel); 
    58.   
  
  
  
  58.             } 
    59.   
  
  
  
  59.             closeQuietly(lockRaf); 
    60.   
  
  
  
  60.         } 
    61.   
  
  
  
  61.         if (releaseLockException != null) { 
    62.   
  
  
  
  62.             throw releaseLockException; 
    63.   
  
  
  
  63.         } 
    64.   
  
  
  
  64.         Log.i(TAG, "load found " + files.size() + " secondary dex files"); 
    65.   
  
  
  
  65.         return files; 
    66.   
  
  
  
  66.     }  
    67.

这个过程主要是获取可以安装的dex文件列表，可以是上次解压出来的缓存文件，也可以是重新从Apk包里面提取出来的。需要注意的时，如果是重新解压，这里会有明显的耗时，而且解压出来的dex文件，会被压缩成.zip压缩包，压缩的过程也会有明显的耗时(这里压缩dex文件可能是问了节省空间)。

如果dex文件是重新解压出来的，则会保存dex文件的信息，包括解压的apk文件的crc值、修改时间以及dex文件的数目，以便下一次启动直接使用已经解压过的dex缓存文件，而不是每一次都重新解压。

需要特别提到的是，里面的FileLock是最新的master分支里面新加进去的功能，现在最新的1.0.1版本里面是没有的。

无论是通过使用缓存的dex文件，还是重新从apk中解压dex文件，获取dex文件列表后，下一步就是安装(或者说加载)这些dex文件了。最后的工作在MultiDex#installSecondaryDexes这个方法里面。

 
 
 
 
    
  
  
  
  
  1. private static void installSecondaryDexes(ClassLoader loader, File dexDir, List files) 
    2.   
  
  
  
  2.             throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, 
    3.   
  
  
  
  3.             InvocationTargetException, NoSuchMethodException, IOException { 
    4.   
  
  
  
  4.         if (!files.isEmpty()) { 
    5.   
  
  
  
  5.             if (Build.VERSION.SDK_INT >= 19) { 
    6.   
  
  
  
  6.                 V19.install(loader, files, dexDir); 
    7.   
  
  
  
  7.             } else if (Build.VERSION.SDK_INT >= 14) { 
    8.   
  
  
  
  8.                 V14.install(loader, files, dexDir); 
    9.   
  
  
  
  9.             } else { 
    10.   
  
  
  
  10.                 V4.install(loader, files); 
    11.   
  
  
  
  11.             } 
    12.   
  
  
  
  12.         } 
    13.   
  
  
  
  13.     }  
    14.

因为在不同的SDK版本上，ClassLoader(更准确来说是DexClassLoader)加载dex文件的方式有所不同，所以这里做了V4/V14/V19的兼容(Magic Code)。

Build.VERSION.SDK_INT < 14 

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.      * Installer for platform versions 4 to 13. 
    3.   
  
  
  
  3.      */ 
    4.   
  
  
  
  4.     private static final class V4 { 
    5.   
  
  
  
  5.         private static void install(ClassLoader loader, List additionalClassPathEntries) 
    6.   
  
  
  
  6.                         throws IllegalArgumentException, IllegalAccessException, 
    7.   
  
  
  
  7.                         NoSuchFieldException, IOException { 
    8.   
  
  
  
  8.              
    9.   
  
  
  
  9.             int extraSize = additionalClassPathEntries.size(); 
    10.   
  
  
  
  10.             Field pathField = findField(loader, "path"); 
    11.   
  
  
  
  11.             StringBuilder path = new StringBuilder((String) pathField.get(loader)); 
    12.   
  
  
  
  12.             String[] extraPaths = new String[extraSize]; 
    13.   
  
  
  
  13.             File[] extraFiles = new File[extraSize]; 
    14.   
  
  
  
  14.             ZipFile[] extraZips = new ZipFile[extraSize]; 
    15.   
  
  
  
  15.             DexFile[] extraDexs = new DexFile[extraSize]; 
    16.   
  
  
  
  16.             for (ListIterator iterator = additionalClassPathEntries.listIterator(); 
    17.   
  
  
  
  17.                     iterator.hasNext();) { 
    18.   
  
  
  
  18.                 File additionalEntry = iterator.next(); 
    19.   
  
  
  
  19.                 String entryPath = additionalEntry.getAbsolutePath(); 
    20.   
  
  
  
  20.                 path.append(':').append(entryPath); 
    21.   
  
  
  
  21.                 int index = iterator.previousIndex(); 
    22.   
  
  
  
  22.                 extraPaths[index] = entryPath; 
    23.   
  
  
  
  23.                 extraFiles[index] = additionalEntry; 
    24.   
  
  
  
  24.                 extraZips[index] = new ZipFile(additionalEntry); 
    25.   
  
  
  
  25.                 extraDexs[index] = DexFile.loadDex(entryPath, entryPath + ".dex", 0); 
    26.   
  
  
  
  26.             } 
    27.   
  
  
  
  27.              
    28.   
  
  
  
  28.             // 这个版本是最简单的。 
    29.   
  
  
  
  29.             // 只需要创建DexFile对象后，使用反射的方法分别扩展ClassLoader实例的以下字段即可。 
    30.   
  
  
  
  30.             pathField.set(loader, path.toString()); 
    31.   
  
  
  
  31.             expandFieldArray(loader, "mPaths", extraPaths); 
    32.   
  
  
  
  32.             expandFieldArray(loader, "mFiles", extraFiles); 
    33.   
  
  
  
  33.             expandFieldArray(loader, "mZips", extraZips); 
    34.   
  
  
  
  34.             expandFieldArray(loader, "mDexs", extraDexs); 
    35.   
  
  
  
  35.         } 
    36.   
  
  
  
  36.     }  
    37.

14 <= Build.VERSION.SDK_INT < 19 

 
 
 
 
    
  
  
  
  
  1. /** 
    2.   
  
  
  
  2.      * Installer for platform versions 14, 15, 16, 17 and 18. 
    3.   
  
  
  
  3.      */ 
    4.   
  
  
  
  4.     private static final class V14 { 
    5.   
  
  
  
  5.         private static void install(ClassLoader loader, List additionalClassPathEntries, 
    6.   
  
  
  
  6.                 File optimizedDirectory) 
    7.   
  
  
  
  7.                         throws IllegalArgumentException, IllegalAccessException, 
    8.   
  
  
  
  8.                         NoSuchFieldException, InvocationTargetException, NoSuchMethodException { 
    9.   
  
  
  
  9.              
    10.   
  
  
  
  10.             // 扩展ClassLoader实例的"pathList"字段。 
    11.   
  
  
  
  11.             Field pathListField = findField(loader, "pathList"); 
    12.   
  
  
  
  12.             Object dexPathList = pathListField.get(loader); 
    13.   
  
  
  
  13.             expandFieldArray(dexPathList, "dexElements", makeDexElements(dexPathList, 
    14.   
  
  
  
  14.                     new ArrayList(additionalClassPathEntries), optimizedDirectory)); 
    15.   
  
  
  
  15.         } 
    16.   
  
  
  
  16.        
    17.   
  
  
  
  17.         private static Object[] makeDexElements( 
    18.   
  
  
  
  18.                 Object dexPathList, ArrayList files, File optimizedDirectory) 
    19.   
  
  
  
  19.                         throws IllegalAccessException, InvocationTargetException, 
    20.   
  
  
  
  20.                         NoSuchMethodException { 
    21.   
  
  
  
  21.             Method makeDexElements = 
    22.   
  
  
  
  22.                     findMethod(dexPathList, "makeDexElements", ArrayList.class, File.class); 
    23.   
  
  
  
  23.             return (Object[]) makeDexElements.invoke(dexPathList, files, optimizedDirectory); 
    24.   
  
  
  
  24.         } 
    25.   
  
  
  
  25.     }  
    26.

从API14开始，DexClassLoader会使用一个DexpDexPathList类来封装DexFile数组。 

 
 
 
 
    
  
  
  
  
  1. final class DexPathList { 
    2.   
  
  
  
  2.     private static final String DEX_SUFFIX = ".dex"; 
    3.   
  
  
  
  3.     private static final String JAR_SUFFIX = ".jar"; 
    4.   
  
  
  
  4.     private static final String ZIP_SUFFIX = ".zip"; 
    5.   
  
  
  
  5.     private static final String APK_SUFFIX = ".apk"; 
    6.   
  
  
  
  6.    
    7.   
  
  
  
  7.     private static Element[] makeDexElements(ArrayList files, 
    8.   
  
  
  
  8.             File optimizedDirectory) { 
    9.   
  
  
  
  9.         ArrayList elements = new ArrayList(); 
    10.   
  
  
  
  10.         for (File file : files) { 
    11.   
  
  
  
  11.             ZipFile zip = null; 
    12.   
  
  
  
  12.             DexFile dex = null; 
    13.   
  
  
  
  13.             String name = file.getName(); 
    14.   
  
  
  
  14.             if (name.endsWith(DEX_SUFFIX)) { 
    15.   
  
  
  
  15.                 // Raw dex file (not inside a zip/jar). 
    16.   
  
  
  
  16.                 try { 
    17.   
  
  
  
  17.                     dex = loadDexFile(file, optimizedDirectory); 
    18.   
  
  
  
  18.                 } catch (IOException ex) { 
    19.   
  
  
  
  19.                     System.logE("Unable to load dex file: " + file, ex); 
    20.   
  
  
  
  20.                 } 
    21.   
  
  
  
  21.             } else if (name.endsWith(APK_SUFFIX) || name.endsWith(JAR_SUFFIX) 
    22.   
  
  
  
  22.                     || name.endsWith(ZIP_SUFFIX)) { 
    23.   
  
  
  
  23.                 try { 
    24.   
  
  
  
  24.                     zip = new ZipFile(file); 
    25.   
  
  
  
  25.                 } catch (IOException ex) { 
    26.   
  
  
  
  26.                     System.logE("Unable to open zip file: " + file, ex); 
    27.   
  
  
  
  27.                 } 
    28.   
  
  
  
  28.                 try { 
    29.   
  
  
  
  29.                     dex = loadDexFile(file, optimizedDirectory); 
    30.   
  
  
  
  30.                 } catch (IOException ignored) { 
    31.   
  
  
  
  31.       
    32.   
  
  
  
  32.                 } 
    33.   
  
  
  
  33.             } else { 
    34.   
  
  
  
  34.                 System.logW("Unknown file type for: " + file); 
    35.   
  
  
  
  35.             } 
    36.   
  
  
  
  36.             if ((zip != null) || (dex != null)) { 
    37.   
  
  
  
  37.                 elements.add(new Element(file, zip, dex)); 
    38.   
  
  
  
  38.             } 
    39.   
  
  
  
  39.         } 
    40.   
  
  
  
  40.         return elements.toArray(new Element[elements.size()]); 
    41.   
  
  
  
  41.     } 
    42.   
  
  
  
  42.     
    43.   
  
  
  
  43.     private static DexFile loadDexFile(File file, File optimizedDirectory) 
    44.   
  
  
  
  44.             throws IOException { 
    45.   
  
  
  
  45.         if (optimizedDirectory == null) { 
    46.   
  
  
  
  46.             return new DexFile(file); 
    47.   
  
  
  
  47.         } else { 
    48.   
  
  
  
  48.             String optimizedPath = optimizedPathFor(file, optimizedDirectory); 
    49.   
  
  
  <            
    
                分享题目：MultiDex工作原理分析和优化方案
                
    
                链接分享：http://www.mswzjz.cn/qtweb/news5/241555.html
            
    
            
    
                攀枝花网站建设、攀枝花网站运维推广公司-贝锐智能，是专注品牌与效果的网络营销公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                贝锐智能

贝锐智能技术为您推荐以下文章

静态网站知识

各行业网站

成都网站优化　　 　蜀锦在线　　 　成都网站维护　　 　成都电信服务器托管　　 　香港虚拟主机腾讯云　　 　重庆联通机房托管　　 　绵阳服务器托管　　 　成都做网站　　 　成都做网站建设公司　　 　注册域名　　 　和县翔豪网站　　 　交互设计　　 　成都外贸网站建设　　 　众诚伟业　　 　重庆网站制作　　 　网络推广公司　　 　兴发搬家　　 　成都二枢电信服务器托管　　 　云主机　　 　四川晃众门窗