1鳖悠、背景

最近因?yàn)樾枰鑫谋镜淖址幋a解析烈炭，所以引用了 IBM 的一個(gè)開(kāi)源庫(kù)溶锭。不過(guò)這個(gè)庫(kù)體積實(shí)在太大，9M梳庆！講道理暖途，對(duì)于文本編碼方式解析這種功能，如果需要使用 9M 的代碼才能完成確實(shí)有些夸張膏执。所以驻售，我猜想這個(gè)庫(kù)中應(yīng)該包含了一些我并不需要的類(lèi)文件。因此更米，我考慮從這個(gè) jar 包當(dāng)中移除這些我并不需要的類(lèi)文件欺栗。試用手動(dòng)刪除的方式并不容易，因?yàn)槲募嗾髀停乙藐P(guān)系不容易確定迟几。所以，我決定使用 Python 腳本來(lái)做 jar 包瘦身的工作栏笆。

2类腮、常量池解析

了解過(guò) JVM 的都清楚 class 文件的結(jié)構(gòu)。如果蛉加，我們可以解析出這個(gè)類(lèi)引用了哪些類(lèi)蚜枢，然后將被引用的類(lèi)添加到隊(duì)列中依次進(jìn)行遍歷，直到找到所有的引用的類(lèi)针饥，然后將這些被引用到類(lèi)重新打包厂抽。這樣我們就只提取了我們需要用到的類(lèi)，從而實(shí)現(xiàn)了 jar 包的壓縮丁眼。這本質(zhì)上是 class 解析和廣度優(yōu)先搜索的過(guò)程筷凤。

這里，我們先看下幾個(gè)解析 class 常量池的方案苞七。

2.1 方案一：使用 javap 反編譯類(lèi)文件

為了解決這個(gè)問(wèn)題藐守，我首先想到的是使用 javap 反編譯獲取 class 文件中引用的類(lèi)。一開(kāi)始的時(shí)候莽鸭，我使用的是如下指令吗伤，

javap -c -p xxx.class

這種方式解析的結(jié)果如下，

 private static java.util.ArrayList<com.ibm.icu.text.CharsetRecognizer> createRecognizers();
    Code:
       0: new           #14                 // class java/util/ArrayList
       3: dup
       4: invokespecial #15                 // Method java/util/ArrayList."<init>":()V
       7: astore_0
       8: aload_0
       9: new           #39                 // class com/ibm/icu/text/CharsetRecog_UTF8
      12: dup
      13: invokespecial #40                 // Method com/ibm/icu/text/CharsetRecog_UTF8."<init>":()V
      16: invokevirtual #23                 // Method java/util/ArrayList.add:(Ljava/lang/Object;)Z
      19: pop
      20: aload_0
      21: new           #41                 // class com/ibm/icu/text/CharsetRecog_Unicode$CharsetRecog_UTF_16_BE
      24: dup
      25: invokespecial #42                 // Method com/ibm/icu/text/CharsetRecog_Unicode$CharsetRecog_UTF_16_BE."<init>":()V

所以硫眨，我們可以通過(guò)匹配 // Method 這個(gè)關(guān)鍵字來(lái)獲取這個(gè)類(lèi)文件引用的類(lèi)足淆。不過(guò)這種方式存在一個(gè)問(wèn)題，即礁阁，如果一個(gè)類(lèi)不是在方法中引用而是通過(guò) extends 的方式繼承引用的則獲取不到巧号。不過(guò)，對(duì)于繼承的方式也有一個(gè)解決辦法姥闭，即對(duì)于繼承丹鸿，編譯器會(huì)默認(rèn)為子類(lèi)生成構(gòu)造方法并且在構(gòu)造方法中調(diào)用父類(lèi)的構(gòu)造方法，所以我們可以在構(gòu)造方法中獲取到被引用的類(lèi)棚品。但是靠欢，如果是接口的話就無(wú)能為力了廊敌。所以，這種方案還是存在這樣一個(gè)問(wèn)題门怪。

2.2 方案二：使用 javap -verbose 指令輸出常量池

這種方式解析出的常量池如下骡澈，

