Java 反編譯工具的對比以及使用方法

今天就跟大家聊聊有關Java 反編譯工具的對比以及使用方法，可能很多人都不太了解，為了讓大家更加了解，小編給大家總結了以下內容，希望大家根據這篇文章可以有所收獲。

前言

Java 反編譯，一聽可能覺得高深莫測，其實反編譯并不是什么特別高級的操作，Java 對于 Class 字節碼文件的生成有著嚴格的要求，如果你非常熟悉  Java 虛擬機規范，了解 Class 字節碼文件中一些字節的作用，那么理解反編譯的原理并不是什么問題。甚至像下面這樣的 Class  文件你都能看懂一二。

一般在逆向研究和代碼分析中，反編譯用到的比較多。不過在日常開發中，有時候只是簡單的看一下所用依賴類的反編譯，也是十分重要的。

恰好最近工作中也需要用到 Java 反編譯，所以這篇文章介紹目前常見的的幾種 Java  反編譯工具的使用，在文章的最后也會通過編譯速度、語法支持以及代碼可讀性三個維度，對它們進行測試，分析幾款工具的優缺點。

Procyon

Github 鏈接：https://github.com/mstrobel/procyon

Procyon 不僅僅是反編譯工具，它其實是專注于 Java 代碼的生成和分析的一整套的 Java 元編程工具。主要包括下面幾個部分：

• Core Framework

• Reflection Framework

• Expressions Framework

• Compiler Toolset (Experimental)

• Java Decompiler (Experimental)

可以看到反編譯只是 Procyon 的其中一個模塊，Procyon 原來托管于 bitbucket，后來遷移到了 GitHub，根據 GitHub  的提交記錄來看，也有將近兩年沒有更新了。不過也有依賴 Procyon 的其他的開源反編譯工具如**  decompiler-procyon**，更新頻率還是很高的，下面也會選擇這個工具進行反編譯測試。

使用 Procyon

<!-- https://mvnrepository.com/artifact/org.jboss.windup.decompiler/decompiler-procyon --> <dependency>     <groupId>org.jboss.windup.decompiler</groupId>     <artifactId>decompiler-procyon</artifactId>     <version>5.1.4.Final</version> </dependency>

寫一個簡單的反編譯測試。

package com.wdbyte.decompiler;  import java.io.IOException; import java.nio.file.Path; import java.nio.file.Paths; import java.util.Iterator; import java.util.List;  import org.jboss.windup.decompiler.api.DecompilationFailure; import org.jboss.windup.decompiler.api.DecompilationListener; import org.jboss.windup.decompiler.api.DecompilationResult; import org.jboss.windup.decompiler.api.Decompiler; import org.jboss.windup.decompiler.procyon.ProcyonDecompiler;  /**  * Procyon 反編譯測試  *  *  @author https://github.com/niumoo  * @date 2021/05/15  */ public class ProcyonTest {     public static void main(String[] args) throws IOException {         Long time = procyon("decompiler.jar", "procyon_output_jar");         System.out.println(String.format("decompiler time: %dms", time));     }     public static Long procyon(String source,String targetPath) throws IOException {         long start = System.currentTimeMillis();         Path outDir = Paths.get(targetPath);         Path archive = Paths.get(source);         Decompiler dec = new ProcyonDecompiler();         DecompilationResult res = dec.decompileArchive(archive, outDir, new DecompilationListener() {             public void decompilationProcessComplete() {                 System.out.println("decompilationProcessComplete");             }             public void decompilationFailed(List<String> inputPath, String message) {                 System.out.println("decompilationFailed");             }             public void fileDecompiled(List<String> inputPath, String outputPath) {             }             public boolean isCancelled() {                 return false;             }         });          if (!res.getFailures().isEmpty()) {             StringBuilder sb = new StringBuilder();             sb.append("Failed decompilation of " + res.getFailures().size() + " classes: ");             Iterator failureIterator = res.getFailures().iterator();             while (failureIterator.hasNext()) {                 DecompilationFailure dex = (DecompilationFailure)failureIterator.next();                 sb.append(System.lineSeparator() + "    ").append(dex.getMessage());             }             System.out.println(sb.toString());         }         System.out.println("Compilation results: " + res.getDecompiledFiles().size() + " succeeded, " + res.getFailures().size() + " failed.");         dec.close();         Long end = System.currentTimeMillis();         return end - start;     } }

