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

[[400055]]

本文转载自微信公众号「未读代码」，作者达西呀。转载本文请联系未读代码公众号。

为大柴旦等地区用户提供了全套网页设计制作服务，及大柴旦网站建设行业解决方案。主营业务为网站设计、成都网站设计、大柴旦网站设计，以传统方式定制建设网站，并提供域名空间备案等一条龙服务，秉承以专业、用心的态度为用户提供真诚的服务。我们深信只要达到每一位用户的要求，就会得到认可，从而选择与我们长期合作。这样，我们也可以走得更远！

前言

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

 
 
 
 
    
  
  
  
  
  1.  
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     org.jboss.windup.decompiler 
    4.   
  
  
  
  4.     decompiler-procyon 
    5.   
  
  
  
  5.     5.1.4.Final 
    6.   
  
  
  
  6.  
    7.

 

写一个简单的反编译测试。

 
 
 
 
    
  
  
  
  
  1. package com.wdbyte.decompiler; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.io.IOException; 
    4.   
  
  
  
  4. import java.nio.file.Path; 
    5.   
  
  
  
  5. import java.nio.file.Paths; 
    6.   
  
  
  
  6. import java.util.Iterator; 
    7.   
  
  
  
  7. import java.util.List; 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. import org.jboss.windup.decompiler.api.DecompilationFailure; 
    10.   
  
  
  
  10. import org.jboss.windup.decompiler.api.DecompilationListener; 
    11.   
  
  
  
  11. import org.jboss.windup.decompiler.api.DecompilationResult; 
    12.   
  
  
  
  12. import org.jboss.windup.decompiler.api.Decompiler; 
    13.   
  
  
  
  13. import org.jboss.windup.decompiler.procyon.ProcyonDecompiler; 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. /** 
    16.   
  
  
  
  16.  * Procyon 反编译测试 
    17.   
  
  
  
  17.  * 
    18.   
  
  
  
  18.  *  @author https://github.com/niumoo 
    19.   
  
  
  
  19.  * @date 2021/05/15 
    20.   
  
  
  
  20.  */ 
    21.   
  
  
  
  21. public class ProcyonTest { 
    22.   
  
  
  
  22.     public static void main(String[] args) throws IOException { 
    23.   
  
  
  
  23.         Long time = procyon("decompiler.jar", "procyon_output_jar"); 
    24.   
  
  
  
  24.         System.out.println(String.format("decompiler time: %dms", time)); 
    25.   
  
  
  
  25.     } 
    26.   
  
  
  
  26.     public static Long procyon(String source,String targetPath) throws IOException { 
    27.   
  
  
  
  27.         long start = System.currentTimeMillis(); 
    28.   
  
  
  
  28.         Path outDir = Paths.get(targetPath); 
    29.   
  
  
  
  29.         Path archive = Paths.get(source); 
    30.   
  
  
  
  30.         Decompiler dec = new ProcyonDecompiler(); 
    31.   
  
  
  
  31.         DecompilationResult res = dec.decompileArchive(archive, outDir, new DecompilationListener() { 
    32.   
  
  
  
  32.             public void decompilationProcessComplete() { 
    33.   
  
  
  
  33.                 System.out.println("decompilationProcessComplete"); 
    34.   
  
  
  
  34.             } 
    35.   
  
  
  
  35.             public void decompilationFailed(List inputPath, String message) { 
    36.   
  
  
  
  36.                 System.out.println("decompilationFailed"); 
    37.   
  
  
  
  37.             } 
    38.   
  
  
  
  38.             public void fileDecompiled(List inputPath, String outputPath) { 
    39.   
  
  
  
  39.             } 
    40.   
  
  
  
  40.             public boolean isCancelled() { 
    41.   
  
  
  
  41.                 return false; 
    42.   
  
  
  
  42.             } 
    43.   
  
  
  
  43.         }); 
    44.   
  
  
  
  44.  
    45.   
  
  
  
  45.         if (!res.getFailures().isEmpty()) { 
    46.   
  
  
  
  46.             StringBuilder sb = new StringBuilder(); 
    47.   
  
  
  
  47.             sb.append("Failed decompilation of " + res.getFailures().size() + " classes: "); 
    48.   
  
  
  
  48.             Iterator failureIterator = res.getFailures().iterator(); 
    49.   
  
  
  
  49.             while (failureIterator.hasNext()) { 
    50.   
  
  
  
  50.                 DecompilationFailure dex = (DecompilationFailure)failureIterator.next(); 
    51.   
  
  
  
  51.                 sb.append(System.lineSeparator() + "    ").append(dex.getMessage()); 
    52.   
  
  
  
  52.             } 
    53.   
  
  
  
  53.             System.out.println(sb.toString()); 
    54.   
  
  
  
  54.         } 
    55.   
  
  
  
  55.         System.out.println("Compilation results: " + res.getDecompiledFiles().size() + " succeeded, " + res.getFailures().size() + " failed."); 
    56.   
  
  
  
  56.         dec.close(); 
    57.   
  
  
  
  57.         Long end = System.currentTimeMillis(); 
    58.   
  
  
  
  58.         return end - start; 
    59.   
  
  
  
  59.     } 
    60.   
  
  
  
  60. } 
    61.