Constant pool:
    #1 = Methodref          #102.#196     // java/lang/Object."<init>":()V
    #2 = Fieldref           #101.#197     // com/ibm/icu/text/CharsetDetector.fInputBytes:[B
    #3 = Fieldref           #101.#198     // com/ibm/icu/text/CharsetDetector.fByteStats:[S
    #4 = Fieldref           #101.#199     // com/ibm/icu/text/CharsetDetector.fC1Bytes:Z
    #5 = Fieldref           #101.#200     // com/ibm/icu/text/CharsetDetector.fStripTags:Z
    #6 = Fieldref           #101.#201     // com/ibm/icu/text/CharsetDetector.fDeclaredEncoding:Ljava/lang/String;
    #7 = Fieldref           #101.#202     // com/ibm/icu/text/CharsetDetector.fRawInput:[B
    #8 = Fieldref           #101.#203     // com/ibm/icu/text/CharsetDetector.fRawLength:I
    #9 = Fieldref           #101.#204     // com/ibm/icu/text/CharsetDetector.fInputStream:Ljava/io/InputStream;
   #10 = Methodref          #205.#206     // java/io/InputStream.mark:(I)V
   #11 = Methodref          #205.#207     // java/io/InputStream.read:([BII)I
   #12 = Methodref          #205.#208     // java/io/InputStream.reset:()V
   #13 = Methodref          #101.#209     // com/ibm/icu/text/CharsetDetector.detectAll:()[Lcom/ibm/icu/text/CharsetMatch;
   #14 = Class              #210          // java/util/ArrayList
   #15 = Methodref          #14.#196      // java/util/ArrayList."<init>":()V
   #16 = Methodref          #101.#211     // com/ibm/icu/text/CharsetDetector.MungeInput:()V
   #17 = Fieldref           #101.#212     // com/ibm/icu/text/CharsetDetector.fCSRecognizers:Ljava/util/ArrayList;
   #18 = Methodref          #14.#213      // java/util/ArrayList.iterator:()Ljava/util/Iterator;
   #19 = InterfaceMethodref #214.#215     // java/util/Iterator.hasNext:()Z
   #20 = InterfaceMethodref #214.#216     // java/util/Iterator.next:()Ljava/lang/Object;

所以，我們可以在解析出常量池之后通過(guò)字符串匹配的方式獲取引用的類(lèi)掷空。

這種方式是可行的肋殴，不過(guò)相比于下面的一種方案，這種方案的執(zhí)行效率相對(duì)較低坦弟，因?yàn)榉淳幾g過(guò)程中生成了許多我們用不到的信息护锤，此外字符串匹配的過(guò)程效率也不高。

所以酿傍，最終我采用了下面的方案烙懦。

2.3 方案三：手動(dòng)解析常量池

這里復(fù)習(xí)一下 class 文件的結(jié)構(gòu)。下面是一個(gè)比較簡(jiǎn)單的 class 通過(guò) hex 打開(kāi)之后的圖赤炒，

class_structure.png

根據(jù) class 類(lèi)結(jié)構(gòu)的定義：前面四個(gè)字節(jié)（CA FE BA BE）是魔數(shù)修陡；接下來(lái)的兩個(gè)字節(jié)（00 00）是 class 支持的最低的 JDK 的版本，通常數(shù)值在 40~60 之間可霎，即 JDK 的版本魄鸦；再接下來(lái)的兩個(gè)字節(jié)（00 31）是支持的最高的 JDK 的版本；緊接著的兩個(gè)個(gè)字節(jié)（00 1F）是常量池的大小癣朗，這里的值是 31. 需要注意的是常量池的編號(hào)是從 1 開(kāi)始的（可以看上面通過(guò) javap -verbose 輸出的結(jié)果）拾因。這很重要，因?yàn)槌Ａ砍刂谐Ａ繒?huì)通過(guò)這個(gè)編號(hào)引用其他常量旷余。

對(duì)于常量池中的常量绢记，其部分定義如下

constant_pool_def.png

