为您推荐:
精华内容
最热下载
问答
  • 44KB weixin_42162216 2021-02-02 22:47:44
  • 24KB g5zhu5896 2020-12-25 11:26:12
  • 37KB weixin_38697579 2021-06-04 15:56:11
  • 5.11MB weixin_38669628 2019-08-14 01:11:45
  • zheshou03 2020-08-13 11:06:24
  • 一、场景介绍 两个工程 Project1,Project2(将被混淆的工程)。Project1 将通过 Maven 依赖配置的方式引用混淆后的 Project2。后面我会详细介绍 pom.xml 的配置。 二、Maven 配置 1、Project1 的 pom...

    一、场景介绍

    两个工程 Project1,Project2(将被混淆的工程)。Project1 将通过 Maven 依赖配置的方式引用混淆后的 Project2。后面我会详细介绍 pom.xml 的配置。

    二、Maven 配置

    1、Project1 的 pom.xml

    该 pom.xml 比较简单主要通过 classifier 来判断是否使用混淆的 Jar(Project2)

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>org.noahx.proguard.example</groupId>
        <artifactId>project1</artifactId>
        <version>1.0-SNAPSHOT</version>
    
        <dependencies>
            <dependency>
                <groupId>org.noahx.proguard.example</groupId>
                <artifactId>project2</artifactId>
                <classifier>pg</classifier> <!--如果不想依赖混淆的包,请注释掉该行-->
                <version>1.0-SNAPSHOT</version>
            </dependency>
        </dependencies>
    
    </project>


    2、Project2 的 pom.xml

    pom.xml 中配置的 proguard-maven-plugin 来做混淆,详细说明见注释。

    <?xml version="1.0" encoding="UTF-8"?>
    <project xmlns="http://maven.apache.org/POM/4.0.0"
             xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
             xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>org.noahx.proguard.example</groupId>
        <artifactId>project2</artifactId>
        <version>1.0-SNAPSHOT</version>
    
    
        <build>
            <plugins>
    
                <plugin>
                    <groupId>com.github.wvengen</groupId>
                    <artifactId>proguard-maven-plugin</artifactId>
                    <version>2.0.7</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>proguard</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <attach>true</attach>
                        <attachArtifactClassifier>pg</attachArtifactClassifier>
                        <!-- attach 的作用是在 install 与 deploy 时将生成的 pg 文件也安装与部署 -->
                        <options> <!-- 详细配置方式参考 ProGuard 官方文档 -->
                            <!--<option>-dontobfuscate</option>-->
                            <option>-ignorewarnings</option> <!--忽略所有告警-->
                            <option>-dontshrink</option>   <!--不做 shrink -->
                            <option>-dontoptimize</option> <!--不做 optimize -->
                            <option>-dontskipnonpubliclibraryclasses</option>
                            <option>-dontskipnonpubliclibraryclassmembers</option>
    
                            <option>-repackageclasses org.noahx.proguard.example.project2.pg</option>
                            <!--平行包结构(重构包层次),所有混淆的类放在 pg 包下-->
    
                            <!-- 以下为 Keep,哪些内容保持不变,因为有一些内容混淆后(a,b,c)导致反射或按类名字符串相关的操作失效 -->
    
                            <option>-keep class **.package-info</option>
                            <!--保持包注解类-->
    
                            <option>-keepattributes Signature</option>
                            <!--JAXB NEED,具体原因不明,不加会导致 JAXB 出异常,如果不使用 JAXB 根据需要修改-->
                            <!-- Jaxb requires generics to be available to perform xml parsing and without this option ProGuard was not retaining that information after obfuscation. That was causing the exception above. -->
    
                            <option>-keepattributes SourceFile,LineNumberTable,*Annotation*</option>
                            <!--保持源码名与行号(异常时有明确的栈信息),注解(默认会过滤掉所有注解,会影响框架的注解)-->
    
                            <option>-keepclassmembers enum org.noahx.proguard.example.project2.** { *;}</option>
                            <!--保持枚举中的名子,确保枚举 valueOf 可以使用-->
    
                            <option>-keep class org.noahx.proguard.example.project2.bean.** { *;}</option>
                            <!--保持 Bean 类,(由于很多框架会对 Bean 中的内容做反射处理,请根据自己的业务调整) -->
    
                            <option>-keep class org.noahx.proguard.example.project2.Project2 { public void init(); public void
                                destroy(); }
                            </option>
                            <!-- 保持对外的接口性质类对外的类名与方法名不变 -->
    
                        </options>
                        <outjar>${project.build.finalName}-pg</outjar>
                        <libs>
                            <lib>${java.home}/lib/rt.jar</lib>
                        </libs>
    
                    </configuration>
                </plugin>
    
             </plugins>
        </build>
    
    </project>


    三、Java 混淆前后内容比较

    这里只比较 Project2 类的不同。其它类的比较,请大家使用 jd-gui 等反编译工具进行比较。

    1、混淆前的 Project2 类

    package org.noahx.proguard.example.project2;
    
    import org.noahx.proguard.example.project2.dao.TestDao;
    import org.noahx.proguard.example.project2.impl.User;
    
    /**
     * Created by noah on 8/20/14.
     */
    public class Project2 {
    
        public void init() {
            test1();
            test2();
        }
    
        private void test1() {
            Status on = Status.valueOf("On");
            switch (on) {
                case On: {
    
                }
                break;
                case Off: {
    
                }
                break;
            }
        }
    
        private void test2() {
            TestDao testDao=new TestDao();
            User user=new User();
            user.setUserid("abc");
            user.setPassword("pwd");
            user.setDescription("des");
            testDao.save(user);
    
        }
    
        private void test3() {
        }
    
        private void test4() {
        }
    
        private void throwException() {
            throw new RuntimeException("hello");
        }
    
        public void destroy() {
            test3();
            test4();
            throwException();
        }
    }


    2、混淆后的 Project2 类

    所有没有指定 keep 的内容都变为了 a,b,c...,增大了阅读难度。

    package org.noahx.proguard.example.project2;
    
    import org.noahx.proguard.example.project2.pg.a;
    
    public class Project2
    {
      public void init()
      {
        b();
        c();
      }
    
      private void b() {
        b localb = b.valueOf("On");
        switch (a.a[localb.ordinal()])
        {
        case 1:
          break;
        case 2:
        }
      }
    
      private void c()
      {
        a locala = new a();
        org.noahx.proguard.example.project2.pg.b localb = new org.noahx.proguard.example.project2.pg.b();
        localb.a("abc");
        localb.b("pwd");
        localb.c("des");
        locala.a(localb);
      }
    
      private void d()
      {
      }
    
      private void e() {
      }
    
      public void a() {
        throw new RuntimeException("hello");
      }
    
      public void destroy() {
        d();
        e();
        a();
      }
    }


    四、类路径中资源加载问题

    使用 ProGuard 产生的 Jar 包,会发生无法定位 Jar 中资源的问题。原因不详,我没有太深入研究。

    使用 [类名].class.getResource(),Thread.currentThread().getContextClassLoader().getResource(),不论是否以“/”开头都返回 null。没有混淆的 Jar 是没有这个问题的。

    我使用了一种直接读取 Jar 中内容的方式来解决。

    final File jarFile = new File([类名].class.getProtectionDomain().getCodeSource().getLocation().getPath()); //定位类所在的 Jar 文件
                if(jarFile.isFile()) {
                    final JarFile jar = new JarFile(jarFile);
                    Enumeration<JarEntry> entries = jar.entries();
                    while (entries.hasMoreElements()) {
                        JarEntry entry = entries.nextElement();
                        if (entry.getName().startsWith("org/noahx")) {
                            InputStream entryInputStream = jarFile.getInputStream(entry);  //遍历包中的内容来获得资源
                        }
                    }
                    jar.close();
                }

    五、总结

    使用 proguard-maven-plugin 插件,既保持了 Maven 的依赖模式,又满足了我的混淆需求。其它详细的参数配置,大家可以参考官方文档。

    ProGuard 满足了我的需求。至于是好是坏,希望大家不要围绕这点做没有必要的争论,谢谢。

    样例程序下载:http://pan.baidu.com/s/1dDGNoDr


    转载于:https://my.oschina.net/noahxiao/blog/304746

    展开全文
    chijiefen1087 2019-09-15 14:38:51
  • &lt;plugin&gt; &lt;groupId&gt;com.github.wvengen&lt;/groupId&gt;...proguard-maven-plugin&lt;/artifactId&gt; &lt;version&gt;2.0.11&lt;/v...
    <plugin>
                    <groupId>com.github.wvengen</groupId>
                    <artifactId>proguard-maven-plugin</artifactId>
                    <version>2.0.11</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>proguard</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
    
                        <attach>true</attach>
                        <attachArtifactClassifier>proguard</attachArtifactClassifier>
                        <!-- attach 的作用是在 install 与 deploy 时将生成的 pg 文件也安装与部署 -->
                        <options> <!-- 详细配置方式参考 ProGuard 官方文档 -->
                            <!--<option>-dontobfuscate</option>-->
                            <option>-ignorewarnings</option> <!--忽略所有告警-->
                            <option>-dontshrink</option>   <!--不做 shrink -->
                            <option>-dontoptimize</option> <!--不做 optimize -->
                            <option>-dontskipnonpubliclibraryclasses</option>
                            <option>-dontskipnonpubliclibraryclassmembers</option>
    
                            <!--不要重构包名
                          <option>-repackageclasses org.noahx.proguard.example.project2.pg</option>
                          -->
                            <!--平行包结构(重构包层次),所有混淆的类放在 pg 包下-->
    
                            <!--保护程序入口-->
                            <!--<option>-keep public class com.yunshouhu.apkprotect.MainHelper { public static void main(java.lang.String[]);}</option>-->
                            <!-- 以下为 Keep,哪些内容保持不变,因为有一些内容混淆后(a,b,c)导致反射或按类名字符串相关的操作失效 -->
                            <option>-keep class **.consolemodel.**</option>
                            <option>-keep class **.service.**</option>
                            <!--保持包注解类-->
                            <option>-keepattributes Signature</option>
                            <!--JAXB NEED,具体原因不明,不加会导致 JAXB 出异常,如果不使用 JAXB 根据需要修改-->
                            <!-- Jaxb requires generics to be available to perform xml parsing and without this option ProGuard was not retaining that information after obfuscation. That was causing the exception above. -->
                            <option>-keepattributes SourceFile,LineNumberTable,*Annotation*</option>
                            <!--保持源码名与行号(异常时有明确的栈信息),注解(默认会过滤掉所有注解,会影响框架的注解)-->
                            <!--<option>-keepclassmembers enum org.noahx.proguard.example.project2.** { *;}</option>-->
                            <!--保持枚举中的名子,确保枚举 valueOf 可以使用-->
                            <!--<option>-keep class org.noahx.proguard.example.project2.bean.** { *;}</option>-->
                            <!--保持 Bean 类,(由于很多框架会对 Bean 中的内容做反射处理,请根据自己的业务调整) -->
                            <!--<option>-keep class org.noahx.proguard.example.project2.Project2 { public void init(); public void  destroy(); }</option>-->
                            <!-- 保持对外的接口性质类对外的类名与方法名不变 -->
                        </options>
                        <!--<outjar>${project.build.finalName}-proguard</outjar>-->
                        <outjar>${project.build}-proguard</outjar>
                        <libs>
                            <lib>${java.home}/lib/rt.jar</lib>
                        </libs>
    
                    </configuration>
                </plugin>

     

    展开全文
    hety119 2018-12-07 17:08:15
  • com.github.wvengen:proguard-maven-plugin:2.0.11文件名或扩展名太长 这样的报错,好像是因为Windows命令行支持的字符串长度有限制。Linux不会有这个问题。 我这里的解决方法是把repository的路径改短,就是把你的...

    最近接手一个IBM的项目,在mvn install的时候出现了
    com.github.wvengen:proguard-maven-plugin:2.0.11文件名或扩展名太长
    这样的报错,好像是因为Windows命令行支持的字符串长度有限制。Linux不会有这个问题。
    我这里的解决方法是把repository的路径改短,就是把你的仓库路径改一下,然后去maven的conf文件夹里把setting.xml的路径改一下
    在这里插入图片描述

    除了这个方法,还有一个就是把pom.xml文件中那个proguard的插件注释掉,反正也不影响开发,编译效率还高,部署的时候再把注解去掉吧。

    还有我想的一个办法就是解除win10路径长度限制,经实验证明不可行,我咨询过了微软的工程师,cmd最大长度为8191,为系统级别的限制,无法更改,这个问题也是醉了,都2021年了,也不解决一下,还是解除限制有什么后顾之忧???

    最后还有一个办法,在VMWare中运行Ubuntu,在linux的系统上写代码,但是这个就麻烦了,环境得重新配起来,如果有时间的话还是可以这么玩的,也有不少人是这么干的。

    展开全文
    weixin_44388689 2021-02-19 15:48:17
  • 基于Maven的项目一般会去考虑使用proguard-maven-plugin,但是这个插件仅支持打Jar包不支持打War包。 于是我用空闲时间在proguard-maven-plugin的基础上修改了里面的一部分逻辑,可以在项目构建过的时候把代码混淆...

    大家可能都会碰到一些代码比较敏感的项目场景,这个时候代码被反编译看到就不好了,这个时候就需要代码混淆插件来对代码进行混淆了。

    基于Maven的项目一般会去考虑使用proguard-maven-plugin,但是这个插件仅支持打Jar包不支持打War包。

    于是我用空闲时间在proguard-maven-plugin的基础上修改了里面的一部分逻辑,可以在项目构建过的时候把代码混淆,支持打成jar包和war包。 

    现在贴出来给大家看看。

    项目地址
    https://github.com/lovethegirl/code-hidding-plugin

    修改部分
    War包压缩解压的工具类

    package com.github.wvengen.maven.proguard;
     
    import java.io.BufferedInputStream;
    import java.io.BufferedOutputStream;
    import java.io.File;
    import java.io.FileInputStream;
    import java.io.FileNotFoundException;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    import java.util.Iterator;
     
    import org.apache.commons.compress.archivers.ArchiveException;
    import org.apache.commons.compress.archivers.ArchiveInputStream;
    import org.apache.commons.compress.archivers.ArchiveOutputStream;
    import org.apache.commons.compress.archivers.ArchiveStreamFactory;
    import org.apache.commons.compress.archivers.jar.JarArchiveEntry;
    import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
    import org.apache.commons.compress.utils.IOUtils;
    import org.apache.commons.io.FileUtils;
     
    /**
     * 处理WAR文件工具类。可压缩或解压缩WAR文件。
     * 
     * @author Xiong Shuhong(shelltea@gmail.com)
     */
    public class WarUtils {
        public static void unzip(String warPath, String unzipPath) {
            File warFile = new File(warPath);
            try {
                BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(
                    warFile));
                ArchiveInputStream in = new ArchiveStreamFactory().createArchiveInputStream(
                    ArchiveStreamFactory.JAR, bufferedInputStream);
     
                JarArchiveEntry entry = null;
                while ((entry = (JarArchiveEntry) in.getNextEntry()) != null) {
                    File file = new File(unzipPath, entry.getName());
                    if (file.exists()) {
                        file.delete();
                    }
                    if (entry.isDirectory()) {
                        file.mkdir();
                    } else {
                        OutputStream out = FileUtils.openOutputStream(file);
                        IOUtils.copy(in, out);
                        out.close();
                    }
                }
                in.close();
            } catch (FileNotFoundException e) {
                System.err.println("未找到war文件");
            } catch (ArchiveException e) {
                System.err.println("不支持的压缩格式");
            } catch (IOException e) {
                System.err.println("文件写入发生错误");
            }
        }
     
        public static void zip(String destFile, String zipDir) {
            File outFile = new File(destFile);
            try {
                outFile.createNewFile();
                BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(
                    new FileOutputStream(outFile));
                ArchiveOutputStream out = new ArchiveStreamFactory().createArchiveOutputStream(
                    ArchiveStreamFactory.JAR, bufferedOutputStream);
     
                if (zipDir.charAt(zipDir.length() - 1) != '/') {
                    zipDir += '/';
                }
     
                Iterator<File> files = FileUtils.iterateFiles(new File(zipDir), null, true);
                while (files.hasNext()) {
                    File file = files.next();
                    ZipArchiveEntry zipArchiveEntry = new ZipArchiveEntry(file, file.getPath().replace(
                        zipDir.replace("/", "\\"), ""));
                    out.putArchiveEntry(zipArchiveEntry);
                    IOUtils.copy(new FileInputStream(file), out);
                    out.closeArchiveEntry();
                }
                out.finish();
                out.close();
            } catch (IOException e) {
                System.err.println("创建文件失败");
            } catch (ArchiveException e) {
                System.err.println("不支持的压缩格式");
            }
        }
    }
    修改ProGuardMojo.java中的代码,在打包的时候把混淆后的代码打进war包,具体可从Git上把项目down下来查看。
    if (attach && !sameArtifact) {
                //操作war解压,等一系列操作
                String absolutePath = outJarFile.getAbsolutePath();
                getLog().info("---absolutePath--" + absolutePath);
                String unzipPath = outJarFile.getParent() + "/proguard-war";
                getLog().info("删除路径" + absolutePath);
                deleteDir(unzipPath);
                File unZipFile = new File(unzipPath);
                unZipFile.mkdir();
                String targetWar = mavenProject.getBuild().getDirectory() + "/"
                                   + mavenProject.getBuild().getFinalName() + ".war";
                getLog().info(targetWar);
                WarUtils.unzip(targetWar, unzipPath);
                //删除路径"
                deleteDir(unzipPath + "/WEB-INF/classes");
                WarUtils.unzip(absolutePath, unzipPath + "/WEB-INF/classes");
                outJarFile.delete();
                WarUtils.zip(absolutePath, outJarFile.getParent() + "/proguard-war");
                getLog().info("---absolutePath--" + absolutePath);
                if (useArtifactClassifier()) {
                    projectHelper.attachArtifact(mavenProject, attachArtifactType,
                        attachArtifactClassifier, outJarFile);
                } else {
                    projectHelper.attachArtifact(mavenProject, attachArtifactType, null, outJarFile);
                }
            }
    然后,运行maven install后,可以在仓库目录中看到打出来的混淆过的war包

    使用方法

    先进行Maven install

    然后在需要混淆代码的工程中加入此插件的依赖

          <plugin>
                    <groupId>com.jiujie</groupId>
                    <artifactId>code-hidding-plugin</artifactId>
                    <version>1.0</version>
                    <executions>
                        <execution>
                            <phase>package</phase>
                            <goals>
                                <goal>proguard</goal>
                            </goals>
                        </execution>
                    </executions>
                    <configuration>
                        <obfuscate>true</obfuscate>
                        <attach>true</attach>
                        <injar>classes</injar>
                        <attachArtifactClassifier>pg</attachArtifactClassifier>
                        attach 的作用是在 install 与 deploy 时将生成的 pg 文件也安装与部署
                        <proguardInclude>${basedir}/proguard.conf</proguardInclude>
                        <outjar>${project.build.finalName}-pg</outjar>
                        <libs>
                            <lib>${java.home}/lib/rt.jar</lib>
                            <lib>${java.home}/lib/jsse.jar</lib>
                        </libs>
                        <addMavenDescriptor>false</addMavenDescriptor>
                    </configuration>
                </plugin>
    在工程根目录下加入工程配置文件proguard.conf

    # ----------------------------------  
    #  通过指定数量的优化能执行  
    #  -optimizationpasses n  
    # ----------------------------------  
    #-optimizationpasses 3  

    # ----------------------------------  
    #   混淆时不会产生形形色色的类名   
    #   -dontusemixedcaseclassnames  
    # ----------------------------------  
    #-dontusemixedcaseclassnames
    # ----------------------------------  
    #      指定不去忽略非公共的库类  
    #  -dontskipnonpubliclibraryclasses  
    # ----------------------------------  

    # ----------------------------------  
    #       不预校验  
    #    -dontpreverify  
    # ----------------------------------  
    # -dontpreverify  
    #忽略所有告警
    -ignorewarnings
    #不做 shrink
    -dontshrink
    #不做 optimize
    -dontoptimize


    # ----------------------------------  
    #      输出生成信息  
    #       -verbose  
    # ----------------------------------  
    -verbose  

    #混淆时应用侵入式重载   
    #-overloadaggressively   

    #优化时允许访问并修改有修饰符的类和类的成员   
    #-allowaccessmodification  
    #确定统一的混淆类的成员名称来增加混淆   


    #这里添加你不需要混淆的类  
    #-keep  class com.showjoy.common.cache.** {*;}   
    -keepclasseswithmembers class com.showjoy.cart.service.** {  
        <fields>;  
    }  
    -keepclasseswithmembers class com.showjoy.cart.ui.cart.** {  
        <fields>;  
    }  
    -keepclassmembers class com.showjoy.cart.CartControllerHandler {  
        <fields>;  
    }  
    -keepclassmembers class com.showjoy.cart.CartExceptionHandler {  
        <fields>;  
    }  
    -keep class com.showjoy.cart.util.EncodeUtil {*;}   

    #-keep public class * extends  javax.servlet.Servlet  


    #-keepdirectories  **  
    #-keepattributes **  
    #-useuniqueclassmembernames  
    #保持源码名与行号(异常时有明确的栈信息),注解(默认会过滤掉所有注解,会影响框架的注解)
    -keepattributes SourceFile,LineNumberTable,*Annotation*
    #保持包注解类
    -keepattributes Signature

    #-keepnames class * implements java.io.Serializable  
    # ---------保护所有实体中的字段名称----------  
    #-keepclassmembers class * implements java.io.Serializable {  
    #    <fields>;  
    #}  

    # --------- 保护类中的所有方法名 ------------  
    #-keepclassmembers class * {  
    #    public <methods>;  
    #}  
    ProGuard说明与配置
    官网:http://proguard.sourceforge.net/
    ProGuard的使用是为了:

    1.创建紧凑的代码文档是为了更快的网络传输,快速装载和更小的内存占用.
    2.创建的程序和程序库很难使用反向工程.
    3.所以它能删除来自源文件中的没有调用的代码
    4.充分利用java6的快速加载的优点来提前检测和返回java6中存在的类文件.


    参数:
    -include {filename} 从给定的文件中读取配置参数
    -basedirectory {directoryname} 指定基础目录为以后相对的档案名称
    -injars {class_path} 指定要处理的应用程序jar,war,ear和目录
    -outjars {class_path} 指定处理完后要输出的jar,war,ear和目录的名称
    -libraryjars {classpath} 指定要处理的应用程序jar,war,ear和目录所需要的程序库文件
    -dontskipnonpubliclibraryclasses 指定不去忽略非公共的库类。
    -dontskipnonpubliclibraryclassmembers 指定不去忽略包可见的库类的成员。


    保留选项
    -keep {Modifier} {class_specification} 保护指定的类文件和类的成员
    -keepclassmembers {modifier} {class_specification} 保护指定类的成员,如果此类受到保护他们会保护的更好
    -keepclasseswithmembers {class_specification} 保护指定的类和类的成员,但条件是所有指定的类和类成员是要存在。
    -keepnames {class_specification} 保护指定的类和类的成员的名称(如果他们不会压缩步骤中删除)
    -keepclassmembernames {class_specification} 保护指定的类的成员的名称(如果他们不会压缩步骤中删除)
    -keepclasseswithmembernames {class_specification} 保护指定的类和类的成员的名称,如果所有指定的类成员出席(在压缩步骤之后)
    -printseeds {filename} 列出类和类的成员-keep选项的清单,标准输出到给定的文件


    压缩
    -dontshrink 不压缩输入的类文件
    -printusage {filename}
    -whyareyoukeeping {class_specification}


    优化
    -dontoptimize 不优化输入的类文件
    -assumenosideeffects {class_specification} 优化时假设指定的方法,没有任何副作用
    -allowaccessmodification 优化时允许访问并修改有修饰符的类和类的成员

    混淆
    -dontobfuscate 不混淆输入的类文件
    -printmapping {filename}
    -applymapping {filename} 重用映射增加混淆
    -obfuscationdictionary {filename} 使用给定文件中的关键字作为要混淆方法的名称
    -overloadaggressively 混淆时应用侵入式重载
    -useuniqueclassmembernames 确定统一的混淆类的成员名称来增加混淆
    -flattenpackagehierarchy {package_name} 重新包装所有重命名的包并放在给定的单一包中
    -repackageclass {package_name} 重新包装所有重命名的类文件中放在给定的单一包中
    -dontusemixedcaseclassnames 混淆时不会产生形形色色的类名
    -keepattributes {attribute_name,...} 保护给定的可选属性,例如LineNumberTable, LocalVariableTable, SourceFile, Deprecated, Synthetic, Signature, and InnerClasses.
    -renamesourcefileattribute {string} 设置源文件中给定的字符串常量

    因为我们开发的是webwork+spring+hibernate的架构的项目,所有需要很详细的配置。(经过n次失败后总结)


    Example:
    -injars <project>.jar
    -outjars <project>_out.jar
    -libraryjars <java.home>/lib/rt.jar
    -libraryjars <project.home>/webroot/WEB-INF/lib/webwork.jar
    .......

    # 保留实现Action接口类中的公有的,友好的,私有的属性 和 公有的,友好的方法。其它的全部压缩,优化,混淆。
    # 因为配置文件中的类名是一个完整的类名,如果经过处理后就有可能找不到这个类。
    # 属性是jsp页面所需要的,如果经过处理jsp页面就无法得到action中的数据。
    -keep public class * implements com.opensymphony.xwork.Action{
    public protected private <fields>;
    public protected <methods>;
    }
    # 保留实现了Serializable接口类中的公有的,友好的,私有的成员(属性和方法)
    # 这个配置主要是对应实体类的配置。
    -keep public class * implements java.io.Serializable{
    public protected private *;
    }
    ......
    --------------------- 
    作者:笔下生灰 
    来源:CSDN 
    原文:https://blog.csdn.net/connect_me/article/details/51320913 
    版权声明:本文为博主原创文章,转载请附上博文链接!

    展开全文
    zhousenshan 2019-03-11 22:24:18
  • earbao 2016-03-28 18:27:16
  • testcs_dn 2015-05-08 14:25:40
  • testcs_dn 2015-05-11 11:53:33
  • weixin_34101229 2016-11-02 11:02:00
  • weixin_34326558 2015-05-08 16:34:53
  • weixin_34355559 2016-04-24 11:55:11
  • jing_xin 2020-09-19 12:03:59
  • qq_35981283 2017-11-14 14:04:55

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,017
精华内容 2,006
关键字:

proguard-maven-plugin