前言

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

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

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

Procyon

Github 鏈接：https://github.com/mstrobel/procyonProcyon 不僅僅是反編譯工具，它其實是專注于 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 / 783decompilationProcessCompleteCompilation 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/cfrCFR 官方網站：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_jarProcessing decompiler.jar (use silent to silence)Processing com.strobel.assembler.metadata.ArrayTypeLoaderProcessing com.strobel.assembler.metadata.ParameterDefinitionProcessing com.strobel.assembler.metadata.MethodHandleProcessing 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 jarList<String> files = new ArrayList<>();files.add(source);// target dirHashMap<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-coreJD-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() {@Overridepublic byte[] load(String internalName) { return classByteMap.get(internalName);}@Overridepublic 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-guiJD-core 也提供了官方的 GUI 界面，需要的也可以直接下載嘗試。

Jadx

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

git clone https://github.com/skylot/jadx.gitcd jadx./gradlew dist# 查看幫助 ./build/jadx/bin/jadx --help jadx - dex to java decompiler, version: devusage: 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 helpExample: 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/fernflowerFernflower 和 Jadx 一樣使用 Grade 進行依賴管理，可以自行克隆倉庫打包運行。

➜ fernflower-master ./gradlew buildBUILD SUCCESSFUL in 32s4 actionable tasks: 4 executed➜ fernflower-master java -jar build/libs/fernflower.jarUsage: java -jar fernflower.jar [-<option>=<value>]* [<source>]+ <destination>Example: java -jar fernflower.jar -dgs=true c:mysource c:my.jar d:decompiled➜ fernflower-master mkdir out➜ fernflower-master java -jar build/libs/fernflower.jar ~/Desktop/decompiler.jar ./outINFO: Decompiling class com/strobel/assembler/metadata/ArrayTypeLoaderINFO: ... doneINFO: Decompiling class com/strobel/assembler/metadata/ParameterDefinitionINFO: ... doneINFO: Decompiling class com/strobel/assembler/metadata/MethodHandle...➜ fernflower-master ll outtotal 1288-rw-r--r-- 1 darcy staff 595K 5 16 17:47 decompiler.jar➜ fernflower-master

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

反編譯速度

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

測試環境

環境變量 描述 處理器 2.6 GHz 六核Intel Core i7 內存 16 GB 2667 MHz DDR4 Java 版本 JDK 14.0.2 測試方式 JMH 基準測試。 待反編譯 JAR 1 procyon-compilertools-0.5.33.jar (1.5 MB) 待反編譯 JAR 2 python2java4common-1.0.0-20180706.084921-1.jar (42 MB)

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

Benchmark Mode Cnt Score Units cfr avgt 10 6548.642 ± 363.502 ms/op fernflower avgt 10 12699.147 ± 1081.539 ms/op jdcore avgt 10 5728.621 ± 310.645 ms/op procyon avgt 10 26776.125 ± 2651.081 ms/op jadx avgt 10 7059.354 ± 323.351 ms/op

反編譯 JAR 2: python2java4common-1.0.0-20180706.084921-1.jar (42 MB)

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

Benchmark Cnt Score Cfr 1 413838.826ms fernflower 1 246819.168ms jdcore 1 Error procyon 1 487647.181ms jadx 1 505600.231ms 語法支持和可讀性

如果反編譯后的代碼需要自己看的話，那么可讀性更好的代碼更占優勢，下面我寫了一些代碼，主要是 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 testSwitch1(){int i = 0;switch(((Long)(i + 1L)) + '') { case '1':System.out.println('one');} } // switch public void testSwitch2(String string){switch (string) { case 'apples':System.out.println('apples');break; case 'pears':System.out.println('pears');break;} } // switch public static void testSwitch3(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 部分也是一致，流程控制部分也沒有變化。

// 源碼 switchpublic void testSwitch1(){ int i = 0; switch(((Long)(i + 1L)) + '') {case '1': System.out.println('one'); }}public void testSwitch2(String string){ switch (string) {case 'apples': System.out.println('apples'); break;case 'pears': System.out.println('pears'); break; }}public static void testSwitch3(int x) { while (true) {if (x < 5) { switch ('test') {case 'okay': continue;default: continue; }}System.out.println('wow x2!'); }}// Procyon 反編譯public void testSwitch1() { final int i = 0; final String string = (Object)(i + 1L) + ''; switch (string) {case '1': { System.out.println('one'); break;} }}public void testSwitch2(final String string) { switch (string) {case 'apples': { System.out.println('apples'); break;}case 'pears': { System.out.println('pears'); break;} }} public static void testSwitch3(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 表達式和流式操作完全一致。

// 源碼// Lambdapublic Integer testLambda(List<Integer> stuff, int y, boolean b) { return stuff.stream().filter(b ? x -> x > y : x -> x < 3).findFirst().orElse(null);}// streampublic 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 testSwitch3(int x) { block6: while (true) { // 源碼中只有 while(true)，反編譯后多了 block6if (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();}Jadx

首先 Jadx 在反編譯測試代碼時，報出了錯誤，反編譯的結果里也有提示不能反編 Lambda 和 Stream 操作，反編譯結果中變量名稱雜亂無章，流程控制幾乎陣亡，如果你想反編譯后生物肉眼閱讀，Jadx 肯定不是一個好選擇。

// Jadx 反編譯private void e(Short s) { b(s.shortValue());// 新增了數據類型轉換 c((double) s.shortValue());// 新增了數據類型轉換 e(s); f(s.shortValue());// 新增了數據類型轉換}private void f(short s) { b(s); c((double) s);// 新增了數據類型轉換 e(Short.valueOf(s));// 新增了數據類型轉換 f(s);}public int testLambda() { // testLambda 反編譯失敗 /*r2 = this;r0 = 3r1 = move-resultjava.lang.Integer r0 = r2.lambdaInvoker(r0, r1)int r0 = r0.intValue()return r0 */ throw new UnsupportedOperationException('Method not decompiled: com.wdbyte.decompiler.HardCode.testLambda():int');}// Stream 反編譯失敗public static <Y extends java.lang.Integer> void testStream(java.util.List<Y> r3) { /*java.util.stream.Stream r1 = r3.stream()r2 = move-resultjava.util.stream.Stream r1 = r1.filter(r2)r2 = move-resultjava.util.stream.Stream r1 = r1.map(r2)r2 = move-resultjava.util.stream.IntStream r0 = r1.mapToInt(r2)r0.toArray()return */ throw new UnsupportedOperationException('Method not decompiled: com.wdbyte.decompiler.HardCode.testStream(java.util.List):void');}public void testSwitch2(String string) { // switch 操作無法正常閱讀，和源碼出入較大。 char c = 65535; switch (string.hashCode()) {case -1411061671: if (string.equals('apples')) {c = 0;break; } break;case 106540109: if (string.equals('pears')) {c = 1;break; } break; } switch (c) {case 0: System.out.println('apples'); return;case 1: System.out.println('pears'); return;default: return; }}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 反編譯結果使用了hashCodepublic static void testSwitch3(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 小時之前，更新速度很快。

文章中部分代碼已經上傳 GitHub ：github.com/niumoo/lab-notes/tree/master/java-decompiler

以上就是最好的Java 反編譯工具的使用對比分析的詳細內容，更多關于Java 反編譯工具的資料請關注好吧啦網其它相關文章！