這里的 u1, u2, u4 和 u8 分別表示一個(gè)、兩個(gè)正卧、四個(gè)和八個(gè)字節(jié)的意思蠢熄。對(duì)于每個(gè)常量，都是以一個(gè)字節(jié)的 tag 作為起始的標(biāo)志炉旷。每個(gè)常量的長(zhǎng)度除了 tag 為 1 的常量之外都是固定的签孔。比如 tag 為 3 的除了 tag 之外還占用 4 個(gè)字節(jié)；tag 為 5 的除了 tag 之外還占用 8 個(gè)字節(jié)窘行。對(duì)于 tag 為 1 的常量饥追，它表示字符串類(lèi)型，通常用來(lái)定義類(lèi)和方法的名稱(chēng)等罐盔。緊跟著 tag 1 的兩個(gè)字節(jié)表示這個(gè)常量的字節(jié)的長(zhǎng)度但绕，比如如果它的值是 5 的話，那么接下來(lái)的 5 個(gè)字節(jié)就是這個(gè)字符串的具體內(nèi)容。

了解了常量池的規(guī)則之后捏顺，我們就可以通過(guò) Python 腳本來(lái)實(shí)現(xiàn)常量池的解析六孵，

class PoolParser:
    def __init__(self):
        self.constants = {
            3: 4, 4: 4, 5: 8, 6: 8, 7: 2, 8: 2, 9: 4, 10: 4, 
            11: 4, 12: 4, 15: 3, 16: 2, 17: 4, 18: 4, 19: 2, 20: 2
        }

    def parse(self, path: str) -> List[str]:
        '''Parse constant pool of class file with path.'''
        try:
            with open(path, 'rb') as fp:
                data = fp.read()
            constant_count = data[8] * 16 * 16 + data[9]
            cur_constant_index = 1
            index = 10
            sequences = {}
            classes_nums = []
            while cur_constant_index < constant_count:
                constant_code = data[index]
                if constant_code == 1:
                    char_length = data[index+1]*16*16+data[index+2]
                    char_start = index+3
                    char_end = char_start+char_length
                    # print(str(cur_constant_index) + '/' + str(constant_count) + ': ' + str(data[char_start:char_end], 'utf-8'))
                    sequences[cur_constant_index] = str(data[char_start:char_end], 'utf-8')
                    index = index + 2 + char_length + 1
                    cur_constant_index = cur_constant_index + 1
                elif constant_code == 5 or constant_code == 6:
                    # Special guideline for double and long type, see https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.4.5
                    index = index + self.constants[constant_code] + 1
                    cur_constant_index = cur_constant_index + 2
                else:
                    # Get number of class in the constant pool.
                    if constant_code == 7:
                        classes_nums.append(data[index+1]*16*16+data[index+2])
                    index = index + self.constants[constant_code] + 1
                    cur_constant_index = cur_constant_index + 1
            return [sequences[num] for num in classes_nums]
        except BaseException as e:
            logging.error("Error while parsing constant pool:\n%s" % traceback.format_exc())
            print("Error while parsing constant pool for [%s]" % path)
            return []

這里的邏輯是解析出常量池的長(zhǎng)度之后進(jìn)行遍歷，每次遞增一幅骄，直到將所有的常量全部解析出來(lái)狸臣。這里有幾個(gè)細(xì)節(jié)需要注意：

• 對(duì)于 tag 為 5 和 6 的常量（實(shí)際就是 long 和 double 類(lèi)型定義的常量）他們占用兩個(gè)編號(hào)。這個(gè)定義感覺(jué)有些奇葩昌执。如果不是看了 Oracle 的官方文檔，一般的書(shū)還真查不到這個(gè)诈泼。就是說(shuō)懂拾，如果一個(gè) class 文件的常量池的大小部分的值是 30 并且常量池中包含了一個(gè) double 類(lèi)型，那么它實(shí)際只有 29 個(gè)常量而不是 30 個(gè)铐达，因?yàn)?double 占了兩個(gè)編號(hào)岖赋，盡管 class 文件上的布局是連續(xù)的。

• 確定常量池中的 class 的時(shí)候用到了 tag 為 7 的常量瓮孙。這個(gè)常量 tag 之后的兩個(gè)字節(jié)就是 class 的內(nèi)容唐断。所以，這是一種準(zhǔn)確的找到常量池中的 class 的方法杭抠。（class 被放到 tag 為 1 的常量中脸甘，實(shí)際是作為 uft8 類(lèi)型的字符串處理的）

• 最后，Oracle 對(duì)于 JVM 定義詳細(xì)的文檔：https://docs.oracle.com/javase/specs/jvms/se7/html/jvms-4.html#jvms-4.4.5偏灿，感興趣的可以自己查找丹诀，比任何書(shū)籍都更加全面。

