java混淆器
㈠ 大神求解，java混淆器，怎么才能只混淆方法体，我试了几天都不行，怎么才能只混淆方法体，求解。
app开发完后，最好做一下扫描和加固，应用扫描可以通过静态代码分析、动态数据跟踪，定版位出风险代码，权同时监控敏感数据的异常行为。
加固可以在一定程度上保护自己核心代码算法,提高破解/盗版/二次打包的难度，缓解代码注入/动态调试/内存注入攻击等。
目前市面上有很多第三方加固的平台， 如果新应用发布前需要扫描或者加固的话，可以先试试免费的，例如腾讯御安全，建议自己先去扫描测试下。
㈡ 疑问Java反射会不会被“混淆器"给毁掉
混淆的作用并复不是使class文件不能被反制编译
混淆的作用是使反编译的代码更难让人阅读，比如一些计算金钱的敏感逻辑里有如下的代码(新金额=旧金额*某个倍率)：
double newMoney=oldMoney*rate;
如果这样的代码直接编译成class文件，别人反编译这个class文件就能很清楚的看到金钱的计算关系，混淆后代码可能就变成这样的了：
double a=b*c;
这样的代码别人即使反编译了，也是很难看懂其中的逻辑关系的
㈢ 有没有 Java 代码混淆工具，不是混淆 jar 包，是混淆代码
Java代码混淆就像男女在一起分不出来一样，这样男女就变成Java的使用者----伟大的Java程序员了
㈣ JAVA 有对源代码进行混淆的混淆器么
不需要对源代码混淆。class有这种功能的，在J2ME中混淆是必须的，结果跟你说的一样，不过原理不是你那么走的，混淆以后的class反编译也会让人看不懂，全部变成了a,b,c,d这样的名字。
㈤ 有java混淆器的eclipse插件吗
android应用程序的混淆打包
1 . 在工程文件project.properties中加入下proguard.config=proguard.cfg ， 如下所示：
target=android-8
proguard.config=proguard.cfg
Eclipse会通过此配置在工程目录生成proguard.cfg文件
2 . 生成keystore (如已有可直接利用)
按照下面的命令行 在D:\Program Files\Java\jdk1.6.0_07\bin>目录下，输入keytool -genkey -alias android.keystore -keyalg RSA -validity 100000 -keystore android.keystore
参数意义：-validity主要是证书的有效期，写100000天；空格，退格键 都算密码。
命令执行后会在D:\Program Files\Java\jdk1.6.0_07\bin>目录下生成 android.keystore文件。
3. 在Eclipce的操作
File -> Export -> Export Android Application -> Select project -> Using the existing keystore , and input password -> select the destination APK file
经过混淆后的源代码，原先的类名和方法名会被类似a,b,c。。。的字符所替换，混淆的原理其实也就是类名和方法名的映射。
proguard 自己考一个就行
----------------------------------------------------------------------------------------
proguard 原理
Java代码编译成二进制class 文件，这个class
文件也可以反编译成源代码 ，除了注释外，原来的code 基本都可以看到。为了防止重要code
被泄露，我们往往需要混淆（Obfuscation code ， 也就是把方法，字段，包和类这些java
元素的名称改成无意义的名称，这样代码结构没有变化，还可以运行，但是想弄懂代码的架构却很难。 proguard
就是这样的混淆工具，它可以分析一组class 的结构，根据用户的配置，然后把这些class 文件的可以混淆java
元素名混淆掉。在分析class 的同时，他还有其他两个功能，删除无效代码（Shrinking 收缩），和代码进行优化
（Optimization Options）。
缺省情况下，proguard
会混淆所有代码，但是下面几种情况是不能改变java 元素的名称，否则就会这样就会导致程序出错。
一， 我们用到反射的地方。
二，
我们代码依赖于系统的接口，比如被系统代码调用的回调方法，这种情况最复杂。
三， 是我们的java
元素名称是在配置文件中配置好的。
所以使用proguard时，我们需要有个配置文件告诉proguard
那些java 元素是不能混淆的。
proguard 配置
最常用的配置选项
-dontwarn 缺省proguard
会检查每一个引用是否正确，但是第三方库里面往往有些不会用到的类，没有正确引用。如果不配置的话，系统就会报错。
-keep 指定的类和类成员被保留作为 入口
。
-keepclassmembers
指定的类成员被保留。
-keepclasseswithmembers
指定的类和类成员被保留，假如指定的类成员存在的话。
proguard 问题和风险
代码混淆后虽然有混淆优化的好处，但是它往往也会带来如下的几点问题
1，混淆错误，用到第三方库的时候，必须告诉 proguard
不要检查，否则proguard 会报错。
2，运行错误，当code
不能混淆的时候，我们必须要正确配置，否则程序会运行出错，这种情况问题最多。
3，调试苦难，出错了，错误堆栈是混淆后的代码
，自己也看不懂。
为了防止混淆出问题，你需要熟悉你所有的code ，系统的架构
，以及系统和你code的集成的接口，并细心分析。 同时你必须需要一轮全面的测试。 所以混淆也还是有一定风险的。
为了避免风险，你可以只是混淆部分关键的代码，但是这样你的混淆的效果也会有所降低。
常见的不能混淆的androidCode
Android 程序
，下面这样代码混淆的时候要注意保留。
Android系统组件，系统组件有固定的方法被系统调用。
被Android Resource
文件引用到的。名字已经固定，也不能混淆，比如自定义的View 。
Android Parcelable ，需要使用android
序列化的。
其他Anroid 官方建议
不混淆的，如
android.app.backup.BackupAgentHelper
android.preference.Preference
com.android.vending.licensing.ILicensingService
Java序列化方法，系统序列化需要固定的方法。
枚举 ，系统需要处理枚举的固定方法。
本地方法，不能修改本地方法名
annotations 注释
数据库驱动
有些resource 文件
用到反射的地方
如何实施
现在的系统已经配置为混淆时候会保留
Android系统组件
自定义View
Android Parcelable
Android R 文件
Android Parcelable
枚举
各个开发人员必须检查自己的code 是否用到反射
，和其他不能混淆的地方。告诉我来修改配置文件（已经保留的就不需要了）
目前系统部检查的第三方库为
-dontwarn
android.support.**
-dontwarn
com.tencent.**
-dontwarn
org.dom4j.**
-dontwarn
org.slf4j.**
-dontwarn
org.http.mutipart.**
-dontwarn
org.apache.**
-dontwarn
org.apache.log4j.**
-dontwarn
org.apache.commons.logging.**
-dontwarn
org.apache.commons.codec.binary.**
-dontwarn
weibo4android.**
proguard 参数
-include {filename}
从给定的文件中读取配置参数
-basedirectory {directoryname}
指定基础目录为以后相对的档案名称
-injars {class_path}
指定要处理的应用程序jar,war,ear和目录
-outjars {class_path}
指定处理完后要输出的jar,war,ear和目录的名称
-libraryjars {classpath}
指定要处理的应用程序jar,war,ear和目录所需要的程序库文件
-
指定不去忽略非公共的库类。
-
指定不去忽略包可见的库类的成员。
保留选项
-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}
设置源文件中给定的字符串常量
解决export打包的报错
这个时候export提示“conversion to Dalvik
format failed with error
1”错误，网上说法有好多种，最后我还是把proguard从4.4升级到4.8就解决了。
升级办法很简单，就是把android
sdk目录下的tool/proguard目录覆盖一下即可。
打包出来的程序如何调试
一旦打包出来，就不能用eclipse的logcat去看了，这里可以用android
sdk中ddms.bat的tool来看，一用就发现和logcat其实还是一个东西，就是多了个设备的选择。
使用 gson 需要的配置
当Gson用到了泛型就会有报错，这个真给郁闷了半天，提示“Missing
type
parameter”。最后找到一个资料给了一个解决办法，参考：http://stackoverflow.com/questio ...
sing-type-parameter。
另外我又用到了JsonObject，提交的Object里面的members居然被改成了a。所以上面给的东西还不够，还要加上
# 用到自己拼接的JsonObject
-keep class com.google.gson.JsonObject
{ *; }
个人建议减少这些依赖包混淆带来的麻烦，干脆都全部保留不混淆。例如
-keep class com.badlogic.** { *;
}
-keep class * implements
com.badlogic.gdx.utils.Json*
-keep class com.google.** { *;
}
使用libgdx需要的配置
验证打包效果
利用了apktool的反编译工具，把打包文件又解压了看了一下，如果包路径、类名、变量名、方法名这些变化和你期望一致，那就OK了。命令：
apktool.bat d xxx.apk
destdir
配置实例
-injars
androidtest.jar【jar包所在地址】
-outjars
out【输出地址】
-libraryjars
'D:\android-sdk-windows\platforms\android-9\android.jar'
【引用的库的jar，用于解析injars所指定的jar类】
-optimizationpasses
5
-dontusemixedcaseclassnames
【混淆时不会产生形形色色的类名 】
-
【指定不去忽略非公共的库类。 】
-dontpreverify
【不预校验】
-verbose
-optimizations
!code/simplification/arithmetic,!field/*,!class/merging/*
【优化】
-keep public class * extends
android.app.Activity【不进行混淆保持原样】
-keep public class * extends
android.app.Application
-keep public class * extends
android.app.Service
-keep public class * extends
android.content.BroadcastReceiver
-keep public class * extends
android.content.ContentProvider
-keep public class * extends
android.app.backup.BackupAgentHelper
-keep public class * extends
android.preference.Preference
-keep public class
com.android.vending.licensing.ILicensingService
-keep public abstract interface
com.asqw.android.Listener{
public protected ;
【所有方法不进行混淆】
}
-keep public class
com.asqw.android{
public void Start(java.lang.String);
【对该方法不进行混淆】
}
-keepclasseswithmembernames class * {
【保护指定的类和类的成员的名称，如果所有指定的类成员出席（在压缩步骤之后）】
native ;
}
-keepclasseswithmembers class * {
【保护指定的类和类的成员，但条件是所有指定的类和类成员是要存在。】
public (android.content.Context,
android.util.AttributeSet);
}
-keepclasseswithmembers class *
{
public (android.content.Context,
android.util.AttributeSet, int);
}
-keepclassmembers class * extends
android.app.Activity {【保护指定类的成员，如果此类受到保护他们会保护的更好
】
public void
*(android.view.View);
}
-keepclassmembers enum *
{
public static **[]
values();
public static **
valueOf(java.lang.String);
}
-keep class * implements
android.os.Parcelable {【保护指定的类文件和类的成员】
public static final
android.os.Parcelable$Creator *;
}
//不混淆指定包下的类
-keep class
com.aspire.**
㈥ javacompile混淆器怎么混淆后的class文件还是可以被反编译出来呢求高手指点....
混淆的作用并不是使class文件不能被反编译
混淆的作用是使反编译的代码更难让人阅读，比如一些回计算金钱答的敏感逻辑里有如下的代码(新金额=旧金额*某个倍率)：
double newMoney=oldMoney*rate;
如果这样的代码直接编译成class文件，别人反编译这个class文件就能很清楚的看到金钱的计算关系，混淆后代码可能就变成这样的了：
double a=b*c;
这样的代码别人即使反编译了，也是很难看懂其中的逻辑关系的
㈦ 除了proguard还有免费的java混淆器吗
我们做java开发的一般都会遇到如何保护我们开发的代码问题。java语言由于是基于jvm上面，所以反编译class文件很很容易。假如我们做了一个web程序，并把这个web程序发布给客户。实际上，客户是很容易反编译出我们的源代码出来，包括所有的src文件和jsp文件等等。
那么，如何保护我们的源代码，实际上，应该有几种方法可以使用：1、使用代码混淆器 2、重载应用服务器的classloader
对于第一种方法来说，现在外面有很多开源工具可以使用，个人认为最好用的当属proguard莫属。proguard主要是易用易学。而且提供的功能也挺多。下面是个人一点使用心得
（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--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，如上面的配置例子所示
对于第二种方法，重载服务器的classloader的原理是这样。 首先我们通过一定算法把class文件加密； 然后写我们自己的classloader，替换服务器的classloader。 这样，我们可以读取class文件，通过我们自己的算法反加密成正确的class，然后再次进行load。这个方式还没应用起来，这几天个人正在研究，有什么新成果会在此做一些总结。
ProGuard是一个开源的项目，主页：http://proguard.sourceforge.net/，目前最新的版本是3.3.2.。加载混淆器是非常简单的，只需要解压缩proguard3.3.2.zip，然后在 J2ME->Packing->Obfuscation 标签中选择 Proguard 的安装目录。如下图所示，在这里可以对需要在混淆过程中保留的类名进行配置，MIDlet 类的名称必须保留，以便设备的 Java 运行时环境（JRE）能够找到执行的入口点。
http://images.csdn.net/20050726/image027.jpg，It’s about the above pic.
另一篇文档
ProGuard是一款免费的Java类文件压缩器、优化器和混淆器。它能发现并删除无用类、字段（field）、方法和属性值（attribute）。它也能优化字节码并删除无用的指令。最后，它使用简单无意义的名字来重命名你的类名、字段名和方法名。经过以上操作的jar文件会变得更小，并很难进行逆向工程。这里提到了ProGuard的主要功能是压缩、优化和混淆，下面我就先介绍一下这些概念，然后再介绍ProGuard的基本使用方法。
l 什么是压缩：
Java源代码（.java文件）通常被编译为字节码（.class文件）。而完整的程序或程序库通常被压缩和发布成Java文档（.jar文件）。字节码比Java源文件更简洁，但是它仍然包含大量的无用代码，尤其它是一个程序库的时候。ProGuard的压缩程序操作能分析字节码，并删除无用的类、字段和方法。程序只保留功能上的等价，包括异常堆栈描述所需要的信息。
l 什么是混淆：
通常情况下，编译后的字节码仍然包含了大量的调试信息：源文件名，行号，字段名，方法名，参数名，变量名等等。这些信息使得它很容易被反编译和通过逆向工程获得完整的程序。有时，这是令人厌恶的。例如像ProGuard这样的混淆器就能删除这些调试信息，并用无意义的字符序列来替换所有名字，使得它很难进行逆向工程，它进一步免费的精简代码。除了异常堆栈信息所需要的类名，方法名和行号外，程序只会保留功能上的等价。通过以上的了解，你应该明白为什么需要混淆了。
l 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当成一个生成配置文件的向导来使用，这样我们只需要修改配置文件而不用重新写一个配置文件。
如果你觉得ProGuard还不错，那就快把它加入你的项目里吧。
第三文档
这是一个不应该在开源社区出现的东西，但它的的确确是一个开源的项目，正像它的名字一样，Proguard，即Program Guard（程序卫士），它代表了开源的相对面－－代码保护。
作为JAVA这样的高级语言，编译的产物只是相对源代码的一个概念而已，字节码虽然不像源代码那样易懂，但绝不是不可能进行反编译的，针对JAVA的反编译产品很多，如CAVAJ,JAD等等。面对反编译产品的不断出现，将代码视为财富的那些开发者，又何去何从。
混淆器正是在这种背景下应运而生，既然不可能完全地将拒绝反编译，那就让他们去反编译吧，只要反编译的结果别人不能直接使用不就行了吗？只要将代码搞混，让别人拿到了反编译的结果也看不懂，甚至不能编译。
混淆的方法有很多，主要是以下几方面。
更名，将私有类，私有的成员，方法体内部的变量名改名，改成a,b,c等等，甚至1,2,3(代码中不允许不等于成果物中不允许）
改变逻辑的流向，如将if条件取反，if/else对换
等价代码，如将循环改成GOTO
无效代码，插入不可及的无用代码
Proguard是一个非常优秀的开源的JAVA混淆器,可以在http://proguard.sourceforge.net/下载到，现在就让我一起来看一下Proguard.
以3.2版为例，释放压缩包，我们看到，作为开源项目就有docs，lib,src,sample文件夹，在此就不一一介绍了。
进入lib目录，内有proguard.jar，如果要自己有混淆器的外壳，或作ANT插件的话，会用到它，详细情况可以参考Proguard的文档。
我们要看的是proguardgui.jar，这是Proguard的图形界面，我们使用JDK打开，注意是JDK，不是JRE。
点选Input/Output标签，选择要混淆的JAR包（注意是JAR包），输出JAR包，以及用到的所有类库。
点选Obfuscation标签，选中不需要混淆的类（要被反射的类绝对不能被混淆）
点选Process标签，Process按钮，等着看结果吧。
Proguard中还包括了代码优化和代码整理的功能，不是本文讨论范围，有兴趣的就自己研究吧）
只混淆方面的选项
使用此种方式，如果a-z使用过，会转向aa.class,如下图配置界面
1,4,6,9,10,11,12
源代码
package org.zwm.pub;
public class Bru {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
System.out.println(showMsg());
}
public static String showMsg() {
return "You are my sun";
}
}
反编译后的代码
// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kps.com/jad.html
// Decompiler options: packimports(3)
package org.zwm.pub;
import java.io.PrintStream;
public class Bru
{
public Bru()
{
}
public static void main(String args[])
{
System.out.println(PK0304140008000800fZ());
}
public static String PK0304140008000800fZ()
{
return "You are my sun";
}
}
㈧ java混淆器是做什么的
用java写的代码 编译后成为.class文件 但是这个class文件可以被反编译查看到源代码
如果代码作者不希望源代码被别人看到 就利用混淆器把源代码混淆 但是程序功能还是正常的，编译后供别人使用，当别人反编译class文件想查看源代码时发现的是被混淆后的代码，虽然这些混淆后的代码也可以分析出来但是很困难
举个例子
class Person
{
private String name;
private int age;
public Person( String n, int a ){
name = n;
age = a;
}
}
混淆后
class OOOOo{
private String oooo;
private int ooo;
public OOOOo( String oo, int o){
oooo = oo;
ooo = o;
}
}
㈨ 关于java混淆器，问使用过的朋友： J2ee项目中如何进行java源代码的混淆
直接把class文件加密吧。在jvm装载的时候进行解密操作即可。刚刚做过类似的项目
㈩ 用java实现js混淆器
简单的思路就是把所有的回车空格换行等一应格式全部去掉
然后把所有变量名字全都替换成无任何意义的简单字母和符号
这样可以让大多数人看的很头大了