Procyon 在反编译时会实时输出反编译文件数量的进度情况，最后还会统计反编译成功和失败的 Class 文件数量。

 
 
 
 
    
  
  
  
  
  1. .... 
    2.   
  
  
  
  2. 五月 15, 2021 10:58:28 下午 org.jboss.windup.decompiler.procyon.ProcyonDecompiler$3 call 
    3.   
  
  
  
  3. 信息: Decompiling 650 / 783 
    4.   
  
  
  
  4. 五月 15, 2021 10:58:30 下午 org.jboss.windup.decompiler.procyon.ProcyonDecompiler$3 call 
    5.   
  
  
  
  5. 信息: Decompiling 700 / 783 
    6.   
  
  
  
  6. 五月 15, 2021 10:58:37 下午 org.jboss.windup.decompiler.procyon.ProcyonDecompiler$3 call 
    7.   
  
  
  
  7. 信息: Decompiling 750 / 783 
    8.   
  
  
  
  8. decompilationProcessComplete 
    9.   
  
  
  
  9. Compilation results: 783 succeeded, 0 failed. 
    10.   
  
  
  
  10. decompiler time: 40599ms 
    11.

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. 可以直接运行查看帮助。

 
 
 
 
    
  
  
  
  
  1. # 查看帮助 
    2.   
  
  
  
  2. java -jar cfr-0.151.jar --help 
    3.

如果只是反编译某个 class.

 
 
 
 
    
  
  
  
  
  1. # 反编译 class 文件，结果输出到控制台 
    2.   
  
  
  
  2. java -jar cfr-0.151.jar WindupClasspathTypeLoader.class 
    3.   
  
  
  
  3. # 反编译 class 文件，结果输出到 out 文件夹 
    4.   
  
  
  
  4. java -jar cfr-0.151.jar WindupClasspathTypeLoader.class --outputpath ./out 
    5.

反编译某个 JAR.

 
 
 
 
    
  
  
  
  
  1. # 反编译 jar 文件，结果输出到 output_jar 文件夹 
    2.   
  
  
  
  2.   Desktop java -jar cfr-0.151.jar decompiler.jar --outputdir ./output_jar 
    3.   
  
  
  
  3. Processing decompiler.jar (use silent to silence) 
    4.   
  
  
  
  4. Processing com.strobel.assembler.metadata.ArrayTypeLoader 
    5.   
  
  
  
  5. Processing com.strobel.assembler.metadata.ParameterDefinition 
    6.   
  
  
  
  6. Processing com.strobel.assembler.metadata.MethodHandle 
    7.   
  
  
  
  7. Processing com.strobel.assembler.metadata.signatures.FloatSignature 
    8.

反编译结果会按照 class 的包路径写入到指定文件夹中。

CFR 代码中使用

添加依赖这里不提。

 
 
 
 
    
  
  
  
  
  1.  
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3.     org.benf 
    4.   
  
  
  
  4.     cfr 
    5.   
  
  
  
  5.     0.151 
    6.   
  
  
  
  6.  
    7.

 