3翁垂、整體的腳本實(shí)現(xiàn)

3.1 jar 包解析

jar 使用的是 zip 文件格式铆遭。對(duì)于 Android 的應(yīng)用場(chǎng)景，因?yàn)槲覀儽旧聿粚?jar 作為可執(zhí)行文件使用沿猜，所以對(duì)于 jar 的格式要求就低得多枚荣。基本使用 Python 的 zip 庫(kù)解壓啼肩，然后使用 jar 指令打包即可橄妆。這里 Zip 解包的邏輯是，

def _unzip_jar(self):
    '''Unzip the jar.'''
    print("Unzip jar ...")
    logging.info("Unzip jar ...")
    self.unzip_to = str(int(time.time()))
    try:
        with open(self.jar_path, 'rb') as fp:
            data = fp.read()
        self.unzip_to = hashlib.md5(data).hexdigest()
    except BaseException as e:
        logging.error("Error while reading the jar md5:\n%s" % traceback.format_exc())
        print("Error while reading the jar md5 [%s]" % self.jar_path)
    self.unzip_to = 'space/%s/unzip' % self.unzip_to
    if not os.path.exists(self.unzip_to):
        try:
            zipFile = zipfile.ZipFile(self.jar_path)
            zipFile.extractall(self.unzip_to)
            zipFile.close()
        except BaseException as e:
            logging.error("Error while unzip the jar:\n%s" % traceback.format_exc())
            print("Error while unzip the jar [%s]" % self.jar_path)
    else:
        logging.info("Unziped resources exists, ignore!")
        print("Unziped resources exists, ignore!")

邏輯比較簡(jiǎn)單祈坠，即先讀取 jar 文件的 md5 來(lái)判斷指定的 jar 的解壓文件是否存在呼畸，如果存在就直接使用，否則再做一遍解壓操作颁虐。

3.2 廣度優(yōu)先搜索

這里我用到的是基于隊(duì)列的廣度優(yōu)先算法蛮原。

def _search_by_read_constants(self):
    '''Search by parsing constants.'''
    print("Searching classes by parsing constant pool ...")
    logging.info("Searching classes by parsing constant pool ...")
    start = int(time.time())
    self.classes = [os.path.join(self.unzip_to, cls.replace('.', '/')) + '.class' for cls in self.classes]
    visits = []
    visits.extend(self.classes)
    count = 0
    parser = PoolParser()
    while len(visits) > 0:
        count = count + 1
        cur_path = visits.pop()
        exists = os.path.exists(cur_path)
        logging.info("Searching under [%d][%s][%s]" % (count, str(exists), self._simplify_class_path(cur_path)))
        print("Searching under [%d][%s][%s]" % (count, str(exists), self._simplify_class_path(cur_path)), end='\r')
        # Ignore if the class file not exists.
        if not exists:
            self.classes.remove(cur_path)
            continue
        # Parse classes from class constant pool.
        classes = parser.parse(cur_path)
        for cls in classes:
            self._handle_classes(cls, cur_path, visits)
    logging.info("Searching classes by parsing constant pool done in [%d]" % (int(time.time())-start))
    print("Searching classes by parsing constant pool done in [%d]" % (int(time.time())-start))

def _handle_classes(self, cls: str, cur_path: str, visits: List[str]):
    '''Handle classes.'''
    pathes = [cls]
    # Handle if the class is an inner class.
    if cls.rfind('$') > 0:
        pos = cls.rfind('$')
        while pos > 0:
            cls = cls[0:pos]
            pathes.append(cls)
            pos = cls.rfind('$')
    for path in pathes:
        cls_path = os.path.join(self.unzip_to, path) + '.class'
        # Only search one class a time.
        if cls_path not in self.classes:
            self.classes.append(cls_path)
            visits.append(cls_path)
            logging.info("Found [%s] under [%s]" % (path, self._simplify_class_path(cur_path)))

這里以啟動(dòng)腳本的時(shí)候傳入的執(zhí)行類(lèi)作為起點(diǎn)進(jìn)行遍歷，判斷這個(gè)文件是否存在于本地另绩。因?yàn)橛幸恍?biāo)準(zhǔn)庫(kù)中引用到的類(lèi)并不在我們的 jar 包當(dāng)中儒陨，所以這一操作是為了將這類(lèi)的文件排除掉花嘶。然后，這里使用了我們前面介紹的 class 常量池解析邏輯從 class 中解析這個(gè)引用到的其他的類(lèi)并將其他們加入到隊(duì)列中繼續(xù)進(jìn)行遍歷蹦漠。直到整個(gè)隊(duì)列為空椭员，則表明程序執(zhí)行結(jié)束。

