MultiDex 不得不说的用法与源码解析

前言

  开发Android应用或者SDK方向小伙伴们,经过多版本的迭代,新功能的不断增加,依赖多个开源项目,使用第三方SDK,都会导致Apk大小急速膨胀。最终会导致方法超限这一问题,下面让大家了解下什么是MultiDex,讲讲它如何使用,从源码角度说说它的工作原理。

1.认识一下MultiDex

1.1 方法超限问题

当应用及其引用的库包含的方法数超过 65536 时,会遇到一个构建错误

trouble writing output:Too many field references: 131000; max is 65536.You may try using --multi-dex option.

较低版本的构建应用会出现一个不同的错误,但指向的却是一问题:

Conversion to Dalvik format failed:Unable to execute dex: method ID not in [0, 0xffff]: 65536

这两种错误情况会显示一个共同的数字:65536。Google规定单个dex文件中的方法数量不能超过65536这一限制。

1.2 64K引用限制

为什么65536方法超限呢?是由于Dex文件格式限制,一个Dex文件中method个数采用short类型来索引文件中的方法,这个也给method个数带来了不小麻烦,short类型能表示的最大值是65536,如果method个数超过了这个范围自然会报错,1K 表示 1024(即 2^10),65536 刚好是 64K,因此这一限制称为“64K 引用限制。

1.3 MultiDex由来

针对这个问题Google官方对64K引用限制提供一种方案,相信大家也用过MultiDex,Multi翻译过来就是多的意思,MultiDex就是多个dex,简单的讲:既然你的代码这么多,一个dex装不下,那么拆分成多个dex来处理。这样避免了单个dex方法超限,也能正常的编译打包应用。

2.MultiDex基本用法

2.1 Android 5.0 及更高版本的 MultiDex 支持

Android 5.0(minSdkVersion >=21)及更高版本使用名为 ART 的虚拟机时,它本身支持从 APK 文件加载多个 DEX 文件。ART 在应用安装时执行预编译,扫描 classesN.dex 文件,并将它们编译成单个 .oat 文件,以供 Android 设备执行。因此,如果你的 minSdkVersion 为 21 或更高的值,则默认情况下会启用 MultiDex,并且不需要 MultiDex 支持库。

2.2Android 5.0之前的MultiDex的支持

Android 5.0(minSdkVersion < 21)之前的平台版本使用 Dalvik 运行时执行应用代码。默认情况下,Dalvik 将应用限制为每个 APK 只能使用一个 classes.dex 字节码文件。为了绕过这一限制,可以在项目中添加 MultiDex 支持库:

android {
    defaultConfig {
        minSdkVersion 16 
        targetSdkVersion 28
        multiDexEnabled true    //启用MultiDex库支持
    }
}
dependencies {
    def multidex_version = "2.0.1"
    implementation 'androidx.multidex:multidex:$multidex_version'
}

如果你不用 AndroidX,修改app下的build.gradle 文件以启用 MultiDex,并将 MultiDex 库添加为依赖项,如下所示:

android {
    defaultConfig {
        minSdkVersion 16 
        targetSdkVersion 28
        multiDexEnabled true    //启用MultiDex库支持
    }
}
dependencies {
     implementation 'com.android.support:multidex:1.0.3'   //MultiDex依赖库
}

2.3MultiDex配置

如果无自定义Application,修改清单文件设置 中的android:name,如下所示:



    
    

如果有自定义Application,且直接继承Application可以更换为MultiDexApplication

public class MyApplication extends MultiDexApplication {
   public void attachBaseContext(Context base) {
        super.attachBaseContext(base);
    }
}

如果有自定义Application,但无法更改基类(继承其他的Appliaction),则可以添加attachBaseContext()方法,并调用MultiDex.install(this);

public class MyApplication extends SomeOtherApplication {
  @Override
  protected void attachBaseContext(Context base) {
     super.attachBaseContext(base);
     MultiDex.install(this);
  }
}

3.MultiDex原理解析

  注:本次源码基于com.android.support:multidex:1.0.3版本分析

3.1 判断安卓虚拟机的逻辑

 程序入口 MultiDex.install();

