程序性能优化之APK大小优化（六）下篇

阿里P7移动互联网架构师进阶视频（每日更新中）免费学习请点击：https://space.bilibili.com/474380680

本篇文章将继续从微信资源混淆AndResGuard原理来介绍APK大小优化:
微信的AndResGuard工具是用于Android资源的混淆，作用有两点：一是通过混淆资源ID长度同时利用7z深度压缩，减小了apk包大小；二是混淆后在安全性方面有一点提升，提高了逆向破解难度。本文从源码角度，来探寻AndResGuard实现原理。

阅读本文需要前提知识：掌握Android应用程序打包编译过程，尤其是对资源的编译和打包过程；熟悉resource.arsc文件格式。

推荐罗升阳文章：http://blog.csdn.net/luoshengyang/article/details/8744683
微信资源混淆工具源码地址：https://github.com/shwenzhang/AndResGuard
附上来自网络神图：

 

​

 

0、程序入口CliMain.main()
该函数处理命令行参数、并解析自定义配置文件，混淆工具可以根据配置项进行特定处理，具体参考config.xml内容，针对其中特定内容，我们会在后面提到。然后进入真正混淆的入口函数resourceProgurad()

特别说明一下解析Configuration中关键点，处理复用旧的mapping文件：
1、processOldMappingFile()

private void processOldMappingFile() throws IOException {
        ...
        try {
            String line = br.readLine();

            while (line != null) {
                if (line.length() > 0) {
                    Matcher mat = MAP_PATTERN.matcher(line);

                    if (mat.find()) {
                        String nameAfter = mat.group(2);
                        String nameBefore = mat.group(1);
                        nameAfter = nameAfter.trim();
                        nameBefore = nameBefore.trim();

                        //如果有这个的话，那就是mOldFileMapping
                        if (line.contains("/")) {
                            mOldFileMapping.put(nameBefore, nameAfter);
                        } else {
                            //这里是resid的mapping
                            int packagePos = nameBefore.indexOf(".R.");
                            if (packagePos == -1) {
                                throw new IOException(
                                    String.format(
                                        "the old mapping file packagename is malformed, " +
                                            "it should be like com.tencent.mm.R.attr.test, yours %s\n", nameBefore)
                                );

                            }
                            String packageName = nameBefore.substring(0, packagePos);
                            int nextDot = nameBefore.indexOf(".", packagePos + 3);
                            String typeName = nameBefore.substring(packagePos + 3, nextDot);

                            String beforename = nameBefore.substring(nextDot + 1);
                            String aftername = nameAfter.substring(nameAfter.indexOf(".", packagePos + 3) + 1);

                            HashMap<String, HashMap<String, String>> typeMap;

                            if (mOldResMapping.containsKey(packageName)) {
                                typeMap = mOldResMapping.get(packageName);
                            } else {
                                typeMap = new HashMap<>();
                            }

                            HashMap<String, String> namesMap;
                            if (typeMap.containsKey(typeName)) {
                                namesMap = typeMap.get(typeName);
                            } else {
                                namesMap = new HashMap<>();
                            }
                            namesMap.put(beforename, aftername);

                            typeMap.put(typeName, namesMap);
                            mOldResMapping.put(packageName, typeMap);
                        }
                    }

                }
                line = br.readLine();
            }
        }
        ...
    }
}

该函数主要功能是：对oldmapping文件处理是按照正则表达式把“->”分隔提取两边字符串，进行hashmap缓存:

其一、如果有这个“/”的话，那就是res path mapping即mOldFileMapping的hashmap中：
mOldFileMapping.put(nameBefore, nameAfter);
(例如res/drawable -> r/c，最终mOldFileMapping是(“res/drawable”,”r/c”))

其二、否则判断如果包含“.R.”,则是resid的mapping，最后按照类别、package保存到oldResMapping的hashmap中：
namesMap.put(beforename, aftername);
(例如com.basket24.demo.R.attr.progress -> com.basket24.demo.R.attr.a，最终namesMap是(“progress”,”a”))
typeMap.put(typeName, namesMap);
(例如com.basket24.demo.R.attr.progress -> com.basket24.demo.R.attr.a，最终typeMap是(“attr”,namesMap))
mOldResMapping.put(packageName, typeMap);
(例如com.basket24.demo.R.attr.progress -> com.basket24.demo.R.attr.a，最终mOldResMapping是(“com.basket24.demo”,typeMap))