這里有個(gè)細(xì)節(jié)需要注意笛园，即內(nèi)部類(lèi)的處理隘击。對(duì)于形如 AAA$BBB$CCC 有一個(gè)要求，我們?cè)诖虬臅r(shí)候必須將外部類(lèi)同時(shí)打入到包中研铆，否則內(nèi)部類(lèi)不會(huì)被打進(jìn)最終的 jar 文件中埋同。這里我寫(xiě)了一段程序來(lái)解析上述類(lèi)型的內(nèi)部類(lèi)及其父類(lèi)，即 _handle_classes() 方法中的前幾行代碼棵红。

3.3 jar 打包

對(duì)于 jar 打包凶赁，我們最好還是使用官方的 jar 指令來(lái)完成。打包的時(shí)候逆甜，一種方式是將我們的所有的類(lèi)通過(guò)拼接的方式組成一個(gè)指令虱肄。不過(guò)因?yàn)橛袝r(shí)候包含的類(lèi)太多，這種方式會(huì)造成打包的指令非常長(zhǎng)交煞。所以咏窿，后來(lái)我換了另外一種方案。即將所有用到的類(lèi)文件考本到一個(gè)目錄下面素征，然后再針對(duì)這個(gè)目錄進(jìn)行打包翰灾。即，

def _pack_classes(self):
    '''Packing casses.'''
    print("Packing classes ...")
    logging.info("Packing classes ...")
    if not os.path.exists(self.output):
        os.mkdir(self.output
    # Copy all filted classes to a directory.
    for cls in self.classes:
        dst = cls.replace(self.unzip_to, self.copy_to)
        par = os.path.dirname(dst)
        if not os.path.exists(par):
            os.makedirs(par)
        shutil.copyfile(cls, dst)
    # Get into the copied directory and use jar to package the directory.
    pack_command = 'cd %s && jar cvf %s/final.jar %s' % (self.copy_to, self.output, '.')
    logging.info("PACK COMMAND: %s" % pack_command)
    ret = os.popen(pack_command).read().strip()

4稚茅、效果

因?yàn)楸旧硎轻槍?duì) jar 包的瘦身纸淮，所以實(shí)際執(zhí)行的效果要取決于 jar 包的具體情況。比如亚享，上述我引用的 IBM 的 jar 包經(jīng)過(guò)瘦身之后咽块，從 9M 精簡(jiǎn)到了 1M 大小。

5欺税、限制

• 現(xiàn)在的方案還不是最極致的優(yōu)化：因?yàn)楝F(xiàn)在的方案只要在一個(gè)類(lèi)文件中出現(xiàn)就會(huì)被加入到最終的 jar 包當(dāng)中侈沪，而我們需要用到的方法可能并不會(huì)用到這些類(lèi)。所以晚凿，如果做方法級(jí)別的掃描就能夠排除更多的沒(méi)必要的類(lèi)文件亭罪。不過(guò)，如果做方法級(jí)別的掃描歼秽，還需要面都崩潰堆椨σ郏可能和實(shí)際的代碼對(duì)不上的問(wèn)題。
• 此外，對(duì)于在 so 中引用到的方法現(xiàn)在還無(wú)能為力箩祥。

總結(jié)

上面是 Android 包體積優(yōu)化的技巧之一吧院崇。我之前看到過(guò)有的團(tuán)隊(duì)做 dex 級(jí)別的優(yōu)化，如果按照上面這種思路袍祖，從整個(gè) Android 包體積中做優(yōu)化底瓣，排除用不到的 class 文件，效果會(huì)比 dex 級(jí)別優(yōu)化效果要好一些蕉陋。不過(guò)捐凭，對(duì)于 Android 而言，遇到的情況可能會(huì)更加復(fù)雜凳鬓，比如 so 中進(jìn)行調(diào)用以及加密和反射等情況茁肠。

開(kāi)源地址：https://github.com/Shouheng88/jarjar