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

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

2022-04-14 531
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 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反编译工具
程序猿阿朗
目录
相关文章
yuanzhengme
|
30天前
|
监控 Java 测试技术
Java开发现在比较缺少什么工具？
【10月更文挑战第15天】Java开发现在比较缺少什么工具？
yuanzhengme
36 1
Dylaniou
|
1月前
|
存储 Java
【编程基础知识】 分析学生成绩：用Java二维数组存储与输出
本文介绍如何使用Java二维数组存储和处理多个学生的各科成绩，包括成绩的输入、存储及格式化输出，适合初学者实践Java基础知识。
Dylaniou
71 1
东方睿赢
|
19天前
|
存储 Java 关系型数据库
在Java开发中，数据库连接是应用与数据交互的关键环节。本文通过案例分析，深入探讨Java连接池的原理与最佳实践
在Java开发中，数据库连接是应用与数据交互的关键环节。本文通过案例分析，深入探讨Java连接池的原理与最佳实践，包括连接创建、分配、复用和释放等操作，并通过电商应用实例展示了如何选择合适的连接池库（如HikariCP）和配置参数，实现高效、稳定的数据库连接管理。
东方睿赢
37 2
java的细水长流
|
22天前
|
Java 数据格式 索引
使用 Java 字节码工具检查类文件完整性的原理是什么
Java字节码工具通过解析和分析类文件的字节码，检查其结构和内容是否符合Java虚拟机规范，确保类文件的完整性和合法性，防止恶意代码或损坏的类文件影响程序运行。
java的细水长流
28 5
java的细水长流
|
22天前
|
Java API Maven
如何使用 Java 字节码工具检查类文件的完整性
本文介绍如何利用Java字节码工具来检测类文件的完整性和有效性，确保类文件未被篡改或损坏，适用于开发和维护阶段的代码质量控制。
java的细水长流
38 5
土木林森
|
20天前
|
Java 关系型数据库 数据库
面向对象设计原则在Java中的实现与案例分析
【10月更文挑战第25天】本文通过Java语言的具体实现和案例分析，详细介绍了面向对象设计的五大核心原则：单一职责原则、开闭原则、里氏替换原则、接口隔离原则和依赖倒置原则。这些原则帮助开发者构建更加灵活、可维护和可扩展的系统，不仅适用于Java，也适用于其他面向对象编程语言。
土木林森
13 2
技能实验室
|
25天前
|
Web App开发 Java
使用java操作浏览器的工具selenium-java和webdriver下载地址
【10月更文挑战第12天】Selenium-java依赖包用于自动化Web测试，版本为3.141.59。ChromeDriver和EdgeDriver分别用于控制Chrome和Edge浏览器，需确保版本与浏览器匹配。示例代码展示了如何使用Selenium-java模拟登录CSDN，包括设置驱动路径、添加Cookies和获取页面源码。
技能实验室
73 6
yuanzhengme
|
30天前
|
Java Maven 数据安全/隐私保护
如何实现Java打包程序的加密代码混淆，避免被反编译？
【10月更文挑战第15天】如何实现Java打包程序的加密代码混淆，避免被反编译？
yuanzhengme
44 2
Dylaniou
|
1月前
|
Java
让星星⭐月亮告诉你，Java synchronized(*.class) synchronized 方法 synchronized(this)分析
本文通过Java代码示例，介绍了`synchronized`关键字在类和实例方法上的使用。总结了三种情况：1) 类级别的锁，多个实例对象在同一时刻只能有一个获取锁；2) 实例方法级别的锁，多个实例对象可以同时执行；3) 同一实例对象的多个线程，同一时刻只能有一个线程执行同步方法。
Dylaniou
18 1
java冯坚持
|
1月前
|
小程序 Oracle Java
JVM知识体系学习一：JVM了解基础、java编译后class文件的类结构详解，class分析工具 javap 和 jclasslib 的使用
这篇文章是关于JVM基础知识的介绍，包括JVM的跨平台和跨语言特性、Class文件格式的详细解析，以及如何使用javap和jclasslib工具来分析Class文件。
java冯坚持
41 0
JVM知识体系学习一：JVM了解基础、java编译后class文件的类结构详解，class分析工具 javap 和 jclasslib 的使用

热门文章

最新文章

  • 1
    【Java】留下没有基础眼泪的面试题
  • 2
    来聊聊Java项目分层规范
  • 3
    超全面！阿里巴巴最新发布23年秋招200道Java面试题（含答案）
  • 4
    JAVA虚拟机关闭钩子(Shutdown Hook)
  • 5
    Java项目导出源代码jar包在Eclipse中查看中文注释乱码的问题
  • 6
    JDK6笔记（5）----JDBC4
  • 7
    （JAVA编程练习）：判断101-200之间有多少个素数，并输出所有素数。
  • 8
    Java -- JDBC 学习--通过 ResultSet 执行查询操作
  • 9
    （十三）java类的继承
  • 10
    How to programmatically new a java class which implements sepecified interface in eclipse plugin development
  • 1
    前端和Java验签以太坊钱包签名实现中心化登录
    1021
  • 2
    零基础轻松入门Java数据库连接（JDBC）
    61
  • 3
    04｜零基础玩转面向对象编程：Java OOP
    33
  • 4
    03｜Java基础语法：讲解标识符、关键字、变量、数据类型、运算符、控制语句（条件分支、循环）
    38
  • 5
    探索Java世界的奇妙工具——运算符与表达式运算符
    30
  • 6
    深入浅出Java基础语法：标识符、关键字、变量、数据类型、运算符与控制语句
    31
  • 7
    Java一分钟之-Java IO流：文件读写基础
    114
  • 8
    轻松理解Java中的数据类型和变量
    24
  • 9
    Java一分钟之-Map接口与HashMap详解
    38
  • 10
    01｜Java简介与历史
    36

    • 相关课程

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

    • 相关电子书

    更多
  • Spring Cloud Alibaba - 重新定义 Java Cloud-Native
  • The Reactive Cloud Native Arch
  • JAVA开发手册1.5.0

    • 相关实验场景

    更多
  • 基于ECS搭建Java Web开发环境
  • 使用Aliyun Java Intializr进行项目开发
  • 搭建Java Web开发环境
  • 部署基于Dragonwell的Java运行环境
  • 阿里云平台上进行Java程序的编译与运行
  • RocketMQ中使用Java客户端发送消息和消费的应用
    • 下一篇
    阿里云OSS设置跨域访问