2、Main.resourceProguard()是混淆真正的入口。

protected void resourceProguard(File outputFile, String apkFilePath, InputParam.SignatureType signatureType) {
        ApkDecoder decoder = new ApkDecoder(config);
        File apkFile = new File(apkFilePath);
        ...
        mRawApkSize = FileOperation.getFileSizes(apkFile);
        try {
            /* 默认使用V1签名 */
            decodeResource(outputFile, decoder, apkFile);
            buildApk(decoder, apkFile, signatureType);
        } catch (Exception e) {
            e.printStackTrace();
            goToError();
        }
    }

混淆入口resourceProguard里功能：
其一：decodeResource();//进行混淆资源相关功能。
其二：buildApk(decoder, apkFile, signatureType);//最后buildApk生成签名包。

3、Main.decodeResource()

private void decodeResource(File outputFile, ApkDecoder decoder, File apkFile) {
    decoder.setApkFile(apkFile);
    ...
    decoder.setOutDir(mOutDir.getAbsoluteFile());
    decoder.decode();//混淆资源功能
}

decodeResource核心功能就是设置相关变量，并执行ApkDecoder.decode()。

4、ApkDecoder.decode()

public void decode(){
    if (hasResources()) {
        ensureFilePath();
        RawARSCDecoder.decode(mApkFile.getDirectory().getFileInput("resources.arsc"));
        ResPackage[] pkgs = ARSCDecoder.decode(mApkFile.getDirectory().getFileInput("resources.arsc"), this);

        //把没有纪录在resources.arsc的资源文件也拷进dest目录
        copyOtherResFiles();

        /*把整个arsc重新修改其中几个字符串池和对应大小，形成新的arsc文件。*/
        ARSCDecoder.write(mApkFile.getDirectory().getFileInput("resources.arsc"), this, pkgs);
      }
}

5、ensureFilePath()

ensureFilePath(){
    Utils.cleanDir(mOutDir);//mOutDir就是outapk目录

    //temp目录，用于解压apk
    String unZipDest = new File(mOutDir, TypedValue.UNZIP_FILE_PATH).getAbsolutePath();

    mCompressData = FileOperation.unZipAPk(mApkFile.getAbsoluteFile().getAbsolutePath(), unZipDest);
    dealWithCompressConfig();//
    //将res混淆成r
    if (!config.mKeepRoot) {
        mOutResFile = new File(mOutDir.getAbsolutePath() + File.separator + TypedValue.RES_FILE_PATH);
    } else {
        mOutResFile = new File(mOutDir.getAbsolutePath() + File.separator + "res");
    }

    //这个需要混淆各个文件夹
    // TypedValue.UNZIP_FILE_PATH指"temp"
    mRawResFile = new File(mOutDir.getAbsoluteFile().getAbsolutePath() + File.separator + TypedValue.UNZIP_FILE_PATH + File.separator + "res");
    mOutTempDir = new File(mOutDir.getAbsoluteFile().getAbsolutePath() + File.separator + TypedValue.UNZIP_FILE_PATH);

    //这里遍历获取原始res目录的文件
    Files.walkFileTree(mRawResFile.toPath(), new ResourceFilesVisitor());

    mOutTempARSCFile = new File(mOutDir.getAbsoluteFile().getAbsolutePath() + File.separator + "resources_temp.arsc");
    mOutARSCFile = new File(mOutDir.getAbsoluteFile().getAbsolutePath() + File.separator + "resources.arsc");

    String basename = mApkFile.getName().substring(0, mApkFile.getName().indexOf(".apk"));

    //RES_MAPPING_FILE = "resource_mapping_";
    //mResMappingFile名称如“resource_mapping_imfun.txt"
    mResMappingFile = new File(mOutDir.getAbsoluteFile().getAbsolutePath() + File.separator
        + TypedValue.RES_MAPPING_FILE + basename + TypedValue.TXT_FILE);
}

ensureFilePath主要功能如下：
其一、在输出目录下，建立一个temp目录，用于apk解压的目录。unZipAPk解压apk，得到mCompressData压缩条目集合[compress.put(name,entry.getMethod());]
其二、根据config来修改压缩的值，将满足config的压缩类型，进行修改压缩标记为ZIP_DEFLATED
其三、判断是否将将res混淆成r
其四、创建需要混淆的temp目录(apk被解压到temp目录)等、使用FileVisitor对目录进行遍历，将原始res（”temp/res”）下路径保存到HashSet中。
其五、创建resources_temp.arsc 和最终resources.arsc等文件及最终mapping命名：resource_mapping_apkname.txt

