| 发布日期：2024-09-07 04:33 点击次数：187 |
点赞再看91porn.，能源无穷。Hello world : ) 微信搜「 神色猿阿朗」。
本文 Github.com/niumoo/JavaNotes 和 未读代码博客 仍是收录，有好多学问点和系列著作。
弁言Java 反编译，一听可能认为深不可测，其实反编译并不是什么非常高档的操作，Java 关于 Class 字节码文献的生成有着严格的条件，如果你相当纯熟 Java 虚构机程序，了解 Class 字节码文献中一些字节的作用，那么连气儿反编译的旨趣并不是什么问题。甚而像底下这么的 Class 文献你皆能看懂一二。
图片
一般在逆向商量和代码分析中，反编译用到的比拟多。不外在日常配置中，有时候只是肤浅的看一下所用依赖类的反编译，亦然十分紧迫的。
就怕最近责任中也需要用到 Java 反编译，是以这篇著作先容目下常见的的几种 Java 反编译器具的使用，在著作的临了也贯通过编译速率、语法搭救以及代码可读性三个维度，对它们进行测试，分析几款器具的优谬误。
ProcyonGithub 相接：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 / 783 decompilationProcessComplete Compilation results: 783 succeeded, 0 failed. decompiler time: 40599msProcyon GUI
关于 Procyon 反编译来说，在 GitHub 上也有基于此完了的开源 GUI 界面，感酷好的可以下载尝试。Github 地址：https://github.com/deathmarine/Luyten
CFRGitHub 地址：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_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-CoreGiHub 地址：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() {
@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-GUIGitHub 地址：https://github.com/java-decompiler/jd-guiJD-core 也提供了官方的 GUI 界面，需要的也可以径直下载尝试。
图片
JadxGitHub 地址：https://github.com/skylot/jadxJadx 是一款可以反编译 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/fernflowerFernflower 和 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 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();
}
}
}鉴于代码篇幅，底下几种的反编译完了的对比只会列出不同之处，沟通之处会径直跳过。
CFRCFR 的反编译完了多出了类型调换部分，个东说念主来看莫得 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-CoreJD-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;
}
}FernflowerFernflower 的反编译完了总体上照旧可以的，不外也有不及，它对变量称号的指定，以及 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
<完>
Hello world : ) 我是阿朗，一线本事器具东说念主，认崇敬真写著作。
点赞的个个皆是东说念主才91porn.，不仅长得帅气颜面，谈话还动听。
本站仅提供存储劳动，通盘内容均由用户发布，如发现存害或侵权内容，请点击举报。