Procyon 在反編譯時會實時輸出反編譯文件數量的進度情況，最后還會統計反編譯成功和失敗的 Class 文件數量。

.... 五月 15, 2021 10:58:28 下午 org.jboss.windup.decompiler.procyon.ProcyonDecompiler$3 call 信息: Decompiling 650 / 783 五月 15, 2021 10:58:30 下午 org.jboss.windup.decompiler.procyon.ProcyonDecompiler$3 call 信息: Decompiling 700 / 783 五月 15, 2021 10:58:37 下午 org.jboss.windup.decompiler.procyon.ProcyonDecompiler$3 call 信息: Decompiling 750 / 783 decompilationProcessComplete Compilation results: 783 succeeded, 0 failed. decompiler time: 40599ms

Procyon GUI

對于 Procyon 反編譯來說，在 GitHub 上也有基于此實現的開源 GUI 界面，感興趣的可以下載嘗試。

Github 地址：https://github.com/deathmarine/Luyten

CFR

GitHub 地址：https://github.com/leibnitz27/cfr

CFR 官方網站：http://www.benf.org/other/cfr/(可能需要FQ)

Maven 倉庫：https://mvnrepository.com/artifact/org.benf/cfr

CFR(Class File Reader) 可以支持 Java 9、Java 12、Java 14 以及其他的最新版 Java 代碼的反編譯工作。而且  CFR 本身的代碼是由 Java 6 編寫，所以基本可以使用 CFR 在任何版本的 Java 程序中。值得一提的是，使用 CFR 甚至可以將使用其他語言編寫的的  JVM 類文件反編譯回 Java 文件。

CFR 命令行使用

使用 CFR 反編譯時，你可以下載已經發布的 JAR 包，進行命令行反編譯，也可以使用 Maven  引入的方式，在代碼中使用。下面先說命令行運行的方式。

直接在 GitHub Tags 下載已發布的最新版 JAR. 可以直接運行查看幫助。

# 查看幫助 java -jar cfr-0.151.jar --help

如果只是反編譯某個 class.

# 反編譯 class 文件，結果輸出到控制臺 java -jar cfr-0.151.jar WindupClasspathTypeLoader.class # 反編譯 class 文件，結果輸出到 out 文件夾 java -jar cfr-0.151.jar WindupClasspathTypeLoader.class --outputpath ./out

反編譯某個 JAR.

# 反編譯 jar 文件，結果輸出到 output_jar 文件夾 ?  Desktop java -jar cfr-0.151.jar decompiler.jar --outputdir ./output_jar Processing decompiler.jar (use silent to silence) Processing com.strobel.assembler.metadata.ArrayTypeLoader Processing com.strobel.assembler.metadata.ParameterDefinition Processing com.strobel.assembler.metadata.MethodHandle Processing com.strobel.assembler.metadata.signatures.FloatSignature

反編譯結果會按照 class 的包路徑寫入到指定文件夾中。

CFR 代碼中使用

添加依賴這里不提。

<!-- https://mvnrepository.com/artifact/org.benf/cfr --> <dependency>     <groupId>org.benf</groupId>     <artifactId>cfr</artifactId>     <version>0.151</version> </dependency>

實際上我在官方網站和 GitHub 上都沒有看到具體的單元測試示例。不過沒有關系，既然能在命令行運行，那么直接在 IDEA 中查看反編譯后的 Main  方法入口，看下命令行是怎么執行的，就可以寫出自己的單元測試了。