下面回到第4步ApkDecoder.decode()中继续执行：

6、RawARSCDecoder.decode()
这一步就是解析原始resources.arsc文件，得到文件结构并缓存相关数据，如资源类型字符串池mExistTypeNames等。代码较长，且关键步骤较少，故略去代码。

继续在第4步ApkDecoder.decode()中往下执行：

7、ARSCDecoder.decode()

public static ResPackage[] decode(InputStream arscStream, ApkDecoder apkDecoder){
    try {
         //proguardFileName混淆文件名
         ARSCDecoder decoder = new ARSCDecoder(arscStream, apkDecoder);
         ResPackage[] pkgs = decoder.readTable();
         return pkgs;
     } catch (IOException ex) {
         throw new AndrolibException("Could not decode arsc file", ex);
     }
}

8、ARSCDecoder的构造函数中执行proguardFileName()

proguardFileName(){

    //其中初始化ProguardStringBuilder，建立各种被映射为的字符集合标记集合
    mProguardBuilder = new ProguardStringBuilder();
    mProguardBuilder.reset();

    final Configuration config = mApkDecoder.getConfig();
    File rawResFile = mApkDecoder.getRawResFile();
    File[] resFiles = rawResFile.listFiles();
    if (!config.mKeepRoot) {
        //需要保持之前的命名方式
        if (config.mUseKeepMapping) {
            mOldFileMapping提取values部分即"r/c"保存到keepFileNames，然后从mProguardBuilder生成的混淆字符池中删除掉这些names.
            for (File resFile : resFiles) {
                String raw = "res" + "/" + resFile.getName();
                if (fileMapping.containsKey(raw)) {
                    mOldFileName.put(raw, fileMapping.get(raw));
                } else {
                    mOldFileName.put(raw, resRoot + "/" + mProguardBuilder.getReplaceString());
                }
            }
            /*上面mOldFileName保存的是用旧混淆(没有的话从新的混淆池中获取)文件处理过的File混淆映射.
            （mOldFileName("res/attr"," r/h")）*/
        }else{//否则
            for (int i = 0; i < resFiles.length; i++) {
                //这里也要用linux的分隔符,如果普通的话，就是r
                mOldFileName.put("res" + "/" + resFiles[i].getName(), TypedValue.RES_FILE_PATH + "/" + mProguardBuilder.getReplaceString());
            }
        }

        generalFileResMapping();//资源目录File映射
    }
}

/**
*对资源目录File映射。
*/
generalFileResMapping(){
    mMappingWriter.write("res path mapping:\n");
    for (String raw : mOldFileName.keySet()) {
        mMappingWriter.write("    " + raw + " -> " + mOldFileName.get(raw));
        mMappingWriter.write("\n");
    }
    mMappingWriter.write("\n\n");
    mMappingWriter.write("res id mapping:\n");
    mMappingWriter.flush();
}

这里第8步主要功能是：
其一、其中初始化ProguardStringBuilder，建立混淆字符串池和标记集合。
其二、获取配置config内容，判断是否keeproot,是否沿用旧的mapping文件等，进行映射。
其三、generalFileResMapping把缓存的映射hashmap写入文件，形成mapping文件，其中目前只有资源目录path映射。

回到第7步中继续执行decoder.readTable()进行真正混淆

9、decoder.readTable()

ResPackage[] readTable(){
    mTableStrings = StringBlock.read(mIn);
    ResPackage[] packages = new ResPackage[packageCount];
    packages[i] = readPackage();
    return packages;
}

readPackage()解析resources.arsc文件，其中关键步骤readEntry()如下：

10、readEntry()

