AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

Java 反编译工具的使用与对比分析（三）

2022-04-14 617
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： Java 反编译工具的使用与对比分析

语法支持和可读性

如果反编译后的代码需要自己看的话，那么可读性更好的代码更占优势，下面我写了一些代码，主要是 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 目录。

文章标签：
Java
关键词：
Java分析
Java工具
Java工具分析
Java反编译
Java反编译工具
程序猿阿朗
目录
相关文章
凉凉心.
|
5天前
|
Java Go 开发工具
【Java】（9）抽象类、接口、内部的运用与作用分析，枚举类型的使用
抽象类必须使用abstract修饰符来修饰，抽象方法也必须使用abstract修饰符来修饰，抽象方法不能有方法体。抽象类不能被实例化，无法使用new关键字来调用抽象类的构造器创建抽象类的实例。抽象类可以包含成员变量、方法（普通方法和抽象方法都可以）、构造器、初始化块、内部类（接 口、枚举）5种成分。抽象类的构造器不能用于创建实例，主要是用于被其子类调用。抽象类中不一定包含抽象方法，但是有抽象方法的类必定是抽象类abstract static不能同时修饰一个方法。
凉凉心.
66 1
凉凉心.
|
5天前
|
存储 Java Go
【Java】（3）8种基本数据类型的分析、数据类型转换规则、转义字符的列举
牢记类型转换规则在脑海中将编译和运行两个阶段分开，这是两个不同的阶段，不要弄混！
凉凉心.
49 2
JJLIN距离
|
7天前
|
人工智能 监控 Java
Java与AI智能体：构建自主决策与工具调用的智能系统
随着AI智能体技术的快速发展，构建能够自主理解任务、制定计划并执行复杂操作的智能系统已成为新的技术前沿。本文深入探讨如何在Java生态中构建具备工具调用、记忆管理和自主决策能力的AI智能体系统。我们将完整展示从智能体架构设计、工具生态系统、记忆机制到多智能体协作的全流程，为Java开发者提供构建下一代自主智能系统的完整技术方案。
JJLIN距离
102 4
JJLIN距离
|
14天前
|
人工智能 Java API
Java AI智能体实战：使用LangChain4j构建能使用工具的AI助手
随着AI技术的发展，AI智能体（Agent）能够通过使用工具来执行复杂任务，从而大幅扩展其能力边界。本文介绍如何在Java中使用LangChain4j框架构建一个能够使用外部工具的AI智能体。我们将通过一个具体示例——一个能获取天气信息和执行数学计算的AI助手，详细讲解如何定义工具、创建智能体并处理执行流程。本文包含完整的代码示例和架构说明，帮助Java开发者快速上手AI智能体的开发。
JJLIN距离
415 8
JJLIN距离
|
15天前
|
人工智能 缓存 监控
使用LangChain4j构建Java AI智能体：让大模型学会使用工具
AI智能体是大模型技术的重要演进方向，它使模型能够主动使用工具、与环境交互，以完成复杂任务。本文详细介绍如何在Java应用中，借助LangChain4j框架构建一个具备工具使用能力的AI智能体。我们将创建一个能够进行数学计算和实时信息查询的智能体，涵盖工具定义、智能体组装、记忆管理以及Spring Boot集成等关键步骤，并展示如何通过简单的对话界面与智能体交互。
JJLIN距离
395 1
小白学大数据
|
27天前
|
数据采集 存储 弹性计算
高并发Java爬虫的瓶颈分析与动态线程优化方案
高并发Java爬虫的瓶颈分析与动态线程优化方案
小白学大数据
132 1
poemyang
|
2月前
|
安全 Java 编译器
new出来的对象，不一定在堆上？聊聊Java虚拟机的优化技术：逃逸分析
逃逸分析是一种静态程序分析技术，用于判断对象的可见性与生命周期。它帮助即时编译器优化内存使用、降低同步开销。根据对象是否逃逸出方法或线程，分析结果分为未逃逸、方法逃逸和线程逃逸三种。基于分析结果，编译器可进行同步锁消除、标量替换和栈上分配等优化，从而提升程序性能。尽管逃逸分析计算复杂度较高，但其在热点代码中的应用为Java虚拟机带来了显著的优化效果。
poemyang
69 4
青云交（Java大数据AI云原生Python）
|
2月前
|
机器学习/深度学习 安全 Java
Java 大视界 -- Java 大数据在智能金融反洗钱监测与交易异常分析中的应用（224）
本文探讨 Java 大数据在智能金融反洗钱监测与交易异常分析中的应用，介绍其在数据处理、机器学习建模、实战案例及安全隐私等方面的技术方案与挑战，展现 Java 在金融风控中的强大能力。
青云交（Java大数据AI云原生Python）
93 0
青云交（Java大数据AI云原生Python）
|
3月前
|
存储 Java 大数据
Java 大视界 -- Java 大数据在智能家居能源消耗模式分析与节能策略制定中的应用（198）
简介：本文探讨Java大数据技术在智能家居能源消耗分析与节能策略中的应用。通过数据采集、存储与智能分析，构建能耗模型，挖掘用电模式，制定设备调度策略，实现节能目标。结合实际案例，展示Java大数据在智能家居节能中的关键作用。
青云交（Java大数据AI云原生Python）
99 0
游客ib7xsk7hcucuo
|
4月前
|
Java 数据安全/隐私保护
银行转账虚拟生成器app，银行卡转账截图制作软件，java实现截图生成工具【仅供装逼娱乐用途】
本项目提供了一套基于Java的图片处理教学方案，包含自定义图片生成、图像水印添加及合法电子凭证生成技术示例。
游客ib7xsk7hcucuo
257 0

