Proguard使用教程

2022-07-16 16:58:57

一、概念

ProGuard是一款免费的Java类文件压缩器、优化器和混淆器。它能发现并删除无用类、字段（field）、方法和属性值（attribute）。它也能优化字节码并删除无用的指令。最后，它使用简单无意义的名字来重命名你的类名、字段名和方法名。经过以上操作的jar文件会变得更小，并很难进行逆向工程。这里提到了ProGuard的主要功能是压缩、优化和混淆，下面我就先介绍一下这些概念，然后再介绍ProGuard的基本使用方法。

1、 什么是压缩： 
   Java源代码（.java文件）通常被编译为字节码（.class文件）。而完整的程序或程序库通常被压缩和发布成Java文档（.jar文件）。字节码比Java源文件更简洁，但是它仍然包含大量的无用代码，尤其它是一个程序库的时候。ProGuard的压缩程序操作能分析字节码，并删除无用的类、字段和方法。程序只保留功能上的等价，包括异常堆栈描述所需要的信息。

2、什么是混淆： 
    通常情况下，编译后的字节码仍然包含了大量的调试信息：源文件名，行号，字段名，方法名，参数名，变量名等等。这些信息使得它很容易被反编译和通过逆向工程获得完整的程序。有时，这是令人厌恶的。例如像ProGuard这样的混淆器就能删除这些调试信息，并用无意义的字符序列来替换所有名字，使得它很难进行逆向工程，它进一步免费的精简代码。除了异常堆栈信息所需要的类名，方法名和行号外，程序只会保留功能上的等价。通过以上的了解，你应该明白为什么需要混淆了。

3、 ProGuard支持那些种类的优化： 
除了在压缩操作删除的无用类，字段和方法外，ProGuard也能在字节码级提供性能优化，内部方法有：

  • 常量表达式求值
  • 删除不必要的字段存取
  • 删除不必要的方法调用
  • 删除不必要的分支
  • 删除不必要的比较和instanceof验证
  • 删除未使用的代码
  • 删除只写字段
  • 删除未使用的方法参数
  • 像push/pop简化一样的各种各样的peephole优化
  • 在可能的情况下为类添加static和final修饰符
  • 在可能的情况下为方法添加private, static和final修饰符
  • 在可能的情况下使get/set方法成为内联的
  • 当接口只有一个实现类的时候，就取代它
  • 选择性的删除日志代码

实际的优化效果是依赖于你的代码和执行代码的虚拟机的。简单的虚拟机比有复杂JIT编译器的高级虚拟机更有效。无论如何，你的字节码会变得更小。 
仍有一些明显需要优化的技术不被支持：

  • 使非final的常量字段成为内联
  • 像get/set方法一样使其他方法成为内联
  • 将常量表达式移到循环之外
  • Optimizations that require escape analysis

ProGuard是一个命令行工具，并提供了图形化用户界面，它也可以结合Ant或J2ME Wireless Toolkit使用。通过ProGuard得到的更精简的jar文件意味着只需要更小的存储空间；网络传输更省时；装载速度更快和占用更小的内存空间。另外，ProGuard非常快速和高效，它仅仅只花费几秒钟和几兆的内存在处理程序。它处理的顺序是先压缩，然后优化，最后才进行混淆。The results section presents actual figures for a number of applications.与其他Java混淆器相比，ProGuard的主要优势可能是它的基于模版文件的简单配置。一些直观的命令行选项或一个简单的配置文件已经足够了。例如，下面的配置选项保护了jar文件里的所有applets： 
-keep public class * extends java.applet.Applet 
用户指南里说明了所有可用的选项，并以大量的例子为你演示这些功能强大的配置选项。

上面谈到了ProGuard的很多好处，现在我们就来看看如何在程序中使用ProGuard吧，之前也提到了ProGuard可以用命令行、图形界面、Ant等来执行和处理程序，同时也提到了配置文件，下面我们一起来看如何使用： 
用命令行执行ProGuard的命令如下： 
java –jar proguard.jar options…… 
具体的选项可以参考ProGuard的用户指南，你也可以把这些属性写在配置文件里；运行时，我们只需要指定这个配置文件就行了，例如： 
java –jar proguard.jar @config.pro 
而配置文件的格式也是要按照ProGuard提供的格式来写的，这个可以参考ProGuard例子里的配置文件来配置适合你的应用系统的ProGuard配置文件。ProGuard提供了图形界面的配置和运行程序，你可以在界面上配置你想要的参数，然后运行即可。前面提到的要手动写的配置文件也可以用图形界面来配置和生成。 
如果你要在Ant里运行ProGuard，只需要添加一一个如下的target即可：

<target name="proguard" depends="init">

       <taskdef resource="proguard/ant/task.properties" classpath="${lib.dir}/proguard/proguard.jar" />

       <proguard configuration="${src.dir}/config.pro" />