readEntry(){
    if (config.mUseWhiteList) {
        //判断是否走whitelist
        HashMap<String, HashMap<String, HashSet<Pattern>>> whiteList = config.mWhiteList;
        String packName = mPkg.getName();
        if (whiteList.containsKey(packName)) {

            HashMap<String, HashSet<Pattern>> typeMaps = whiteList.get(packName);
            String typeName = mType.getName();

            if (typeMaps.containsKey(typeName)) {
                String specName = mSpecNames.get(specNamesId).toString();
                HashSet<Pattern> patterns = typeMaps.get(typeName);
                for (Iterator<Pattern> it = patterns.iterator(); it.hasNext(); ) {
                    Pattern p = it.next();
                    if (p.matcher(specName).matches()) {
                        mPkg.putSpecNamesReplace(mResId, specName);//缓存设置package中spec替换项
                        mPkg.putSpecNamesblock(specName);
                        mProguardBuilder.setInWhiteList(mCurEntryID, true);//当前资源项ID标示为白名单

                        mType.putSpecProguardName(specName);//设置spec的proguard的名称为原始资源项名称
                        isWhiteList = true;
                        break;
                    }
                }
            }

        }

    }

    if (!isWhiteList) {
        boolean keepMapping = false;
        if (config.mUseKeepMapping) {//判断旧的mapping文件也复用，得到replaceString
            HashMap<String, HashMap<String, HashMap<String, String>>> resMapping = config.mOldResMapping;
            String packName = mPkg.getName();
            //resMapping是指res Id的映射
            if (resMapping.containsKey(packName)) {
                HashMap<String, HashMap<String, String>> typeMaps = resMapping.get(packName);
                String typeName = mType.getName();
                if (typeMaps.containsKey(typeName)) {
                    //这里面的东东已经提前去掉，请放心使用
                    /*(例如com.basket24.demo.R.attr.progress -> com.basket24.demo.R.attr.a，最终proguard是("progress","a"))*/
                    HashMap<String, String> proguard = typeMaps.get(typeName);
                    String specName = mSpecNames.get(specNamesId).toString();
                    if (proguard.containsKey(specName)) {
                        keepMapping = true;
                        /*获取旧的混淆id映射中specname对应的混淆字符串，继续使用。*/
                        replaceString = proguard.get(specName);
                    }
                }
            }
        }

        //没有经过旧的混淆文件处理，则直接从混淆池中获取一个混淆字符串
        if (!keepMapping) {
            replaceString = mProguardBuilder.getReplaceString();
        }

        /*设置混淆池中对应资源项id的位置为“已混淆”的标记。*/
        mProguardBuilder.setInReplaceList(mCurEntryID, true);
        if (replaceString == null) {
            throw new AndrolibException("readEntry replaceString == null");
        }
        //根据新的混淆字符串，生成相应的id映射。
        generalResIDMapping(mPkg.getName(), mType.getName(), mSpecNames.get(specNamesId).toString(), replaceString);

        //以下对混淆字符串进行相应对象的缓存。
        mPkg.putSpecNamesReplace(mResId, replaceString);
        mPkg.putSpecNamesblock(replaceString);
        mType.putSpecProguardName(replaceString);
    }
}  

/*根据新的混淆字符串，生成相应的id映射。输出到新的混淆mapping文件中(里面已经文件file的映射关系)。*/
generalResIDMapping(){
    mMappingWriter.write("    " + packagename + ".R." + typename + "." + specname + " -> " + packagename + ".R." + typename + "." + replace);
}

readEntry函数主要实现了：
其一、判断是否启用whitelist，如果有的话，设置specname的混淆字符串为原始字符串，即不进行混淆，进行相应对象缓存。
其二、判断是否复用旧的mapping文件中id的映射，已有的继续使用旧的映射关系中的混淆字符串，否则从混淆池中获取一个新的字符串，即得到replaceString。
其三、根据新的混淆字符串，生成相应的id映射。输出到新的混淆mapping文件中(里面已经文件file的映射关系)。

readEntry继续解析arsc文件，执行到关键步骤readValue:

11、readValue()

