前言
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 微基準測試工具分別對這五款反編譯工具進行了簡單的測試，下面是一些測試結果。
測試環境
| 環境變數 | 描述 |
|---|---|
| 處理器 | 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 部分也是一致，流程控制部分也沒有變化。
// 原始碼 switch
public 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 表示式和流式操作完全一致。
// 原始碼
// 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 testSwitch3(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();
}
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 = 3
r1 = move-result
java.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-result
java.util.stream.Stream r1 = r1.filter(r2)
r2 = move-result
java.util.stream.Stream r1 = r1.map(r2)
r2 = move-result
java.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 反編譯結果使用了hashCode
public 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
最後的話
文章有幫助可以點個「贊」或「分享」，都是支援，我都喜歡！
文章每週持續更新，要實時關注我更新的文章以及分享的乾貨，可以關注「 未讀程式碼 」公眾號或者我的部落格，也可以加我微信：wn8398。