package com.wdbyte.decompiler;  import java.io.IOException; import java.util.ArrayList; import java.util.HashMap; import java.util.List;  import org.benf.cfr.reader.api.CfrDriver; import org.benf.cfr.reader.util.getopt.OptionsImpl;  /**  * CFR Test  *  * @author https://github.com/niumoo  * @date 2021/05/15  */ public class CFRTest {     public static void main(String[] args) throws IOException {         Long time = cfr("decompiler.jar", "./cfr_output_jar");         System.out.println(String.format("decompiler time: %dms", time));         // decompiler time: 11655ms     }     public static Long cfr(String source, String targetPath) throws IOException {         Long start = System.currentTimeMillis();         // source jar         List<String> files = new ArrayList<>();         files.add(source);         // target dir         HashMap<String, String> outputMap = new HashMap<>();         outputMap.put("outputdir", targetPath);          OptionsImpl options = new OptionsImpl(outputMap);         CfrDriver cfrDriver = new CfrDriver.Builder().withBuiltOptions(options).build();         cfrDriver.analyse(files);         Long end = System.currentTimeMillis();         return (end - start);     } }

JD-Core

GiHub 地址：https://github.com/java-decompiler/jd-core

JD-core 官方網址：https://java-decompiler.github.io/

JD-core 是一個的獨立的 Java 庫，可以用于 Java 的反編譯，支持從 Java 1 至 Java 12 的字節碼反編譯，包括 Lambda  表達式、方式引用、默認方法等。知名的 JD-GUI 和 Eclipse 無縫集成反編譯引擎就是 JD-core。JD-core  提供了一些反編譯的核心功能，也提供了單獨的 Class 反編譯方法，但是如果你想在自己的代碼中去直接反編譯整個 JAR  包，還是需要一些改造的，如果是代碼中有匿名函數，Lambda 等，雖然可以直接反編譯，不過也需要額外考慮。

使用 JD-core

<!-- https://mvnrepository.com/artifact/org.jd/jd-core -->         <dependency>             <groupId>org.jd</groupId>             <artifactId>jd-core</artifactId>             <version>1.1.3</version>         </dependency>

為了可以反編譯整個 JAR 包，使用的代碼我做了一些簡單改造，以便于最后一部分的對比測試，但是這個示例中沒有考慮內部類，Lambda 等會編譯出多個  Class 文件的情況，所以不能直接使用在生產中。

package com.wdbyte.decompiler;  import java.io.File; import java.io.IOException; import java.io.InputStream; import java.nio.file.Files; import java.nio.file.Path; import java.nio.file.Paths; import java.util.Enumeration; import java.util.HashMap; import java.util.jar.JarFile; import java.util.zip.ZipEntry; import java.util.zip.ZipFile;  import org.apache.commons.io.IOUtils; import org.apache.commons.lang3.StringUtils; import org.jd.core.v1.ClassFileToJavaSourceDecompiler; import org.jd.core.v1.api.loader.Loader; import org.jd.core.v1.api.printer.Printer;  /**  * @author https://github.com/niumoo  * @date 2021/05/15  */ public class JDCoreTest {      public static void main(String[] args) throws Exception {         JDCoreDecompiler jdCoreDecompiler = new JDCoreDecompiler();         Long time = jdCoreDecompiler.decompiler("decompiler.jar","jd_output_jar");         System.out.println(String.format("decompiler time: %dms", time));     } }   class JDCoreDecompiler{      private ClassFileToJavaSourceDecompiler decompiler = new ClassFileToJavaSourceDecompiler();     // 存放字節碼     private HashMap<String,byte[]> classByteMap = new HashMap<>();      /**      * 注意：沒有考慮一個 Java 類編譯出多個 Class 文件的情況。      *       * @param source      * @param target      * @return      * @throws Exception      */     public Long decompiler(String source,String target) throws Exception {         long start = System.currentTimeMillis();         // 解壓         archive(source);         for (String className : classByteMap.keySet()) {             String path = StringUtils.substringBeforeLast(className, "/");             String name = StringUtils.substringAfterLast(className, "/");             if (StringUtils.contains(name, "$")) {                 name = StringUtils.substringAfterLast(name, "$");             }             name = StringUtils.replace(name, ".class", ".java");             decompiler.decompile(loader, printer, className);             String context = printer.toString();             Path targetPath = Paths.get(target + "/" + path + "/" + name);             if (!Files.exists(Paths.get(target + "/" + path))) {                 Files.createDirectories(Paths.get(target + "/" + path));             }             Files.deleteIfExists(targetPath);             Files.createFile(targetPath);             Files.write(targetPath, context.getBytes());         }         return System.currentTimeMillis() - start;     }     private void archive(String path) throws IOException {         try (ZipFile archive = new JarFile(new File(path))) {             Enumeration<? extends ZipEntry> entries = archive.entries();             while (entries.hasMoreElements()) {                 ZipEntry entry = entries.nextElement();                 if (!entry.isDirectory()) {                     String name = entry.getName();                     if (name.endsWith(".class")) {                         byte[] bytes = null;                         try (InputStream stream = archive.getInputStream(entry)) {                             bytes = IOUtils.toByteArray(stream);                         }                         classByteMap.put(name, bytes);                     }                 }             }         }     }      private Loader loader = new Loader() {         @Override         public byte[] load(String internalName) {             return classByteMap.get(internalName);         }         @Override         public boolean canLoad(String internalName) {             return classByteMap.containsKey(internalName);         }     };      private Printer printer = new Printer() {         protected static final String TAB = "  ";         protected static final String NEWLINE = "\n";         protected int indentationCount = 0;         protected StringBuilder sb = new StringBuilder();         @Override public String toString() {             String toString = sb.toString();             sb = new StringBuilder();             return toString;         }         @Override public void start(int maxLineNumber, int majorVersion, int minorVersion) {}         @Override public void end() {}         @Override public void printText(String text) { sb.append(text); }         @Override public void printNumericConstant(String constant) { sb.append(constant); }         @Override public void printStringConstant(String constant, String ownerInternalName) { sb.append(constant); }         @Override public void printKeyword(String keyword) { sb.append(keyword); }         @Override public void printDeclaration(int type, String internalTypeName, String name, String descriptor) { sb.append(name); }         @Override public void printReference(int type, String internalTypeName, String name, String descriptor, String ownerInternalName) { sb.append(name); }         @Override public void indent() { this.indentationCount++; }         @Override public void unindent() { this.indentationCount--; }         @Override public void startLine(int lineNumber) { for (int i=0; i<indentationCount; i++) sb.append(TAB); }         @Override public void endLine() { sb.append(NEWLINE); }         @Override public void extraLine(int count) { while (count-- > 0) sb.append(NEWLINE); }         @Override public void startMarker(int type) {}         @Override public void endMarker(int type) {}     }; }

JD-GUI

GitHub 地址：https://github.com/java-decompiler/jd-gui

JD-core 也提供了官方的 GUI 界面，需要的也可以直接下載嘗試。

Jadx

GitHub 地址：https://github.com/skylot/jadx

Jadx 是一款可以反編譯 JAR、APK、DEX、AAR、AAB、ZIP 文件的反編譯工具，并且也配有 Jadx-gui 用于界面操作。Jadx 使用  Grade 進行依賴管理，可以自行克隆倉庫打包運行。

git clone https://github.com/skylot/jadx.git cd jadx ./gradlew dist # 查看幫助  ./build/jadx/bin/jadx --help   jadx - dex to java decompiler, version: dev  usage: jadx [options] <input files> (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab) options:   -d, --output-dir                    - output directory   -ds, --output-dir-src               - output directory for sources   -dr, --output-dir-res               - output directory for resources   -r, --no-res                        - do not decode resources   -s, --no-src                        - do not decompile source code   --single-class                      - decompile a single class   --output-format                     - can be 'java' or 'json', default: java   -e, --export-gradle                 - save as android gradle project   -j, --threads-count                 - processing threads count, default: 6   --show-bad-code                     - show inconsistent code (incorrectly decompiled)   --no-imports                        - disable use of imports, always write entire package name   --no-debug-info                     - disable debug info   --add-debug-lines                   - add comments with debug line numbers if available   --no-inline-anonymous               - disable anonymous classes inline   --no-replace-consts                 - don't replace constant value with matching constant field   --escape-unicode                    - escape non latin characters in strings (with \u)   --respect-bytecode-access-modifiers - don't change original access modifiers   --deobf                             - activate deobfuscation   --deobf-min                         - min length of name, renamed if shorter, default: 3   --deobf-max                         - max length of name, renamed if longer, default: 64   --deobf-cfg-file                    - deobfuscation map file, default: same dir and name as input file with '.jobf' extension   --deobf-rewrite-cfg                 - force to save deobfuscation map   --deobf-use-sourcename              - use source file name as class name alias   --deobf-parse-kotlin-metadata       - parse kotlin metadata to class and package names   --rename-flags                      - what to rename, comma-separated, 'case' for system case sensitivity, 'valid' for java identifiers, 'printable' characters, 'none' or 'all' (default)   --fs-case-sensitive                 - treat filesystem as case sensitive, false by default   --cfg                               - save methods control flow graph to dot file   --raw-cfg                           - save methods control flow graph (use raw instructions)   -f, --fallback                      - make simple dump (using goto instead of 'if', 'for', etc)   -v, --verbose                       - verbose output (set --log-level to DEBUG)   -q, --quiet                         - turn off output (set --log-level to QUIET)   --log-level                         - set log level, values: QUIET, PROGRESS, ERROR, WARN, INFO, DEBUG, default: PROGRESS   --version                           - print jadx version   -h, --help                          - print this help Example:   jadx -d out classes.dex

根據 HELP 信息，如果想要反編譯 decompiler.jar 到 out 文件夾。

./build/jadx/bin/jadx -d ./out ~/Desktop/decompiler.jar  INFO  - loading ... INFO  - processing ... INFO  - doneress: 1143 of 1217 (93%)

Fernflower

GitHub 地址：https://github.com/fesh0r/fernflower

Fernflower 和 Jadx 一樣使用 Grade 進行依賴管理，可以自行克隆倉庫打包運行。

?  fernflower-master ./gradlew build  BUILD SUCCESSFUL in 32s 4 actionable tasks: 4 executed  ?  fernflower-master java -jar build/libs/fernflower.jar Usage: java -jar fernflower.jar [-<option>=<value>]* [<source>]+ <destination> Example: java -jar fernflower.jar -dgs=true c:\my\source\ c:\my.jar d:\decompiled\  ?  fernflower-master mkdir out ?  fernflower-master java -jar build/libs/fernflower.jar ~/Desktop/decompiler.jar ./out INFO:  Decompiling class com/strobel/assembler/metadata/ArrayTypeLoader INFO:  ... done INFO:  Decompiling class com/strobel/assembler/metadata/ParameterDefinition INFO:  ... done INFO:  Decompiling class com/strobel/assembler/metadata/MethodHandle ...  ?  fernflower-master ll out total 1288 -rw-r--r--  1 darcy  staff   595K  5 16 17:47 decompiler.jar ?  fernflower-master

Fernflower 在反編譯 JAR 包時，默認反編譯的結果也是一個 JAR 包。Jad

反編譯速度

到這里已經介紹了五款 Java  反編譯工具了，那么在日常開發中我們應該使用哪一個呢?又或者在代碼分析時我們又該選擇哪一個呢?我想這兩種情況的不同，使用時的關注點也是不同的。如果是日常使用，讀讀代碼，我想應該是對可讀性要求更高些，如果是大量的代碼分析工作，那么可能反編譯的速度和語法的支持上要求更高些。為了能有一個簡單的參考數據，我使用  JMH 微基準測試工具分別對這五款反編譯工具進行了簡單的測試，下面是一些測試結果。

測試環境

反編譯 JAR 1：procyon-compilertools-0.5.33.jar (1.5 MB)

JAR 2 這個包是比較大的，是拿很多代碼倉庫合并到一起的，同時還有很多 Python 轉 Java 生成的代碼，理論上代碼的復雜度會更高。

語法支持和可讀性

如果反編譯后的代碼需要自己看的話，那么可讀性更好的代碼更占優勢，下面我寫了一些代碼，主要是 Java 8  及以下的代碼語法和一些嵌套的流程控制，看看反編譯后的效果如何。

package com.wdbyte.decompiler;  import java.util.ArrayList; import java.util.List; import java.util.stream.IntStream;  import org.benf.cfr.reader.util.functors.UnaryFunction;  /**  * @author https://www.wdbyte.com  * @date 2021/05/16  */ public class HardCode <A, B> {     public HardCode(A a, B b) { }      public static void test(int... args) { }      public static void main(String... args) {         test(1, 2, 3, 4, 5, 6);     }      int byteAnd0() {         int b = 1;         int x = 0;         do {             b = (byte)((b ^ x));         } while (b++ < 10);         return b;     }      private void a(Integer i) {         a(i);         b(i);         c(i);     }      private void b(int i) {         a(i);         b(i);         c(i);     }      private void c(double d) {         c(d);         d(d);     }      private void d(Double d) {         c(d);         d(d);     }      private void e(Short s) {         b(s);         c(s);         e(s);         f(s);     }      private void f(short s) {         b(s);         c(s);         e(s);         f(s);     }      void test1(String path) {         try {             int x = 3;         } catch (NullPointerException t) {             System.out.println("File Not found");             if (path == null) { return; }             throw t;         } finally {             System.out.println("Fred");             if (path == null) { throw new IllegalStateException(); }         }     }      private final List<Integer> stuff = new ArrayList<>();{         stuff.add(1);         stuff.add(2);     }      public static int plus(boolean t, int a, int b) {         int c = t ? a : b;         return c;     }      // Lambda     Integer lambdaInvoker(int arg, UnaryFunction<Integer, Integer> fn) {         return fn.invoke(arg);     }      // Lambda     public int testLambda() {         return lambdaInvoker(3, x -> x + 1);         //        return 1;     }      // Lambda     public Integer testLambda(List<Integer> stuff, int y, boolean b) {         return stuff.stream().filter(b ? x -> x > y : x -> x < 3).findFirst().orElse(null);     }      // stream     public static <Y extends Integer> void testStream(List<Y> list) {         IntStream s = list.stream()             .filter(x -> {                 System.out.println(x);                 return x.intValue() / 2 == 0;                 })             .map(x -> (Integer)x+2)             .mapToInt(x -> x);         s.toArray();     }      // switch     public void testSwitch2(){         int i = 0;         switch(((Long)(i + 1L)) + "") {             case "1":                 System.out.println("one");         }     }     // switch     public void testSwitch3(String string){         switch (string) {             case "apples":                 System.out.println("apples");                 break;             case "pears":                 System.out.println("pears");                 break;         }     }      // switch     public static void testSwitch4(int x) {         while (true) {             if (x < 5) {                 switch ("test") {                     case "okay":                         continue;                     default:                         continue;                 }             }             System.out.println("wow x2!");         }     } }

此處本來貼出了所有工具的反編譯結果，但是礙于文章長度和閱讀體驗，沒有放出來，不過我在個人博客的發布上是有完整代碼的，個人網站排版比較自由，可以使用 Tab  選項卡的方式展示。如果需要查看可以訪問 https://www.wdbyte.com 進行查看。

Procyon

看到 Procyon  的反編譯結果，還是比較吃驚的，在正常反編譯的情況下，反編譯后的代碼基本上都是原汁原味。唯一一處反編譯后和源碼語法上有變化的地方，是一個集合的初始化操作略有不同。

// 源碼  public HardCode(A a, B b) { }  private final List<Integer> stuff = new ArrayList<>();{     stuff.add(1);     stuff.add(2);  } // Procyon 反編譯 private final List<Integer> stuff;      public HardCode(final A a, final B b) {     (this.stuff = new ArrayList<Integer>()).add(1);     this.stuff.add(2); }

而其他部分代碼， 比如裝箱拆箱，Switch 語法，Lambda 表達式，流式操作以及流程控制等，幾乎完全一致，閱讀沒有障礙。

裝箱拆箱操作反編譯后完全一致，沒有多余的類型轉換代碼。

// 源碼 private void a(Integer i) {     a(i);     b(i);     c(i); }  private void b(int i) {     a(i);     b(i);     c(i); }  private void c(double d) {     c(d);     d(d); }  private void d(Double d) {     c(d);     d(d); }  private void e(Short s) {     b(s);     c(s);     e(s);     f(s); }  private void f(short s) {     b(s);     c(s);     e(s);     f(s); } // Procyon 反編譯 private void a(final Integer i) {     this.a(i);     this.b(i);     this.c(i); }  private void b(final int i) {     this.a(i);     this.b(i);     this.c(i); }  private void c(final double d) {     this.c(d);     this.d(d); }  private void d(final Double d) {     this.c(d);     this.d(d); }  private void e(final Short s) {     this.b(s);     this.c(s);     this.e(s);     this.f(s); }  private void f(final short s) {     this.b(s);     this.c(s);     this.e(s);     this.f(s); }

Switch 部分也是一致，流程控制部分也沒有變化。

// 源碼 switch public void testSwitch2(){     int i = 0;     switch(((Long)(i + 1L)) + "") {         case "1":             System.out.println("one");     } } public void testSwitch3(String string){     switch (string) {         case "apples":             System.out.println("apples");             break;         case "pears":             System.out.println("pears");             break;     } } public static void testSwitch4(int x) {     while (true) {         if (x < 5) {             switch ("test") {                 case "okay":                     continue;                 default:                     continue;             }         }         System.out.println("wow x2!");     } } // Procyon 反編譯 public void testSwitch2() {     final int i = 0;     final String string = (Object)(i + 1L) + "";     switch (string) {         case "1": {             System.out.println("one");             break;         }     } } public void testSwitch3(final String string) {     switch (string) {         case "apples": {             System.out.println("apples");             break;         }         case "pears": {             System.out.println("pears");             break;         }     } }    public static void testSwitch4(final int x) {     while (true) {         if (x < 5) {             final String s = "test";             switch (s) {                 case "okay": {                     continue;                 }                 default: {                     continue;                 }             }         }         else {             System.out.println("wow x2!");         }     } }

Lambda 表達式和流式操作完全一致。

// 源碼 // Lambda public Integer testLambda(List<Integer> stuff, int y, boolean b) {     return stuff.stream().filter(b ? x -> x > y : x -> x < 3).findFirst().orElse(null); }  // stream public static <Y extends Integer> void testStream(List<Y> list) {     IntStream s = list.stream()         .filter(x -> {             System.out.println(x);             return x.intValue() / 2 == 0;             })         .map(x -> (Integer)x+2)         .mapToInt(x -> x);     s.toArray(); } // Procyon 反編譯 public Integer testLambda(final List<Integer> stuff, final int y, final boolean b) {     return stuff.stream().filter(b ? (x -> x > y) : (x -> x < 3)).findFirst().orElse(null); }  public static <Y extends Integer> void testStream(final List<Y> list) {     final IntStream s = list.stream().filter(x -> {         System.out.println(x);         return x / 2 == 0;     }).map(x -> x + 2).mapToInt(x -> x);     s.toArray(); }

流程控制，反編譯后發現丟失了無異議的代碼部分，閱讀來說并無障礙。

// 源碼 void test1(String path) {     try {         int x = 3;     } catch (NullPointerException t) {         System.out.println("File Not found");         if (path == null) { return; }         throw t;     } finally {         System.out.println("Fred");         if (path == null) { throw new IllegalStateException(); }     } } // Procyon 反編譯 void test1(final String path) {     try {}     catch (NullPointerException t) {         System.out.println("File Not found");         if (path == null) {             return;         }         throw t;     }     finally {         System.out.println("Fred");         if (path == null) {             throw new IllegalStateException();         }     } }

鑒于代碼篇幅，下面幾種的反編譯結果的對比只會列出不同之處，相同之處會直接跳過。

CFR

CFR 的反編譯結果多出了類型轉換部分，個人來看沒有 Procyon 那么原汁原味，不過也算是十分優秀，測試案例中唯一不滿意的地方是對 while  continue 的處理。

// CFR 反編譯結果 // 裝箱拆箱 private void e(Short s) {    this.b(s.shortValue()); // 裝箱拆箱多出了類型轉換部分。    this.c(s.shortValue()); // 裝箱拆箱多出了類型轉換部分。    this.e(s);    this.f(s); } // 流程控制 void test1(String path) {     try {         int n = 3;// 流程控制反編譯結果十分滿意，原汁原味，甚至此處的無意思代碼都保留了。     }     catch (NullPointerException t) {         System.out.println("File Not found");         if (path == null) {             return;         }         throw t;     }     finally {         System.out.println("Fred");         if (path == null) {             throw new IllegalStateException();         }     } } // Lambda 和 Stream 操作完全一致，不提。 // switch 處，反編譯后功能一致，但是流程控制有所更改。 public static void testSwitch4(int x) {     block6: while (true) { // 源碼中只有 while(true)，反編譯后多了 block6         if (x < 5) {             switch ("test") {                 case "okay": {                     continue block6; // 多了 block6                 }             }             continue;         }         System.out.println("wow x2!");     } }

JD-Core

JD-Core 和 CFR  一樣，對于裝箱拆箱操作，反編譯后不再一致，多了類型轉換部分，而且自動優化了數據類型。個人感覺，如果是反編譯后自己閱讀，通篇的數據類型的轉換優化影響還是挺大的。

// JD-Core 反編譯 private void d(Double d) {   c(d.doubleValue()); // 新增了數據類型轉換   d(d); }  private void e(Short s) {   b(s.shortValue()); // 新增了數據類型轉換   c(s.shortValue()); // 新增了數據類型轉換   e(s);   f(s.shortValue()); // 新增了數據類型轉換 }  private void f(short s) {   b(s);   c(s);   e(Short.valueOf(s)); // 新增了數據類型轉換   f(s); } // Stream 操作中，也自動優化了數據類型轉換，閱讀起來比較累。 public static <Y extends Integer> void testStream(List<Y> list) {   IntStream s = list.stream().filter(x -> {         System.out.println(x);         return (x.intValue() / 2 == 0);       }).map(x -> Integer.valueOf(x.intValue() + 2)).mapToInt(x -> x.intValue());   s.toArray(); }

Fernflower

Fernflower 的反編譯結果總體上還是不錯的，不過也有不足，它對變量名稱的指定，以及 Switch 字符串時的反編譯結果不夠理想。

//反編譯后變量命名不利于閱讀，有很多 var 變量 int byteAnd0() {    int b = 1;    byte x = 0;     byte var10000;    do {       int b = (byte)(b ^ x);       var10000 = b;       b = b + 1;    } while(var10000 < 10);     return b; } // switch 反編譯結果使用了hashCode public static void testSwitch4(int x) {    while(true) {       if (x < 5) {          String var1 = "test";          byte var2 = -1;          switch(var1.hashCode()) {          case 3412756:              if (var1.equals("okay")) {                var2 = 0;            }          default:             switch(var2) {             case 0:             }          }       } else {          System.out.println("wow x2!");       }    } }

五種反編譯工具比較下來，結合反編譯速度和代碼可讀性測試，看起來 CFR 工具勝出，Procyon 緊隨其后。CFR  在速度上不落下風，在反編譯的代碼可讀性上，是最好的，主要體現在反編譯后的變量命名、裝箱拆箱、類型轉換，流程控制上，以及對 Lambda 表達式、Stream  流式操作和 Switch 的語法支持上，都非常優秀。根據 CFR 官方介紹，已經支持到 Java 14 語法，而且截止寫這篇測試文章時，CFR  最新提交代碼時間實在 11 小時之前，更新速度很快。

看完上述內容，你們對Java 反編譯工具的對比以及使用方法有進一步的了解嗎？如果還想了解更多知識或者相關內容，請關注億速云行業資訊頻道，感謝大家的支持。