java反编译工具有哪些（java反编译class命令）
程序员文章站
2023-11-28 11:00:40
前言java 反编译，一听可能觉得高深莫测，其实反编译并不是什么特别高级的操作，java 对于 class 字节码文件的生成有着严格的要求，如果你非常熟悉 java 虚拟机规范，了解 class 字节...
前言
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:mysource 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 ddr4java 版本jdk 14.0.2测试方式jmh 基准测试。待反编译 jar 1procyon-compilertools-0.5.33.jar (1.5 mb)待反编译 jar 2python2java4common-1.0.0-20180706.084921-1.jar (42 mb)
反编译 jar 1：procyon-compilertools-0.5.33.jar (1.5 mb)
benchmarkmodecntscoreunitscfravgt106548.642 ± 363.502ms/opfernfloweravgt1012699.147 ± 1081.539ms/opjdcoreavgt105728.621 ± 310.645ms/opprocyonavgt1026776.125 ± 2651.081ms/opjadxavgt107059.354 ± 323.351ms/op
反编译 jar 2: python2java4common-1.0.0-20180706.084921-1.jar (42 mb)
jar 2 这个包是比较大的，是拿很多代码仓库合并到一起的，同时还有很多 python 转 java 生成的代码，理论上代码的复杂度会更高。
benchmarkcntscorecfr1413838.826msfernflower1246819.168msjdcore1errorprocyon1487647.181msjadx1505600.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 的 niumoo/lab-notes 仓库 的 java-decompiler 目录。