readValue() {
    //这里面有几个限制，一对于string ,id, array我们是知道肯定不用改的，第二看要那个type是否对应有文件路径
    if (mPkg.isCanProguard() && flags && type == TypedValue.TYPE_STRING && mShouldProguardForType && mShouldProguardTypeSet.contains(mType.getName())) {
        //mTableStringsProguard是要存放混淆的资源项值
        if (mTableStringsProguard.get(data) == null) {
            String raw = mTableStrings.get(data).toString();//mTableStrings是解析原始arsc文件得到资源项值字符串池
            String proguard = mPkg.getSpecRepplace(mResId);//获取前面已缓存下的specName对应的混淆字符串
            //这个要写死这个，因为resources.arsc里面就是用这个"/"
            int secondSlash = raw.lastIndexOf("/");
            ...
            String newFilePath = raw.substring(0, secondSlash);//获得原始资源项值的path部分

            if (!mApkDecoder.getConfig().mKeepRoot) {
                //如在(“res/drawable“,”r/c”)中找到newFilePath=”r/c”
                newFilePath = mOldFileName.get(raw.substring(0, secondSlash));//mOldFileName是已生成的混淆文件映射
            }
            ...
            //同理这里不能用File.separator，因为resources.arsc里面就是用这个

            /***********************
            *结果result如”r/c/a”
            ************************/
            String result = newFilePath + "/" + proguard;
            ...
            String compatibaleraw = new String(raw);
            String compatibaleresult = new String(result);

            //为了适配window要做一次转换
            if (!File.separator.contains("/")) {
                compatibaleresult = compatibaleresult.replace("/", File.separator);
                compatibaleraw = compatibaleraw.replace("/", File.separator);
            }

            //下面很关键，创建了原始res文件和混淆后的res文件
            File resRawFile = new File(mApkDecoder.getOutTempDir().getAbsolutePath() + File.separator + compatibaleraw);
            File resDestFile = new File(mApkDecoder.getOutDir().getAbsolutePath() + File.separator + compatibaleresult);

            //这里用的是linux的分隔符
            HashMap<String, Integer> compressData = mApkDecoder.getCompressData();
            if (compressData.containsKey(raw)) {
                compressData.put(result, compressData.get(raw));//替换压缩的文件名为混淆后的字符串
            } else {
                System.err.printf("can not find the compress dataresFile=%s\n", raw);
            }

            if (!resRawFile.exists()) {
                System.err.printf("can not find res file, you delete it? path: resFile=%s\n", resRawFile.getAbsolutePath());
                return;
            } else {
                if (resDestFile.exists()) {
                    throw new AndrolibException(
                        String.format("res dest file is already  found: destFile=%s", resDestFile.getAbsolutePath())
                    );
                }
                /**************************************************************
                *关键点：把旧的资源文件内容copy到新的混淆后的资源文件中
                **************************************************************/
                FileOperation.copyFileUsingStream(resRawFile, resDestFile);
                //already copied
                //从原始资源目录mRawResourceFiles中删除掉该已混淆的文件Path
                mApkDecoder.removeCopiedResFile(resRawFile.toPath());

                /**********************
                *按照data的index顺序，保存resutl(result如”r/c/a”),
                *即把混淆后的资源项的值缓存下来
                **********************/
                mTableStringsProguard.put(data, result);
            }
        }
    }
}

readValue主要实现了：
其一、mPkg.getSpecRepplace获取前面已缓存下的specName对应的混淆字符串如“a”
其二、从mOldFileName中如在(“res/drawable“,”r/c”)中找到newFilePath=”r/c”
其三、生成result如”r/c/a”
其四、创建了混淆后的res文件，把旧的资源文件内容copy到新的混淆后的资源文件中。
其五、从原始资源目录mRawResourceFiles中删除掉该已混淆的文件Path
其六、按照Value的index顺序，保存result(如”r/c/a”),即把混淆后的资源项的值缓存下来

下面回到第4步中，继续执行copyOtherResFiles():

12、 copyOtherResFiles()

copyOtherResFiles(){
    ...
    Path resPath = mRawResFile.toPath();
    Path destPath = mOutResFile.toPath();

    //mRawResourceFiles中是剩下的
    for (Path path : mRawResourceFiles) {
        //copy文件内容到dest中
        FileOperation.copyFileUsingStream(path.toFile(), dest.toFile());

    }
}

该函数主要实现了把没有纪录在resources.arsc的资源文件也拷进dest目录。

回到第4步中，继续执行ARSCDecoder.write()：

13、ARSCDecoder.write()

write(){
    ARSCDecoder writer = new ARSCDecoder(arscStream, decoder, pkgs);
    writer.writeTable();
}