public static void install(Context context) {
        Log.i("MultiDex", "Installing application");
        if (IS_VM_MULTIDEX_CAPABLE) {
          //判断VM是否支持Multidex,如果是ART虚拟机默认情况下会启用 MultiDex,并且不需要MultiDex支持库

          Log.i("MultiDex", "VM has multidex support, MultiDex support library is disabled.");
        } else if (VERSION.SDK_INT < 4) {
            //最低兼容SDK版本是4,这样的手机基本都是看不着了吧
            throw new RuntimeException("MultiDex installation failed. SDK " + VERSION.SDK_INT + " is unsupported. Min SDK version is " + 4 + ".");
        } else {
              //执行到这里说明当前是Dalvik虚拟机,该进行多dex拆分
                     doInstallation();
                     ...........
}
}

我们再看看IS_VM_MULTIDEX_CAPABLE如何定义做了什么逻辑:

//System.getProperty("java.vm.version")  获取当前虚拟机版本 例:2.1.0
private static final boolean IS_VM_MULTIDEX_CAPABLE = isVMMultidexCapable(System.getProperty("java.vm.version"));
    /**
     * 1、通过正则表达式将版本号分成major(主版本号)和minor(次版本号)。
     * 2、通过判断主版本和次版本是否大于一个常量来判定虚拟机是否支持MultiDex。
     */
static boolean isVMMultidexCapable(String versionString) {
        boolean isMultidexCapable = false;
        if (versionString != null) {
            Matcher matcher = Pattern.compile("(\\d+)\\.(\\d+)(\\.\\d+)?").matcher(versionString);
            if (matcher.matches()) {
                try {
                    int major = Integer.parseInt(matcher.group(1));
                    int minor = Integer.parseInt(matcher.group(2));
                    isMultidexCapable = major > 2 || major == 2 && minor >= 1;
                } catch (NumberFormatException var5) {
                   
                }
            }
        }

        Log.i("MultiDex", "VM with version " + versionString + (isMultidexCapable ? " has multidex support" : " does not have multidex support"));
        return isMultidexCapable;
    }

isVMMultidexCapable() 返回True 说明是ART虚拟机自身就支持MultiDex不需要再做任何处理,Flase说明是Dalvik虚拟机自身不支持 MultiDex ,该执行doInstallation()

3.1.1有争议的一个问题

网上搜索很多技术大佬的博客,大部分说:可以通过调用 System.getProperty(“java.vm.version”)来检测当前使用的是哪个虚拟机,如果使用的是ART虚拟机的话,属性值会大于等于2.0.0(重点就是这个=2.0.0)

在这里我纠正下,正确的说法是:如果使用的是ART虚拟机的话,属性值应该大于等于2.1.0(>=2.1.0),有什么依据这样说?用真机(模拟器)安卓系统4.4测试,会发现 System.getProperty(“java.vm.version”)=2.0.0 ,把结果带入isVMMultidexCapable()方法里,返回的是false,说明当前应该(api 4.4版本)是Dalvik虚拟机才对,有悖于技术大佬博客上面所说的等于2.0.0就是ART虚拟机。


3.2Dex解压和压缩