实际上我在官方网站和 GitHub 上都没有看到具体的单元测试示例。不过没有关系，既然能在命令行运行，那么直接在 IDEA 中查看反编译后的 Main 方法入口，看下命令行是怎么执行的，就可以写出自己的单元测试了。

 
 
 
 
    
  
  
  
  
  1. package com.wdbyte.decompiler; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.io.IOException; 
    4.   
  
  
  
  4. import java.util.ArrayList; 
    5.   
  
  
  
  5. import java.util.HashMap; 
    6.   
  
  
  
  6. import java.util.List; 
    7.   
  
  
  
  7.  
    8.   
  
  
  
  8. import org.benf.cfr.reader.api.CfrDriver; 
    9.   
  
  
  
  9. import org.benf.cfr.reader.util.getopt.OptionsImpl; 
    10.   
  
  
  
  10.  
    11.   
  
  
  
  11. /** 
    12.   
  
  
  
  12.  * CFR Test 
    13.   
  
  
  
  13.  * 
    14.   
  
  
  
  14.  * @author https://github.com/niumoo 
    15.   
  
  
  
  15.  * @date 2021/05/15 
    16.   
  
  
  
  16.  */ 
    17.   
  
  
  
  17. public class CFRTest { 
    18.   
  
  
  
  18.     public static void main(String[] args) throws IOException { 
    19.   
  
  
  
  19.         Long time = cfr("decompiler.jar", "./cfr_output_jar"); 
    20.   
  
  
  
  20.         System.out.println(String.format("decompiler time: %dms", time)); 
    21.   
  
  
  
  21.         // decompiler time: 11655ms 
    22.   
  
  
  
  22.     } 
    23.   
  
  
  
  23.     public static Long cfr(String source, String targetPath) throws IOException { 
    24.   
  
  
  
  24.         Long start = System.currentTimeMillis(); 
    25.   
  
  
  
  25.         // source jar 
    26.   
  
  
  
  26.         List files = new ArrayList<>(); 
    27.   
  
  
  
  27.         files.add(source); 
    28.   
  
  
  
  28.         // target dir 
    29.   
  
  
  
  29.         HashMap outputMap = new HashMap<>(); 
    30.   
  
  
  
  30.         outputMap.put("outputdir", targetPath); 
    31.   
  
  
  
  31.  
    32.   
  
  
  
  32.         OptionsImpl options = new OptionsImpl(outputMap); 
    33.   
  
  
  
  33.         CfrDriver cfrDriver = new CfrDriver.Builder().withBuiltOptions(options).build(); 
    34.   
  
  
  
  34.         cfrDriver.analyse(files); 
    35.   
  
  
  
  35.         Long end = System.currentTimeMillis(); 
    36.   
  
  
  
  36.         return (end - start); 
    37.   
  
  
  
  37.     } 
    38.   
  
  
  
  38. } 
    39.

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

 
 
 
 
    
  
  
  
  
  1.  
    2.   
  
  
  
  2.          
    3.   
  
  
  
  3.             org.jd 
    4.   
  
  
  
  4.             jd-core 
    5.   
  
  
  
  5.             1.1.3 
    6.   
  
  
  
  6.          
    7.

 