writeTable(){
    System.out.printf("writing new resources.arsc \n");
    mTableLenghtChange = 0;
    writeNextChunkCheck(Header.TYPE_TABLE, 0);
    int packageCount = mIn.readInt();
    mOut.writeInt(packageCount);

    //mTableStringsProguard就是上面产生的已混淆的资源项值的字符串池
    mTableLenghtChange += StringBlock.writeTableNameStringBlock(mIn, mOut, mTableStringsProguard);
    ...
    for (int i = 0; i < packageCount; i++) {
        mCurPackageID = i;
        writePackage();
    }
    //最后需要把整个的size重写回去
    reWriteTable();
}

writePackage(){
    checkChunkType(Header.TYPE_PACKAGE);
    int id = (byte) mIn.readInt();
    mOut.writeInt(id);
    mResId = id << 24;
    //char_16的，一共256byte
    mOut.writeBytes(mIn, 256);
    /* typeNameStrings */
    mOut.writeInt(mIn.readInt());
    /* typeNameCount */
    mOut.writeInt(mIn.readInt());
    /* specNameStrings */
    mOut.writeInt(mIn.readInt());
    /* specNameCount */
    mOut.writeInt(mIn.readInt());
    StringBlock.writeAll(mIn, mOut);

    if (mPkgs[mCurPackageID].isCanProguard()) {
        //writeSpecNameStringBlock把混淆后specname重新写入arsc文件
        //其中mCurSpecNameToPos是混淆的specname对应位置
        int specSizeChange = StringBlock.writeSpecNameStringBlock(
            mIn,
            mOut,
            mPkgs[mCurPackageID].getSpecNamesBlock(),
            mCurSpecNameToPos
        );
        mPkgsLenghtChange[mCurPackageID] += specSizeChange;
        mTableLenghtChange += specSizeChange;//重新记录大小
    } else {
        StringBlock.writeAll(mIn, mOut);
    }
    writeNextChunk(0);
    while (mHeader.type == Header.TYPE_LIBRARY) {
        writeLibraryType();
    }
    while (mHeader.type == Header.TYPE_SPEC_TYPE) {
        writeTableTypeSpec();
    }
}

/**
*修改混淆资源项specname对应位置
*/
writeEntry(){
        /* size */
        mOut.writeBytes(mIn, 2);
        short flags = mIn.readShort();
        mOut.writeShort(flags);
        int specNamesId = mIn.readInt();
        ResPackage pkg = mPkgs[mCurPackageID];
        if (pkg.isCanProguard()) {

            //获取资源项specname对应位置
            specNamesId = mCurSpecNameToPos.get(pkg.getSpecRepplace(mResId));
            if (specNamesId < 0) {
                throw new AndrolibException(String.format(
                    "writeEntry new specNamesId < 0 %d", specNamesId));
            }
        }
        //重写位置
        mOut.writeInt(specNamesId);

        if ((flags & ENTRY_FLAG_COMPLEX) == 0) {
            writeValue();
        } else {
            writeComplexEntry();
        }
    }

这一步同样是解析resource.arsc,重新修改arsc文件其中几个字符串池和对应大小，形成新的arsc文件。主要包括：
其一、资源项值字符串池修改，我们需要把文件指向路径改变，例如res/layout/test.xml,改为res/layout/a.xml
其二、资源项key池修改，即specsname除了白名单部分全部废弃，替换成所有我们混淆方案中用到的字符。
其三、每个资源项entry中指向的specsname中的id修正。由于specname已混淆，我们需要用混淆后的资源项specname的位置改写。

回到最开始第2步中，执行 buildApk(decoder, apkFile, signatureType);

14、buildApk()
重新打包生成新的apk并签名等，这一步不再赘述。

以上完成了对apk资源混淆的过程分析。

总结：

资源混淆核心处理过程如下：
1、生成新的资源文件目录，里面对资源文件路径进行混淆(其中涉及如何复用旧的mapping文件)，例如将res/drawable/hello.png混淆为r/s/a.png，并将映射关系输出到mapping文件中。
2、对资源id进行混淆(其中涉及如何复用旧的mapping文件)，并将映射关系输出到mapping文件中。
3、生成新的resources.arsc文件，里面对资源项值字符串池、资源项key字符串池、进行混淆替换，对资源项entry中引用的资源项字符串池位置进行修正、并更改相应大小，并打包生成新的apk。

原文链接https://blog.csdn.net/cg_wang/article/details/70183864
阿里P7移动互联网架构师进阶视频（每日更新中）免费学习请点击：https://space.bilibili.com/474380680