如果上一步判断是Dalvik虚拟机,执行到了doInstallation()

   /**
    * applicationInfo.sourceDir获取应用APK所在目录  /data/app/{packageName}-s_ZR1N24kyfFdRoazc7SLw==/base.apk
    * applicationInfo.dataDir获取数据所在目录   /data/user/0/{packageName}
   */
  private static void doInstallation(Context mainContext, File sourceApk, File dataDir, String secondaryFolderName, String prefsKeyPrefix, boolean reinstallOnPatchRecoverableException) throws IOException, IllegalArgumentException, IllegalAccessException, NoSuchFieldException, InvocationTargetException, NoSuchMethodException, SecurityException, ClassNotFoundException, InstantiationException {
        Set var6 = installedApk;
        //考虑到多线程并发下加锁,保证执行一次
        synchronized(installedApk) {
            //如果应用 没有安装,把installedApk添加到集合中,安装应用的路径:/data/app/packageName/base.apk
            if (!installedApk.contains(sourceApk)) {
                installedApk.add(sourceApk);
                if (VERSION.SDK_INT > 20) {
                    Log.w("MultiDex", "MultiDex is not guaranteed to work in SDK version " + VERSION.SDK_INT + ": SDK version higher than " + 20 + " should be backed by " + "runtime with built-in multidex capabilty but it's not the " + "case here: java.vm.version=\"" + System.getProperty("java.vm.version") + "\"");
                }
                ClassLoader loader;
                try {
                    loader = mainContext.getClassLoader(); //上下文对象中获取ClassLoader对象,提取出来的Dex需要通过ClassLoader真正的被加载执行;
                } catch (RuntimeException var25) {
                    Log.w("MultiDex", "Failure while trying to obtain Context class loader. Must be running in test mode. Skip patching.", var25);
                    return;
                }

                if (loader == null) {//说明获取ClassLoader 对象失败
                    Log.e("MultiDex", "Context class loader is null. Must be running in test mode. Skip patching.");
                } else {
                    try {
                        clearOldDexDir(mainContext);//清理老的缓存DEX文件
                    } catch (Throwable var24) {
                        Log.w("MultiDex", "Something went wrong when trying to clear old MultiDex extraction, continuing without cleaning.", var24);
                    }
                    //创建一个存放dex的目录   getDexDir()有详细的注释
                    File dexDir = getDexDir(mainContext, dataDir, secondaryFolderName);

                    // 把APK中的dex提取到dexDir目录中,返回的files集合有可能为空,表示没有secondaryDex
                    //apk路径:data/app/packageName/base.apk
                    //dexDir 路径: data/user/0/packageName/code_cache/secondary-dexes
                    MultiDexExtractor extractor = new MultiDexExtractor(sourceApk, dexDir);
                    IOException closeException = null;

                    try {
                   //  调用MultiDexExtractor.load方法,第一次是没有缓存的,需要IO操作,会非常耗时 返回dex文件列表
                        List files = extractor.load(mainContext, prefsKeyPrefix, false);

                        try {
                            installSecondaryDexes(loader, dexDir, files);  //安装提取出来的Dex文件。
                        } catch (IOException var26) {
                            if (!reinstallOnPatchRecoverableException) {
                                throw var26;
                            }
                            //出现异常 重新提取dex文件,并安装提取出来的dex文件
                            Log.w("MultiDex", "Failed to install extracted secondary dex files, retrying with forced extraction", var26);
                            files = extractor.load(mainContext, prefsKeyPrefix, true);
                            installSecondaryDexes(loader, dexDir, files);
                        }
                    } finally {
                        try {
                            extractor.close();
                        } catch (IOException var23) {
                            closeException = var23;
                        }
                    }

                    if (closeException != null) {
                        throw closeException;
                    }
                }
            }
        }
    }

上面代码进行各种预校验以及获取需要的信息,重点方法MultiDexExtractor.load():提取dex

 List load(Context context, String prefsKeyPrefix, boolean forceReload) throws IOException {
        Log.i("MultiDex", "MultiDexExtractor.load(" + this.sourceApk.getPath() + ", " + forceReload + ", " + prefsKeyPrefix + ")");

        if (!this.cacheLock.isValid()) {  //文件锁是否还有效,无效抛异常
            throw new IllegalStateException("MultiDexExtractor was closed");
        } else {
            List files;

            //forceReload判断文件是否重新加载,isModified()是判断sourceApk文件是否做过修改(简单点说这个条件就是没有覆盖安装过)
            if (!forceReload && !isModified(context, this.sourceApk, this.sourceCrc, prefsKeyPrefix)) {
                try {
                    files = this.loadExistingExtractions(context, prefsKeyPrefix);//加载之前已经解压过的dex(可以理解缓存过的)
                } catch (IOException var6) {
                    Log.w("MultiDex", "Failed to reload existing extracted secondary dex files, falling back to fresh extraction", var6);
                    files = this.performExtractions();    //出现异常重新执行提取dex
                    putStoredApkInfo(context, prefsKeyPrefix, getTimeStamp(this.sourceApk), this.sourceCrc, files);//出现异常保存apk时间戳 Crc码等信息缓存下来用于下次比对。
                }
            } else {
                if (forceReload) {
                    Log.i("MultiDex", "Forced extraction must be performed.");
                } else {
                    Log.i("MultiDex", "Detected that extraction must be performed.");
                }
                files = this.performExtractions();//走到else{}说明 没有缓存,本质上提取的是dex文件
                putStoredApkInfo(context, prefsKeyPrefix, getTimeStamp(this.sourceApk), this.sourceCrc, files);//把apk 信息缓存下来
            }

            Log.i("MultiDex", "load found " + files.size() + " secondary dex files");
            return files;
        }
    }