热门文章

最新文章

  • 1
    阿里出手！Java 开发者狂喜！开源 AI Agent 框架 JManus 来了，初次见面就心动～
  • 2
    构建基于Java的AI智能体：使用LangChain4j与Spring AI实现RAG应用
  • 3
    最详细Java正则表达式详解
  • 4
    2025 年最新 Java 实操学习路线，从入门到高级应用详细指南
  • 5
    Java并发编程：CountDownLatch实战解析
  • 6
    热门小程序源码合集：微信抖音小程序源码支持PHP/Java/uni-app完整项目实践指南
  • 7
    使用LangChain4j构建Java AI智能体：让大模型学会使用工具
  • 8
    Java AI智能体实战：使用LangChain4j构建能使用工具的AI助手
  • 9
    抖音微信爆款小游戏大全：免费休闲/竞技/益智/PHP+Java全筏开源开发
  • 10
    Java新特性：使用Stream API重构你的数据处理
  • 1
    2025 版 Java 零基础入门到精通实操指南
    777
  • 2
    java 入门学习视频_2025 最新 java 入门零基础学习视频教程
    153
  • 3
    顺丰同城抢单辅助脚本，顺丰骑士抢单辅助免封号，自动抢单神器【java版开源】
    473
  • 4
    现代化 java 分层开发实施策略与最佳实践指南
    149
  • 5
    我们详细地讲解一下 Java 异常及要如何处理
    83
  • 6
    MinIO Java SDK 7.1.4 升级到 8.5.17 需要注意什么
    320
  • 7
    微信不封号无限加人软件，微信一键自动加人软件，java实现批量化加人
    114
  • 8
    Java 与 C++ 区别深入剖析及应用实例详解
    362
  • 9
    Java 生态大模型应用开发全流程实战案例与技术路径终极对决
    600
  • 10
    Java 抽象类与接口在 Java17 + 开发中的现代应用实践解析
    94

    • 相关课程

    更多
  • Java面试疑难点解析 - 面试技巧及语言基础
  • Java面试疑难点解析 - Java Web开发
  • Java面试疑难点解析 - 系统架构及项目设计
  • Java编程入门
  • Java面向对象编程
  • Java高级编程

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0
    • 下一篇
    阿里云云原生一体化数仓 — 数据治理新能力解读