关于java:Java-反编译工具哪家强对比分析瞧一瞧

Java 反编译 ，一听可能感觉高深莫测，其实反编译并不是什么特地高级的操作，Java 对于 Class 字节码文件的生成有着严格的要求，如果你十分相熟 Java 虚拟机标准，理解 Class 字节码文件中一些字节的作用，那么了解反编译的原理并不是什么问题。
甚至像上面这样的 Class 文件你都能看懂一二。

个别在逆向钻研和代码剖析中，反编译用到的比拟多。不过在日常开发中，有时候只是简略的看一下所用依赖类的反编译，也是非常重要的。

恰好最近工作中也须要用到 Java 反编译 ，所以这篇文章介绍目前常见的的几种 Java 反编译工具的应用，在文章的最初也会通过 编译速度 、 语法反对 以及 代码可读性 三个维度，对它们 进行测试 ，剖析几款工具的 优缺点。

<!– more –>

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，更新频率还是很高的，上面也会抉择这个工具进行反编译测试。

<!-- 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 反编译来说，在 GitHub 上也有基于此实现的开源 GUI 界面，感兴趣的能够下载尝试。
Github 地址：https://github.com/deathmarine/Luyten

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 反编译时，你能够下载曾经公布的 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 的包门路写入到指定文件夹中。

增加依赖这里不提。

<!-- 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);
    }
}

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 等，尽管能够间接反编译，不过也须要额定思考。

        <!-- 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) {}};
}

GitHub 地址：https://github.com/java-decompiler/jd-gui
JD-core 也提供了官网的 GUI 界面，须要的也能够间接下载尝试。

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%)

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 的反编译后果，还是比拟吃惊的，在失常反编译的状况下，反编译后的代码基本上都是 原汁原味。惟一一处反编译后和源码语法上有变动的中央，是一个汇合的初始化操作略有不同。

// 源码
 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 的反编译后果多出了类型转换局部，集体来看没有 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 和 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 在反编译测试代码时，报出了谬误，反编译的后果里也有提醒 不能反编 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 的反编译后果总体上还是不错的，不过也有有余，它对变量名称的指定，以及 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

最初的话

文章有帮忙能够点个「赞」或「分享」，都是反对，我都喜爱！
文章每周继续更新，要实时关注我更新的文章以及分享的干货，能够关注「未读代码」公众号或者我的博客。

关于java:Java-反编译工具哪家强对比分析瞧一瞧

前言

Procyon

应用 Procyon

Procyon GUI

CFR

CFR 命令行应用

CFR 代码中应用

JD-Core

应用 JD-core

JD-GUI

Jadx

Fernflower

反编译速度

语法反对和可读性

Procyon

CFR

JD-Core

Jadx

Fernflower

总结