看上面的代码是不是有点懵我先给大家梳理下大概的逻辑:load()方法里面有两种逻辑,缓存过的loadExistingExtractions()和没缓存过的performExtractions(),第一次获取dex,没有缓存过任何信息,应先执行performExtractions()这是一个IO耗时操作(下面会细说),完成这个操作后把信息缓存下来(因为IO很耗时 不能每次都去操作),下一次则读取缓存的loadExistingExtractions(),速度会更快些。

private List performExtractions() throws IOException {  
        //  格式:base.apk.classes"
        String extractedFilePrefix = this.sourceApk.getName() + ".classes";
        this.clearDexDir();  //清理dex文件
        List files = new ArrayList();

        ZipFile apk = new ZipFile(this.sourceApk);// 把.apk转换成.zip

        try {
            int secondaryNumber = 2;
            //apk本质上就是归档文件上面步骤已经把apk变成了zip文件 ,for循环遍历zip文件 ,获取的dex文件
            // classes2.dex  classesN.dex
            for(ZipEntry dexFile = apk.getEntry("classes" + secondaryNumber + ".dex"); dexFile != null; dexFile = apk.getEntry("classes" + secondaryNumber + ".dex")) {
                //获取的应该是base.apk.classes2.zip
                String fileName = extractedFilePrefix + secondaryNumber + ".zip";
                //创建base.apk.classes2.zip 文件
                MultiDexExtractor.ExtractedDex extractedFile = new MultiDexExtractor.ExtractedDex(this.dexDir, fileName);//
                // 添加到文件列表(base.apk.classes2.zip 添加到/data/user/0/packageName/files/code_cache/secondary-dexes文件下)
                files.add(extractedFile);
                Log.i("MultiDex", "Extraction is needed for file " + extractedFile);
                int numAttempts = 0;
                boolean isExtractionSuccessful = false; //是否提取成功

                while(numAttempts < 3 && !isExtractionSuccessful) {
                    ++numAttempts;

                    //将classes2.dex文件写到压缩文件classes2.zip里去,最多重试三次
                    extract(apk, dexFile, extractedFile, extractedFilePrefix);

                    try {
                        extractedFile.crc = getZipCrc(extractedFile);
                        isExtractionSuccessful = true;
                    } catch (IOException var18) {
                        isExtractionSuccessful = false;
                        Log.w("MultiDex", "Failed to read crc from " + extractedFile.getAbsolutePath(), var18);
                    }

                    Log.i("MultiDex", "Extraction " + (isExtractionSuccessful ? "succeeded" : "failed") + " '" + extractedFile.getAbsolutePath() + "': length " + extractedFile.length() + " - crc: " + extractedFile.crc);

                    if (!isExtractionSuccessful) {
                        //未校验通过则删除。
                        extractedFile.delete();
                        if (extractedFile.exists()) {
                            Log.w("MultiDex", "Failed to delete corrupted secondary dex '" + extractedFile.getPath() + "'");
                        }
                    }
                }

                if (!isExtractionSuccessful) {
                    throw new IOException("Could not create zip file " + extractedFile.getAbsolutePath() + " for secondary dex (" + secondaryNumber + ")");
                }

                ++secondaryNumber;
            }
        } finally {
            try {
                apk.close();
            } catch (IOException var17) {
                Log.w("MultiDex", "Failed to close resource", var17);
            }
        }
        return files; //返回dex的压缩文件列表
    }

上面的逻辑就是解压apk(apk来自applicationInfo.sourceDir()),遍历出里面的dex文件,例如 classes.dex, classesN.dex,然后又压缩成classes.zip,classesN.zip,然后返回zip文件列表。

总结:第一次加载才会执行耗时IO操作,第二次进来读取缓存中保存的dex信息,直接返回文件列表,所以第一次启动的时候比较耗时。

3.3 安装dex

dex列表已经返回了,该执行 installSecondaryDexes();进行dex安装

private static void installSecondaryDexes(ClassLoader loader, File dexDir, List files) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, InvocationTargetException, NoSuchMethodException, IOException, SecurityException, ClassNotFoundException, InstantiationException {
         //针对不同的api  分别进行逻辑处理
        if (!files.isEmpty()) {
            if (VERSION.SDK_INT >= 19) {
                MultiDex.V19.install(loader, files, dexDir);
            } else if (VERSION.SDK_INT >= 14) {
                MultiDex.V14.install(loader, files);
            } else {
                MultiDex.V4.install(loader, files);
            }
        }
    }

