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混淆器
簡單的思路就是把所有的回車空格換行等一應格式全部去掉
然後把所有變數名字全都替換成無任何意義的簡單字母和符號
這樣可以讓大多數人看的很頭大了