</target>

你只需要制定lib.dir和src.dir属性就行了，同样的，这里也用了proguard配置文件，跟上面提到的是一样的。建议大家把ProGuardGUI当成一个生成配置文件的向导来使用，这样我们只需要修改配置文件而不用重新写一个配置文件。

二、用法

（1）、从网上download proguard工具，proguard工具主要包含是几个jar文件和一些example，下载地址http://proguard.sourceforge.net/ 
   （2）、将里面的几个jar文件添加到类路径下面。当然，也可以不添加，但是下面在做混淆的时候，必须指定classpath，使在做混淆的过程中，能否访问该类 
   （3）、编写一个配置文件，主要是混淆器的一些参数。比如，下面是一个例子

-injars       platform.jar

-outjars      platform_out.jar

-libraryjars  <java.home>/lib/rt.jar

-libraryjars ibatis-common-2.jar

-libraryjars ibatis-dao-2.jar

-libraryjars ibatis-sqlmap-2.jar

-libraryjars junit-3.8.1.jar

-libraryjars d:/j2ee.jar

-libraryjars struts.jar

-libraryjars commons-lang.jar

-libraryjars D:/0working/coreproject/byislib/jasperreports-0.6.1.jar

-libraryjars  commons-beanutils.jar 

-printmapping proguard.map

-overloadaggressively

-defaultpackage ''

-allowaccessmodification

-dontoptimize

-keep public class *

{

public protected *;

}

-keep public class org.**

-keep public class it.**

各个参数的含义参考proguard文档，该文档非常详细，上手很容易 
OK，到此就完成了代码混淆，打开产生的jar包可以看到，多了好多a、b、c之类的类文件。说明混淆结果已经成功。将原jar删除、运行产生的混淆jar包，一切正常！

常见问题：使用过程中个人遇到了几个问题，开始也是找了很久才解决 
  a. 内存溢出异常： 主要是proguard在做混淆的时候，吃了很多内存，因此，在运行混淆器的时候，可以增加内存，比如 java -mx512m ..... 
  b.栈溢出异常： 主要是proguard在做混淆的时候，会对一些代码进行优化，若遇到一些相对复杂的方法时，可能会抛出此异常。对付的办法是增加配置参数-dontoptimize，如上面的配置例子所示

图形界面程序:

解压后，得到的lib包里有三个jar包文件，其中一个proguardgui.jar，是图形界面程序。 
　　运行方法：在同样的目录中，建一个批处理文件（bat文件），内容就一句：java -jar proguardgui.jar，保存文件，双击鼠标运行这个文件，图形界面就出现了。 
　　在图形界面中，只需简单的设置，就可以完成混淆的任务。

　　1.在"Input/Output"页签中，设置好要混淆的jar包，设置好混淆结果包的名字，指定好编译这个包需要的jar包，注意，jar包不要同名包含接口jar包及接口的实现jar包，Proguard会个定义重复的错。 
　　2.在"Shriking"页签中，选择一个Keep的类型，如果是WEB工程，就选Library，应用程序就选Application，等。 
　　3."Obfuscation"、"Optimization"页签中都选默认就可以了。有特殊要求，可以仔细研究一下文档。如果混淆结果使用程序功能不太正常，可以把Optimize选项关闭。反正我们最关心的是混淆，优化不优化无所谓。 
　　4."Information"页签中，有个Ignore warnings about possibly erronous input，如果混淆的时候，因为警告无法继续，可以把这个选项勾上。其它的选默认就可以了。 
　　5."Process"页签中，点"Process!"按钮进行混淆。也可以点"Save configuration..."按钮，保存配置文件。

以下面的Test.java文件为例：

import java.util.*;

import java.io.*;

public class Test {

    public static void main(String[] args) throws Exception {

        BufferedReader stdin = new BufferedReader(new InputStreamReader(System.in));

           String s = stdin.readLine();

        if(s.length()%2==0)

            System.out.println(showMsg1());

        else

            System.out.println(showMsg2());

        Flight a = new Flight();

        a.setName(s);

        System.out.println(a.output());

        Bomber b = new Bomber();

        b.setName(s);

        System.out.println(b.output());

        s = stdin.readLine();

        StringTokenizer st = new StringTokenizer(s);

        int n = Integer.parseInt(st.nextToken());

        System.out.println(compute(n));

    }

    public static String showMsg1() {

        return "You are my sun1";

    }

    public static String showMsg2() {

        return "You are my sun2";

    }

    public static int compute(int n) {

        if(n>1)

            return n*compute(n-1);

        else

            return 1;

    }

    public static class Flight{

        public Flight(){

        }

        public String output(){

            return this.name;

        }

        public void setName(String name){

            this.name="Flight:"+name;

        }

        private String name;

    }

    public static class Bomber{

        public Bomber(){

        }

        public String output(){

            return this.name;

        }