看下 api19(v14 v4这是对不同版本做了处理 )dex安装处理了什么逻辑 MultiDex.V19.install()

 private static final class V19 {
        private V19() {
        }

        static void install(ClassLoader loader, List additionalClassPathEntries, File optimizedDirectory) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, InvocationTargetException, NoSuchMethodException, IOException {
            //反射获取ClassLoader 的 pathList 字段
            Field pathListField = MultiDex.findField(loader, "pathList");
            Object dexPathList = pathListField.get(loader);
            ArrayList suppressedExceptions = new ArrayList();
            //生成的Dex文件对应的Element数组
            //将Element数组插入到原有的dexElments数组后面
            MultiDex.expandFieldArray(dexPathList, "dexElements", makeDexElements(dexPathList, new ArrayList(additionalClassPathEntries), optimizedDirectory, suppressedExceptions));
            if (suppressedExceptions.size() > 0) {
                Iterator var6 = suppressedExceptions.iterator();

                while(var6.hasNext()) {
                    IOException e = (IOException)var6.next();
                    Log.w("MultiDex", "Exception in makeDexElement", e);
                }
                //反射获取到dexElements字段
                Field suppressedExceptionsField = MultiDex.findField(dexPathList, "dexElementsSuppressedExceptions");
                IOException[] dexElementsSuppressedExceptions = (IOException[])((IOException[])suppressedExceptionsField.get(dexPathList));
                if (dexElementsSuppressedExceptions == null) {
                    dexElementsSuppressedExceptions = (IOException[])suppressedExceptions.toArray(new IOException[suppressedExceptions.size()]);
                } else {
                    IOException[] combined = new IOException[suppressedExceptions.size() + dexElementsSuppressedExceptions.length];
                    suppressedExceptions.toArray(combined);
                    System.arraycopy(dexElementsSuppressedExceptions, 0, combined, suppressedExceptions.size(), dexElementsSuppressedExceptions.length);
                    dexElementsSuppressedExceptions = combined;
                }

                suppressedExceptionsField.set(dexPathList, dexElementsSuppressedExceptions);
                IOException exception = new IOException("I/O exception during makeDexElement");
                exception.initCause((Throwable)suppressedExceptions.get(0));
                throw exception;
            }
        }

        private static Object[] makeDexElements(Object dexPathList, ArrayList files, File optimizedDirectory, ArrayList suppressedExceptions) throws IllegalAccessException, InvocationTargetException, NoSuchMethodException {
            Method makeDexElements = MultiDex.findMethod(dexPathList, "makeDexElements", ArrayList.class, File.class, ArrayList.class);
            return (Object[])((Object[])makeDexElements.invoke(dexPathList, files, optimizedDirectory, suppressedExceptions));
        }
    }

上面代码做了以下的几个操作

1 .反射获取到 pathList 字段

  1. 找到pathList 字段对应的类的makeDexElements 方法(也用到了反射)

  2. 通过MultiDex.expandFieldArray 这个方法扩展 dexElements 数组

就是创建一个新的数组,把主dex要增加的内容(classerdex2、classerdexN)拷贝进去,反射替换原来的dexElements为新的数组。

3.3.1 类加载机制(简单说说概念,本文重点是MultiDex)

不管是 PathClassLoader还是DexClassLoader,都继承自BaseDexClassLoader。系统会默认创建一个PathClassLoader ,PathClassLoader有个重要成员变量pathList,pathList内部包含一个Element[],数组每一个元素对应这一个dex文件(classes.dex)。

默认情况下 系统只会加载apk第一个classes.dex文件,一般来说element数组只会存在一个元素对应一个classes.dex,运行需要加载某个类时,pathClassLoader 通过pathList的 element数组 从前往后遍历所有元素,去看哪一个dex文件有对应类,有则返回。


3.4详细源码注释

github地址有需要可以去clone :https://github.com/AndroidProg/MultiDexSources

技术思考:

   1. 为了更好的了解一个程序或者原理,找程序入口下断点分析非常有必要的

   2. 优秀的解决方案都是从源码中获取的

   3. 知道的越多不知道的更多(说多都是泪)

结语

  记录下自己的学习和工作经验,分享给有需要的人。如果有那里写的不对或者不理解,欢迎大家的指正。

你可能感兴趣的:(MultiDex 不得不说的用法与源码解析)