为了可以反编译整个 JAR 包，使用的代码我做了一些简单改造，以便于最后一部分的对比测试，但是这个示例中没有考虑内部类，Lambda 等会编译出多个 Class 文件的情况，所以不能直接使用在生产中。

 
 
 
 
    
  
  
  
  
  1. package com.wdbyte.decompiler; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.io.File; 
    4.   
  
  
  
  4. import java.io.IOException; 
    5.   
  
  
  
  5. import java.io.InputStream; 
    6.   
  
  
  
  6. import java.nio.file.Files; 
    7.   
  
  
  
  7. import java.nio.file.Path; 
    8.   
  
  
  
  8. import java.nio.file.Paths; 
    9.   
  
  
  
  9. import java.util.Enumeration; 
    10.   
  
  
  
  10. import java.util.HashMap; 
    11.   
  
  
  
  11. import java.util.jar.JarFile; 
    12.   
  
  
  
  12. import java.util.zip.ZipEntry; 
    13.   
  
  
  
  13. import java.util.zip.ZipFile; 
    14.   
  
  
  
  14.  
    15.   
  
  
  
  15. import org.apache.commons.io.IOUtils; 
    16.   
  
  
  
  16. import org.apache.commons.lang3.StringUtils; 
    17.   
  
  
  
  17. import org.jd.core.v1.ClassFileToJavaSourceDecompiler; 
    18.   
  
  
  
  18. import org.jd.core.v1.api.loader.Loader; 
    19.   
  
  
  
  19. import org.jd.core.v1.api.printer.Printer; 
    20.   
  
  
  
  20.  
    21.   
  
  
  
  21. /** 
    22.   
  
  
  
  22.  * @author https://github.com/niumoo 
    23.   
  
  
  
  23.  * @date 2021/05/15 
    24.   
  
  
  
  24.  */ 
    25.   
  
  
  
  25. public class JDCoreTest { 
    26.   
  
  
  
  26.  
    27.   
  
  
  
  27.     public static void main(String[] args) throws Exception { 
    28.   
  
  
  
  28.         JDCoreDecompiler jdCoreDecompiler = new JDCoreDecompiler(); 
    29.   
  
  
  
  29.         Long time = jdCoreDecompiler.decompiler("decompiler.jar","jd_output_jar"); 
    30.   
  
  
  
  30.         System.out.println(String.format("decompiler time: %dms", time)); 
    31.   
  
  
  
  31.     } 
    32.   
  
  
  
  32. } 
    33.   
  
  
  
  33.  
    34.   
  
  
  
  34.  
    35.   
  
  
  
  35. class JDCoreDecompiler{ 
    36.   
  
  
  
  36.  
    37.   
  
  
  
  37.     private ClassFileToJavaSourceDecompiler decompiler = new ClassFileToJavaSourceDecompiler(); 
    38.   
  
  
  
  38.     // 存放字节码 
    39.   
  
  
  
  39.     private HashMap classByteMap = new HashMap<>(); 
    40.   
  
  
  
  40.  
    41.   
  
  
  
  41.     /** 
    42.   
  
  
  
  42.      * 注意：没有考虑一个 Java 类编译出多个 Class 文件的情况。 
    43.   
  
  
  
  43.      *  
    44.   
  
  
  
  44.      * @param source 
    45.   
  
  
  
  45.      * @param target 
    46.   
  
  
  
  46.      * @return 
    47.   
  
  
  
  47.      * @throws Exception 
    48.   
  
  
  
  48.      */ 
    49.   
  
  
  
  49.     public Long decompiler(String source,String target) throws Exception { 
    50.   
  
  
  
  50.         long start = System.currentTimeMillis(); 
    51.   
  
  
  
  51.         // 解压 
    52.   
  
  
  
  52.         archive(source); 
    53.   
  
  
  
  53.         for (String className : classByteMap.keySet()) { 
    54.   
  
  
  
  54.             String path = StringUtils.substringBeforeLast(className, "/"); 
    55.   
  
  
  
  55.             String name = StringUtils.substringAfterLast(className, "/"); 
    56.   
  
  
  
  56.             if (StringUtils.contains(name, "$")) { 
    57.   
  
  
  
  57.                 name = StringUtils.substringAfterLast(name, "$"); 
    58.   
  
  
  
  58.             } 
    59.   
  
  
  
  59.             name = StringUtils.replace(name, ".class", ".java"); 
    60.   
  
  
  
  60.             decompiler.decompile(loader, printer, className); 
    61.   
  
  
  
  61.             String context = printer.toString(); 
    62.   
  
  
  
  62.             Path targetPath = Paths.get(target + "/" + path + "/" + name); 
    63.   
  
  
  
  63.             if (!Files.exists(Paths.get(target + "/" + path))) { 
    64.   
  
  
  
  64.                 Files.createDirectories(Paths.get(target + "/" + path)); 
    65.   
  
  
  
  65.             } 
    66.   
  
  
  
  66.             Files.deleteIfExists(targetPath); 
    67.   
  
  
  
  67.             Files.createFile(targetPath); 
    68.   
  
  
  
  68.             Files.write(targetPath, context.getBytes()); 
    69.   
  
  
  
  69.         } 
    70.   
  
  
  
  70.         return System.currentTimeMillis() - start; 
    71.   
  
  
  
  71.     } 
    72.   
  
  
  
  72.     private void archive(String path) throws IOException { 
    73.   
  
  
  
  73.         try (ZipFile archive = new JarFile(new File(path))) { 
    74.   
  
  
  
  74.             Enumeration entries = archive.entries(); 
    75.   
  
  
  
  75.             while (entries.hasMoreElements()) { 
    76.   
  
  
  
  76.                 ZipEntry entry = entries.nextElement(); 
    77.   
  
  
  
  77.                 if (!entry.isDirectory()) { 
    78.   
  
  
  
  78.                     String name = entry.getName(); 
    79.   
  
  
  
  79.                     if (name.endsWith(".class")) { 
    80.   
  
  
  
  80.                         byte[] bytes = null; 
    81.   
  
  
  
  81.                         try (InputStream stream = archive.getInputStream(entry)) { 
    82.   
  
  
  
  82.                             bytes = IOUtils.toByteArray(stream); 
    83.   
  
  
  
  83.                         } 
    84.   
  
  
  
  84.                         classByteMap.put(name, bytes); 
    85.   
  
  
  
  85.                     } 
    86.   
  
  
  
  86.                 } 
    87.   
  
  
  
  87.             } 
    88.   
  
  
  
  88.         } 
    89.   
  
  
  
  89.     } 
    90.   
  
  
  
  90.  
    91.   
  
  
  
  91.     private Loader loader = new Loader() { 
    92.   
  
  
  
  92.         @Override 
    93.   
  
  
  
  93.         public byte[] load(String internalName) { 
    94.   
  
  
  
  94.             return classByteMap.get(internalName); 
    95.   
  
  
  
  95.         } 
    96.   
  
  
  
  96.         @Override 
    97.   
  
  
  
  97.         public boolean canLoad(String internalName) { 
    98.   
  
  
  
  98.             return classByteMap.containsKey(internalName); 
    99.   
  
  
  
  99.         } 
    100.   
  
  
  
  100.     }; 
    101.   
  
  
  
  101.  
    102.   
  
  
  
  102.     private Printer printer = new Printer() { 
    103.   
  
  
  
  103.         protected static final String TAB = "  "; 
    104.   
  
  
  
  104.         protected static final String NEWLINE = "\n"; 
    105.   
  
  
  
  105.         protected int indentationCount = 0; 
    106.   
  
  
  
  106.         protected StringBuilder sb = new StringBuilder(); 
    107.   
  
  
  
  107.         @Override public String toString() { 
    108.   
  
  
  
  108.             String toString = sb.toString(); 
    109.   
  
  
  
  109.             sb = new StringBuilder(); 
    110.   
  
  
  
  110.             return toString; 
    111.   
  
  
  
  111.         } 
    112.   
  
  
  
  112.         @Override public void start(int maxLineNumber, int majorVersion, int minorVersion) {} 
    113.   
  
  
  
  113.         @Override public void end() {} 
    114.   
  
  
  
  114.         @Override public void printText(String text) { sb.append(text); } 
    115.   
  
  
  
  115.         @Override public void printNumericConstant(String constant) { sb.append(constant); } 
    116.   
  
  
  
  116.         @Override public void printStringConstant(String constant, String ownerInternalName) { sb.append(constant); } 
    117.   
  
  
  
  117.         @Override public void printKeyword(String keyword) { sb.append(keyword); } 
    118.   
  
  
  
  118.         @Override public void printDeclaration(int type, String internalTypeName, String name, String descriptor) { sb.append(name); } 
    119.   
  
  
  
  119.         @Override public void printReference(int type, String internalTypeName, String name, String descriptor, String ownerInternalName) { sb.append(name); } 
    120.   
  
  
  
  120.         @Override public void indent() { this.indentationCount++; } 
    121.   
  
  
  
  121.         @Override public void unindent() { this.indentationCount--; } 
    122.   
  
  
  
  122.         @Override public void startLine(int lineNumber) { for (int i=0; i  
  
  
  
  123.         @Override public void endLine() { sb.append(NEWLINE); } 
    124.   
  
  
  
  124.         @Override public void extraLine(int count) { while (count-- > 0) sb.append(NEWLINE); } 
    125.   
  
  
  
  125.         @Override public void startMarker(int type) {} 
    126.   
  
  
  
  126.         @Override public void endMarker(int type) {} 
    127.   
  
  
  
  127.     }; 
    128.   
  
  
  
  128. } 
    129.

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 进行依赖管理，可以自行克隆仓库打包运行。

 
 
 
 
    
  
  
  
  
  1. git clone https://github.com/skylot/jadx.git 
    2.   
  
  
  
  2. cd jadx 
    3.   
  
  
  
  3. ./gradlew dist 
    4.   
  
  
  
  4. # 查看帮助 
    5.   
  
  
  
  5.  ./build/jadx/bin/jadx --help 
    6.   
  
  
  
  6.   
    7.   
  
  
  
  7. jadx - dex to java decompiler, version: dev 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. usage: jadx [options]  (.apk, .dex, .jar, .class, .smali, .zip, .aar, .arsc, .aab) 
    10.   
  
  
  
  10. options: 
    11.   
  
  
  
  11.   -d, --output-dir                    - output directory 
    12.   
  
  
  
  12.   -ds, --output-dir-src               - output directory for sources 
    13.   
  
  
  
  13.   -dr, --output-dir-res               - output directory for resources 
    14.   
  
  
  
  14.   -r, --no-res                        - do not decode resources 
    15.   
  
  
  
  15.   -s, --no-src                        - do not decompile source code 
    16.   
  
  
  
  16.   --single-class                      - decompile a single class 
    17.   
  
  
  
  17.   --output-format                     - can be 'java' or 'json', default: java 
    18.   
  
  
  
  18.   -e, --export-gradle                 - save as android gradle project 
    19.   
  
  
  
  19.   -j, --threads-count                 - processing threads count, default: 6 
    20.   
  
  
  
  20.   --show-bad-code                     - show inconsistent code (incorrectly decompiled) 
    21.   
  
  
  
  21.   --no-imports                        - disable use of imports, always write entire package name 
    22.   
  
  
  
  22.   --no-debug-info                     - disable debug info 
    23.   
  
  
  
  23.   --add-debug-lines                   - add comments with debug line numbers if available 
    24.   
  
  
  
  24.   --no-inline-anonymous               - disable anonymous classes inline 
    25.   
  
  
  
  25.   --no-replace-consts                 - don't replace constant value with matching constant field 
    26.   
  
  
  
  26.   --escape-unicode                    - escape non latin characters in strings (with \u) 
    27.   
  
  
  
  27.   --respect-bytecode-access-modifiers - don't change original access modifiers 
    28.   
  
  
  
  28.   --deobf                             - activate deobfuscation 
    29.   
  
  
  
  29.   --deobf-min                         - min length of name, renamed if shorter, default: 3 
    30.   
  
  
  
  30.   --deobf-max                         - max length of name, renamed if longer, default: 64 
    31.   
  
  
  
  31.   --deobf-cfg-file                    - deobfuscation map file, default: same dir and name as input file with '.jobf' extension 
    32.   
  
  
  
  32.   --deobf-rewrite-cfg                 - force to save deobfuscation map 
    33.   
  
  
  
  33.   --deobf-use-sourcename              - use source file name as class name alias 
    34.   
  
  
  
  34.   --deobf-parse-kotlin-metadata       - parse kotlin metadata to class and package names 
    35.   
  
  
  
  35.   --rename-flags                      - what to rename, comma-separated, 'case' for system case sensitivity, 'valid' for java identifiers, 'printable' characters, 'none' or 'all' (default) 
    36.   
  
  
  
  36.   --fs-case-sensitive                 - treat filesystem as case sensitive, false by default 
    37.   
  
  
  
  37.   --cfg                               - save methods control flow graph to dot file 
    38.   
  
  
  
  38.   --raw-cfg                           - save methods control flow graph (use raw instructions) 
    39.   
  
  
  
  39.   -f, --fallback                      - make simple dump (using goto instead of 'if', 'for', etc) 
    40.   
  
  
  
  40.   -v, --verbose                       - verbose output (set --log-level to DEBUG) 
    41.   
  
  
  
  41.   -q, --quiet                         - turn off output (set --log-level to QUIET) 
    42.   
  
  
  
  42.   --log-level                         - set log level, values: QUIET, PROGRESS, ERROR, WARN, INFO, DEBUG, default: PROGRESS 
    43.   
  
  
  
  43.   --version                           - print jadx version 
    44.   
  
  
  
  44.   -h, --help                          - print this help 
    45.   
  
  
  
  45. Example: 
    46.   
  
  
  
  46.   jadx -d out classes.dex 
    47.

根据 HELP 信息，如果想要反编译 decompiler.jar 到 out 文件夹。

 
 
 
 
    
  
  
  
  
  1. ./build/jadx/bin/jadx -d ./out ~/Desktop/decompiler.jar  
    2.   
  
  
  
  2. INFO  - loading ... 
    3.   
  
  
  
  3. INFO  - processing ... 
    4.   
  
  
  
  4. INFO  - doneress: 1143 of 1217 (93%) 
    5.

Fernflower

GitHub 地址：https://github.com/fesh0r/fernflower

Fernflower 和 Jadx 一样使用 Grade 进行依赖管理，可以自行克隆仓库打包运行。

 
 
 
 
    
  
  
  
  
  1.   fernflower-master ./gradlew build 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. BUILD SUCCESSFUL in 32s 
    4.   
  
  
  
  4. 4 actionable tasks: 4 executed 
    5.   
  
  
  
  5.  
    6.   
  
  
  
  6.   fernflower-master java -jar build/libs/fernflower.jar 
    7.   
  
  
  
  7. Usage: java -jar fernflower.jar [-
    8.   
  
  
  
  8. Example: java -jar fernflower.jar -dgs=true c:\my\source\ c:\my.jar d:\decompiled\ 
    9.   
  
  
  
  9.  
    10.   
  
  
  
  10.   fernflower-master mkdir out 
    11.   
  
  
  
  11.   fernflower-master java -jar build/libs/fernflower.jar ~/Desktop/decompiler.jar ./out 
    12.   
  
  
  
  12. INFO:  Decompiling class com/strobel/assembler/metadata/ArrayTypeLoader 
    13.   
  
  
  
  13. INFO:  ... done 
    14.   
  
  
  
  14. INFO:  Decompiling class com/strobel/assembler/metadata/ParameterDefinition 
    15.   
  
  
  
  15. INFO:  ... done 
    16.   
  
  
  
  16. INFO:  Decompiling class com/strobel/assembler/metadata/MethodHandle 
    17.   
  
  
  
  17. ... 
    18.   
  
  
  
  18.  
    19.   
  
  
  
  19.   fernflower-master ll out 
    20.   
  
  
  
  20. total 1288 
    21.   
  
  
  
  21. -rw-r--r--  1 darcy  staff   595K  5 16 17:47 decompiler.jar 
    22.   
  
  
  
  22.   fernflower-master 
    23.

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 这个包是比较大的，是拿很多代码仓库合并到一起的，同时还有很多 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 及以下的代码语法和一些嵌套的流程控制，看看反编译后的效果如何。

 
 
 
 
    
  
  
  
  
  1. package com.wdbyte.decompiler; 
    2.   
  
  
  
  2.  
    3.   
  
  
  
  3. import java.util.ArrayList; 
    4.   
  
  
  
  4. import java.util.List; 
    5.   
  
  
  
  5. import java.util.stream.IntStream; 
    6.   
  
  
  
  6.  
    7.   
  
  
  
  7. import org.benf.cfr.reader.util.functors.UnaryFunction; 
    8.   
  
  
  
  8.  
    9.   
  
  
  
  9. /** 
    10.   
  
  
  
  10.  * @author https://www.wdbyte.com 
    11.   
  
  
  
  11.  * @date 2021/05/16 
    12.   
  
  
  
  12.  */ 
    13.   
  
  
  
  13. public class HardCode  { 
    14.   
  
  
  
  14.     public HardCode(A a, B b) { } 
    15.   
  
  
  
  15.  
    16.   
  
  
  
  16.     public static void test(int... args) { } 
    17.   
  
  
  
  17.  
    18.   
  
  
  
  18.     public
                网站标题：Java反编译工具的使用与对比分析
                
    
                标题链接：http://www.csdahua.cn/qtweb/news28/550978.html
            
    
            
    
                网站建设、网络推广公司-快上网，是专注品牌与效果的网站制作，网络营销seo公司；服务项目有等
                                
    
            
    
                广告
                
            
    
            
    
                声明：本网站发布的内容（图片、视频和文字）以用户投稿、用户转载内容为主，如果涉及侵权请尽快告知，我们将会在第一时间删除。文章观点不代表本网站立场，如需处理请联系客服。电话：028-86922220；邮箱：631063699@qq.com。内容未经允许不得转载，或转载时需注明来源：
                快上网

成都快上网为您推荐相关内容

网站建设知识

分类信息网站

四川瑞杰　　 　鳄鱼养殖　　 　成都网站维护　　 　小谭网创广告　　 　小谭网创广告　　 　微信小程序　　 　营山产后护理服务　　 　微信公众号开发　　 　成都微信二次开发公司　　 　成都电信服务器托管　　 　成都商城网站建设　　 　珉田数据中心　　 　天泽尚品装饰　　 　成都花箱　　 　重庆网站建设　　 　乐山做网站　　 　营山月子会所　　 　成都app软件开发　　 　乐山主机托管　　 　成都免费建站