        public void setName(String name){

            this.name="Bomber:"+name;

        }

        private String name;

    }

}

首先jar cvf a.jar *.class打包程序，然后jad -d d:\ -r -s java d:\*.class反编译程序，生成Test.java文件，通过对比可以发现，它和原来文件的内容基本是相同的。

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.

// Jad home page: http://www.kpdus.com/jad.html

// Decompiler options: packimports(3)

// Source File Name:   Test.java

import java.io.*;

import java.util.StringTokenizer;

public class Test

{

    public static class Bomber

    {

        public String output()

        {

            return name;

        }

        public void setName(String s)

        {

            name = (new StringBuilder()).append("Bomber:").append(s).toString();

        }

        private String name;

        public Bomber()

        {

        }

    }

    public static class Flight

    {

        public String output()

        {

            return name;

        }

        public void setName(String s)

        {

            name = (new StringBuilder()).append("Flight:").append(s).toString();

        }

        private String name;

        public Flight()

        {

        }

    }

    public Test()

    {

    }

    public static void main(String args[])

        throws Exception

    {

        BufferedReader bufferedreader = new BufferedReader(new InputStreamReader(System.in));

        String s = bufferedreader.readLine();

        if(s.length() % 2 == 0)

            System.out.println(showMsg1());

        else

            System.out.println(showMsg2());

        Flight flight = new Flight();

        flight.setName(s);

        System.out.println(flight.output());

        Bomber bomber = new Bomber();

        bomber.setName(s);

        System.out.println(bomber.output());

        s = bufferedreader.readLine();

        StringTokenizer stringtokenizer = new StringTokenizer(s);

        int i = Integer.parseInt(stringtokenizer.nextToken());

        System.out.println(compute(i));

    }

    public static String showMsg1()

    {

        return "You are my sun1";

    }

    public static String showMsg2()

    {

        return "You are my sun2";

    }

    public static int compute(int i)

    {

        if(i > 1)

            return i * compute(i - 1);

        else

            return 1;

    }

}

进入Proguard的lib目录，用JDK打开proguardgui.jar（java -jar proguardgui.jar），点选Input/Output标签，选择要混淆的JAR包（注意是JAR包），输出JAR包，以及用到的所有类库。Proguard使用教程
点选Obfuscation标签，选中不需要混淆的类（要被反射的类绝对不能被混淆），一般是1，4，5，9，10，11，12这几个选项。

Proguard使用教程
a.txt的文件内容为：（混淆函数名）
Gcd
b.txt的文件内容为：（混淆类名）
A
B

点选Process标签，Process按钮，生产b.jar

Proguard使用教程

解压b.jar后，这时的3个class文件分别为A.class、B.class、Test.class；
重新反编译程序jad -d d:\b\ -r -s java d:\b\*.class，生成3个java文件：A.java、B.java、Test.java，具体内容如下：

A.java

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.

// Jad home page: http://www.kpdus.com/jad.html

// Decompiler options: packimports(3) 

public final class A

{

    public A()

    {

    }

    public final String Gcd()

    {

        return Gcd;

    }

    public final void Gcd(String s)

    {

        Gcd = (new StringBuilder()).append("Bomber:").append(s).toString();

    }

    private String Gcd;

}

B.java

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.

// Jad home page: http://www.kpdus.com/jad.html

// Decompiler options: packimports(3) 

public final class B

{

    public B()

    {

    }

    public final String Gcd()

    {

        return Gcd;

    }

    public final void Gcd(String s)

    {

        Gcd = (new StringBuilder()).append("Flight:").append(s).toString();

    }

    private String Gcd;

}

Test.java

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.

// Jad home page: http://www.kpdus.com/jad.html

// Decompiler options: packimports(3) 

import java.io.*;

import java.util.StringTokenizer;

public class Test

{

    public Test()

    {

    }

    public static void main(String args[])

    {

        String s;

        if((s = (args = new BufferedReader(new InputStreamReader(System.in))).readLine()).length() % 2 == 0)

            System.out.println("You are my sun1");

        else

            System.out.println("You are my sun2");

        Object obj;

        ((B) (obj = new B())).Gcd(s);

        System.out.println(((B) (obj)).Gcd());

        ((A) (obj = new A())).Gcd(s);

        System.out.println(((A) (obj)).Gcd());

        s = args.readLine();

        args = Integer.parseInt((args = new StringTokenizer(s)).nextToken());

        System.out.println(Gcd(args));

    }

    private static int Gcd(int i)

    {

        if(i > 1)

            return i * Gcd(i - 1);

        else

            return 1;

    }

}

通过对比可以发现，它和原来文件的内容有许多出入。

上一篇：Java 并发编程-再谈 AbstractQueuedSynchronizer 2:共享模式与基于 Condition 的等待 / 通知机制实现


下一篇：Navicat for MySQL11--使用经验