最近看<<深入淺出Hibernate>>,作者在書中介紹了Hibernate 提供的用戶自定義數據類型，于是效仿書中的方法，在數據庫表中添加一個字段用于記錄所有好友的userid，每個userid之間用";"加以分隔，同時將該字段映射為一個特殊的List集合，利用UserType interface實現String解析后將各個userid封裝在List中，將List中的記錄封裝成以";"分隔的String。
使用UserType接口，實現了較好的設計風格，以及更好的重用性。
/*
* 用戶自定義的數據類型，對應數據庫中的一個字段，在該字段中，保存了
* 多個用戶需要的信息，之間用";"加以分隔.
* @Author:Paul
* @Date:April 18th,2008
*/
package com.globalhands.hibernate.userTypes;
import java.io.Serializable;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.sql.Types;
import org.hibernate.Hibernate;
import org.hibernate.HibernateException;
import org.hibernate.usertype.UserType;
public class SpecialList implements UserType {
private List specialList;
private static final char SPLITTER = ';';
private static final int[] TYPES = new int[] { Types.VARCHAR };
public String assemble(Serializable arg0, Object arg1)
throws HibernateException {
return null;
}
/*
* 將List封裝為一個String對象
*/
public String assemble(List specialList) throws HibernateException {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < specialList.size() - 1; i++) {
sb.append(specialList.get(i)).append(this.SPLITTER);
}
sb.append(specialList.get(specialList.size() - 1));
return sb.toString();
}
/*
* 創建一個新的List實例，包含原有的List實例中的所有元素.
*/
public Object deepCopy(Object value) throws HibernateException {
List sourceList = (List) value;
List targetList = new ArrayList();
targetList.addAll(sourceList);
return targetList;
}
public Serializable disassemble(Object arg0) throws HibernateException {
return null;
}
/*
* 判斷specialList是否發生變化
*/
public boolean equals(Object x, Object y) throws HibernateException {
if (x == y) {
return true;
}
if (x != null && y != null) {
List xList = (List) x;
List yList = (List) y;
if (xList.size() != yList.size()) {
return false;
}
for (int i = 0; i <= xList.size() - 1; i++) {
String str1 = (String) xList.get(i);
String str2 = (String) yList.get(i);
if (!xList.equals(yList)) {
return false;
}
}
return true;
}
return false;
}
public int hashCode(Object arg0) throws HibernateException {
return 0;
}
public boolean isMutable() {
return false;
}
/*
* 從resultset中取出email字段，并將其解析為List類型后返回
*/
public Object nullSafeGet(ResultSet rs, String[] names, Object owner)
throws HibernateException, SQLException {
String value = (String) Hibernate.STRING.nullSafeGet(rs, names[0]);
if (value != null) {
return parse(value);
} else {
return null;
}
}
/*
* 將以";"分隔的字符串解析為一個字符串數組
*/
private List parse(String value) {
String[] strs = value.split(";");
List specialList = new ArrayList();
for (int i = 0; i <= strs.length - 1; i++) {
specialList.add(strs[i]);
}
return specialList;
}
/*
* 將List型的email信息組裝成字符串之后保存到email字段
*/
public void nullSafeSet(PreparedStatement st, Object value, int index)
throws HibernateException, SQLException {
if (value != null) {
String str = assemble((List) value);
Hibernate.STRING.nullSafeSet(st, str, index);
} else {
Hibernate.STRING.nullSafeSet(st, value, index);
}
}
public Object replace(Object arg0, Object arg1, Object arg2)
throws HibernateException {
return null;
}
public Class returnedClass() {
return List.class;
}
public int[] sqlTypes() {
return TYPES;
}
}
同時，修改相應的[ormapping_filename].hbm.xml中相應字段的映射信息
<property name="buddy" type="com.globalhands.hibernate.userTypes.SpecialList">
<column name="buddy" length="2000" not-null="true" />
</property>
之后，修改POJO類中該字段的返回類型為List。
使用JUnit測試程序。
ASM 是一個 Java 字節碼操控框架。它能被用來動態生成類或者增強既有類的功能。ASM 可以直接產生二進制 class 文件，也可以在類被加載入 Java 虛擬機之前動態改變類行為。Java class 被存儲在嚴格格式定義的 .class 文件里，這些類文件擁有足夠的元數據來解析類中的所有元素：類名稱、方法、屬性以及 Java 字節碼（指令）。ASM 從類文件中讀入信息后，能夠改變類行為，分析類信息，甚至能夠根據用戶要求生成新類。
與 BCEL 和 SERL 不同，ASM 提供了更為現代的編程模型。對于 ASM 來說，Java class 被描述為一棵樹；使用 “Visitor” 模式遍歷整個二進制結構；事件驅動的處理方式使得用戶只需要關注于對其編程有意義的部分，而不必了解 Java 類文件格式的所有細節：ASM 框架提供了默認的 “response taker”處理這一切。
動態生成 Java 類與 AOP 密切相關的。AOP 的初衷在于軟件設計世界中存在這么一類代碼，零散而又耦合：零散是由于一些公有的功能（諸如著名的 log 例子）分散在所有模塊之中；同時改變 log 功能又會影響到所有的模塊。出現這樣的缺陷，很大程度上是由于傳統的 面向對象編程注重以繼承關系為代表的“縱向”關系，而對于擁有相同功能或者說方面 （Aspect）的模塊之間的“橫向”關系不能很好地表達。例如，目前有一個既有的銀行管理系統，包括 Bank、Customer、Account、Invoice 等對象，現在要加入一個安全檢查模塊， 對已有類的所有操作之前都必須進行一次安全檢查。
圖 1. ASM – AOP
然而 Bank、Customer、Account、Invoice 是代表不同的事務，派生自不同的父類，很難在高層上加入關于 Security Checker 的共有功能。對于沒有多繼承的 Java 來說，更是如此。傳統的解決方案是使用 Decorator 模式，它可以在一定程度上改善耦合，而功能仍舊是分散的 —— 每個需要 Security Checker 的類都必須要派生一個 Decorator，每個需要 Security Checker 的方法都要被包裝（wrap）。下面我們以 Account 類為例看一下 Decorator：
首先，我們有一個 SecurityChecker 類，其靜態方法 checkSecurity 執行安全檢查功能：
public class SecurityChecker { public static void checkSecurity() { System.out.println("SecurityChecker.checkSecurity ..."); //TODO real security check } }
|
另一個是 Account 類：
public class Account { public void operation() { System.out.println("operation..."); //TODO real operation } }
|
若想對 operation 加入對 SecurityCheck.checkSecurity() 調用，標準的 Decorator 需要先定義一個 Account 類的接口：
public interface Account { void operation(); }
|
然后把原來的 Account 類定義為一個實現類：
public class AccountImpl extends Account{ public void operation() { System.out.println("operation..."); //TODO real operation } }
|
定義一個 Account 類的 Decorator，并包裝 operation 方法：
public class AccountWithSecurityCheck implements Account { private Account account; public AccountWithSecurityCheck (Account account) { this.account = account; } public void operation() { SecurityChecker.checkSecurity(); account.operation(); } }
|
在這個簡單的例子里，改造一個類的一個方法還好，如果是變動整個模塊，Decorator 很快就會演化成另一個噩夢。動態改變 Java 類就是要解決 AOP 的問題，提供一種得到系統支持的可編程的方法，自動化地生成或者增強 Java 代碼。這種技術已經廣泛應用于最新的 Java 框架內，如 Hibernate，Spring 等。
最直接的改造 Java 類的方法莫過于直接改寫 class 文件。Java 規范詳細說明了class 文件的格式，直接編輯字節碼確實可以改變 Java 類的行為。直到今天，還有一些 Java 高手們使用最原始的工具，如 UltraEdit 這樣的編輯器對 class 文件動手術。是的，這是最直接的方法，但是要求使用者對 Java class 文件的格式了熟于心：小心地推算出想改造的函數相對文件首部的偏移量，同時重新計算 class 文件的校驗碼以通過 Java 虛擬機的安全機制。
Java 5 中提供的 Instrument 包也可以提供類似的功能：啟動時往 Java 虛擬機中掛上一個用戶定義的 hook 程序，可以在裝入特定類的時候改變特定類的字節碼，從而改變該類的行為。但是其缺點也是明顯的：
- Instrument 包是在整個虛擬機上掛了一個鉤子程序，每次裝入一個新類的時候，都必須執行一遍這段程序，即使這個類不需要改變。
- 直接改變字節碼事實上類似于直接改寫 class 文件，無論是調用
ClassFileTransformer. transform(ClassLoader loader, String className, Class classBeingRedefined, ProtectionDomain protectionDomain, byte[] classfileBuffer)，還是Instrument.redefineClasses(ClassDefinition[] definitions)，都必須提供新 Java 類的字節碼。也就是說，同直接改寫 class 文件一樣，使用 Instrument 也必須了解想改造的方法相對類首部的偏移量，才能在適當的位置上插入新的代碼。
盡管 Instrument 可以改造類，但事實上，Instrument 更適用于監控和控制虛擬機的行為。
一種比較理想且流行的方法是使用 java.lang.ref.proxy。我們仍舊使用上面的例子，給 Account 類加上 checkSecurity 功能:
首先，Proxy 編程是面向接口的。下面我們會看到，Proxy 并不負責實例化對象，和 Decorator 模式一樣，要把 Account 定義成一個接口，然后在 AccountImpl 里實現 Account 接口，接著實現一個 InvocationHandler Account 方法被調用的時候，虛擬機都會實際調用這個 InvocationHandler 的 invoke 方法：
class SecurityProxyInvocationHandler implements InvocationHandler { private Object proxyedObject; public SecurityProxyInvocationHandler(Object o) { proxyedObject = o; } public Object invoke(Object object, Method method, Object[] arguments) throws Throwable { if (object instanceof Account && method.getName().equals("opertaion")) { SecurityChecker.checkSecurity(); } return method.invoke(proxyedObject, arguments); } }
|
最后，在應用程序中指定 InvocationHandler 生成代理對象：
public static void main(String[] args) { Account account = (Account) Proxy.newProxyInstance( Account.class.getClassLoader(), new Class[] { Account.class }, new SecurityProxyInvocationHandler(new AccountImpl()) ); account.function(); }
|
其不足之處在于：
- Proxy 是面向接口的，所有使用 Proxy 的對象都必須定義一個接口，而且用這些對象的代碼也必須是對接口編程的：Proxy 生成的對象是接口一致的而不是對象一致的：例子中
Proxy.newProxyInstance生成的是實現Account接口的對象而不是AccountImpl的子類。這對于軟件架構設計，尤其對于既有軟件系統是有一定掣肘的。 - Proxy 畢竟是通過反射實現的，必須在效率上付出代價：有實驗數據表明，調用反射比一般的函數開銷至少要大 10 倍。而且，從程序實現上可以看出，對 proxy class 的所有方法調用都要通過使用反射的 invoke 方法。因此，對于性能關鍵的應用，使用 proxy class 是需要精心考慮的，以避免反射成為整個應用的瓶頸。
ASM 能夠通過改造既有類，直接生成需要的代碼。增強的代碼是硬編碼在新生成的類文件內部的，沒有反射帶來性能上的付出。同時，ASM 與 Proxy 編程不同，不需要為增強代碼而新定義一個接口，生成的代碼可以覆蓋原來的類，或者是原始類的子類。它是一個普通的 Java 類而不是 proxy 類，甚至可以在應用程序的類框架中擁有自己的位置，派生自己的子類。
相比于其他流行的 Java 字節碼操縱工具，ASM 更小更快。ASM 具有類似于 BCEL 或者 SERP 的功能，而只有 33k 大小，而后者分別有 350k 和 150k。同時，同樣類轉換的負載，如果 ASM 是 60% 的話，BCEL 需要 700%，而 SERP 需要 1100% 或者更多。
ASM 已經被廣泛應用于一系列 Java 項目：AspectWerkz、AspectJ、BEA WebLogic、IBM AUS、OracleBerkleyDB、Oracle TopLink、Terracotta、RIFE、EclipseME、Proactive、Speedo、Fractal、EasyBeans、BeanShell、Groovy、Jamaica、CGLIB、dynaop、Cobertura、JDBCPersistence、JiP、SonarJ、Substance L&F、Retrotranslator 等。Hibernate 和 Spring 也通過 cglib，另一個更高層一些的自動代碼生成工具使用了 ASM。
  |
|
所謂 Java 類文件，就是通常用 javac 編譯器產生的 .class 文件。這些文件具有嚴格定義的格式。為了更好的理解 ASM，首先對 Java 類文件格式作一點簡單的介紹。Java 源文件經過 javac 編譯器編譯之后，將會生成對應的二進制文件（如下圖所示）。每個合法的 Java 類文件都具備精確的定義，而正是這種精確的定義，才使得 Java 虛擬機得以正確讀取和解釋所有的 Java 類文件。
圖 2. ASM – Javac 流程
Java 類文件是 8 位字節的二進制流。數據項按順序存儲在 class 文件中，相鄰的項之間沒有間隔，這使得 class 文件變得緊湊，減少存儲空間。在 Java 類文件中包含了許多大小不同的項，由于每一項的結構都有嚴格規定，這使得 class 文件能夠從頭到尾被順利地解析。下面讓我們來看一下 Java 類文件的內部結構，以便對此有個大致的認識。
例如，一個最簡單的 Hello World 程序：
public class HelloWorld { public static void main(String[] args) { System.out.println("Hello world"); } }
|
經過 javac 編譯后，得到的類文件大致是：
圖 3. ASM – Java 類文件
從上圖中可以看到，一個 Java 類文件大致可以歸為 10 個項：
- Magic：該項存放了一個 Java 類文件的魔數（magic number）和版本信息。一個 Java 類文件的前 4 個字節被稱為它的魔數。每個正確的 Java 類文件都是以 0xCAFEBABE 開頭的，這樣保證了 Java 虛擬機能很輕松的分辨出 Java 文件和非 Java 文件。
- Version：該項存放了 Java 類文件的版本信息，它對于一個 Java 文件具有重要的意義。因為 Java 技術一直在發展，所以類文件的格式也處在不斷變化之中。類文件的版本信息讓虛擬機知道如何去讀取并處理該類文件。
- Constant Pool：該項存放了類中各種文字字符串、類名、方法名和接口名稱、final 變量以及對外部類的引用信息等常量。虛擬機必須為每一個被裝載的類維護一個常量池，常量池中存儲了相應類型所用到的所有類型、字段和方法的符號引用，因此它在 Java 的動態鏈接中起到了核心的作用。常量池的大小平均占到了整個類大小的 60% 左右。
- Access_flag：該項指明了該文件中定義的是類還是接口（一個 class 文件中只能有一個類或接口），同時還指名了類或接口的訪問標志，如 public，private, abstract 等信息。
- This Class：指向表示該類全限定名稱的字符串常量的指針。
- Super Class：指向表示父類全限定名稱的字符串常量的指針。
- Interfaces：一個指針數組，存放了該類或父類實現的所有接口名稱的字符串常量的指針。以上三項所指向的常量，特別是前兩項，在我們用 ASM 從已有類派生新類時一般需要修改：將類名稱改為子類名稱；將父類改為派生前的類名稱；如果有必要，增加新的實現接口。
- Fields：該項對類或接口中聲明的字段進行了細致的描述。需要注意的是，fields 列表中僅列出了本類或接口中的字段，并不包括從超類和父接口繼承而來的字段。
- Methods：該項對類或接口中聲明的方法進行了細致的描述。例如方法的名稱、參數和返回值類型等。需要注意的是，methods 列表里僅存放了本類或本接口中的方法，并不包括從超類和父接口繼承而來的方法。使用 ASM 進行 AOP 編程，通常是通過調整 Method 中的指令來實現的。
- Class attributes：該項存放了在該文件中類或接口所定義的屬性的基本信息。
事實上，使用 ASM 動態生成類，不需要像早年的 class hacker 一樣，熟知 class 文件的每一段，以及它們的功能、長度、偏移量以及編碼方式。ASM 會給我們照顧好這一切的，我們只要告訴 ASM 要改動什么就可以了 —— 當然，我們首先得知道要改什么：對類文件格式了解的越多，我們就能更好地使用 ASM 這個利器。
|
|
ASM 通過樹這種數據結構來表示復雜的字節碼結構，并利用 Push 模型來對樹進行遍歷，在遍歷過程中對字節碼進行修改。所謂的 Push 模型類似于簡單的 Visitor 設計模式，因為需要處理字節碼結構是固定的，所以不需要專門抽象出一種 Vistable 接口，而只需要提供 Visitor 接口。所謂 Visitor 模式和 Iterator 模式有點類似，它們都被用來遍歷一些復雜的數據結構。Visitor 相當于用戶派出的代表，深入到算法內部，由算法安排訪問行程。Visitor 代表可以更換，但對算法流程無法干涉，因此是被動的，這也是它和 Iterator 模式由用戶主動調遣算法方式的最大的區別。
在 ASM 中，提供了一個 ClassReader 類，這個類可以直接由字節數組或由 class 文件間接的獲得字節碼數據，它能正確的分析字節碼，構建出抽象的樹在內存中表示字節碼。它會調用 accept 方法，這個方法接受一個實現了 ClassVisitor 接口的對象實例作為參數，然后依次調用 ClassVisitor 接口的各個方法。字節碼空間上的偏移被轉換成 visit 事件時間上調用的先后，所謂 visit 事件是指對各種不同 visit 函數的調用，ClassReader 知道如何調用各種 visit 函數。在這個過程中用戶無法對操作進行干涉，所以遍歷的算法是確定的，用戶可以做的是提供不同的 Visitor 來對字節碼樹進行不同的修改。ClassVisitor 會產生一些子過程，比如 visitMethod 會返回一個實現 MethordVisitor 接口的實例，visitField 會返回一個實現 FieldVisitor 接口的實例，完成子過程后控制返回到父過程，繼續訪問下一節點。因此對于 ClassReader 來說，其內部順序訪問是有一定要求的。實際上用戶還可以不通過 ClassReader 類，自行手工控制這個流程，只要按照一定的順序，各個 visit 事件被先后正確的調用，最后就能生成可以被正確加載的字節碼。當然獲得更大靈活性的同時也加大了調整字節碼的復雜度。
各個 ClassVisitor 通過職責鏈 （Chain-of-responsibility） 模式，可以非常簡單的封裝對字節碼的各種修改，而無須關注字節碼的字節偏移，因為這些實現細節對于用戶都被隱藏了，用戶要做的只是覆寫相應的 visit 函數。
ClassAdaptor 類實現了 ClassVisitor 接口所定義的所有函數，當新建一個 ClassAdaptor 對象的時候，需要傳入一個實現了 ClassVisitor 接口的對象，作為職責鏈中的下一個訪問者 （Visitor），這些函數的默認實現就是簡單的把調用委派給這個對象，然后依次傳遞下去形成職責鏈。當用戶需要對字節碼進行調整時，只需從 ClassAdaptor 類派生出一個子類，覆寫需要修改的方法，完成相應功能后再把調用傳遞下去。這樣，用戶無需考慮字節偏移，就可以很方便的控制字節碼。
每個 ClassAdaptor 類的派生類可以僅封裝單一功能，比如刪除某函數、修改字段可見性等等，然后再加入到職責鏈中，這樣耦合更小，重用的概率也更大，但代價是產生很多小對象，而且職責鏈的層次太長的話也會加大系統調用的開銷，用戶需要在低耦合和高效率之間作出權衡。用戶可以通過控制職責鏈中 visit 事件的過程，對類文件進行如下操作：
-
刪除類的字段、方法、指令：只需在職責鏈傳遞過程中中斷委派，不訪問相應的 visit 方法即可，比如刪除方法時只需直接返回
null，而不是返回由visitMethod方法返回的MethodVisitor對象。class DelLoginClassAdapter extends ClassAdapter { public DelLoginClassAdapter(ClassVisitor cv) { super(cv); } public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) { if (name.equals("login")) { return null; } return cv.visitMethod(access, name, desc, signature, exceptions); } }
-
修改類、字段、方法的名字或修飾符：在職責鏈傳遞過程中替換調用參數。
class AccessClassAdapter extends ClassAdapter { public AccessClassAdapter(ClassVisitor cv) { super(cv); } public FieldVisitor visitField(final int access, final String name, final String desc, final String signature, final Object value) { int privateAccess = Opcodes.ACC_PRIVATE; return cv.visitField(privateAccess, name, desc, signature, value); } }
-
增加新的類、方法、字段
ASM 的最終的目的是生成可以被正常裝載的 class 文件，因此其框架結構為客戶提供了一個生成字節碼的工具類 —— ClassWriter。它實現了 ClassVisitor 接口，而且含有一個 toByteArray() 函數，返回生成的字節碼的字節流，將字節流寫回文件即可生產調整后的 class 文件。一般它都作為職責鏈的終點，把所有 visit 事件的先后調用（時間上的先后），最終轉換成字節碼的位置的調整（空間上的前后），如下例：
ClassWriter classWriter = new ClassWriter(ClassWriter.COMPUTE_MAXS); ClassAdaptor delLoginClassAdaptor = new DelLoginClassAdapter(classWriter); ClassAdaptor accessClassAdaptor = new AccessClassAdaptor(delLoginClassAdaptor); ClassReader classReader = new ClassReader(strFileName); classReader.accept(classAdapter, ClassReader.SKIP_DEBUG); |
綜上所述，ASM 的時序圖如下：
圖 4. ASM – 時序圖
|
|
我們還是用上面的例子，給 Account 類加上 security check 的功能。與 proxy 編程不同，ASM 不需要將 Account 聲明成接口，Account 可以仍舊是一個實現類。ASM 將直接在 Account 類上動手術，給 Account 類的 operation 方法首部加上對 SecurityChecker.checkSecurity 的調用。
首先，我們將從 ClassAdapter 繼承一個類。ClassAdapter 是 ASM 框架提供的一個默認類，負責溝通 ClassReader 和 ClassWriter。如果想要改變 ClassReader 處讀入的類，然后從 ClassWriter 處輸出，可以重寫相應的 ClassAdapter 函數。這里，為了改變 Account 類的 operation 方法，我們將重寫 visitMethdod 方法。
class AddSecurityCheckClassAdapter extends ClassAdapter{ public AddSecurityCheckClassAdapter(ClassVisitor cv) { //Responsechain 的下一個 ClassVisitor，這里我們將傳入 ClassWriter， //負責改寫后代碼的輸出 super(cv); } //重寫 visitMethod，訪問到 "operation" 方法時， //給出自定義 MethodVisitor，實際改寫方法內容 public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) { MethodVisitor mv = cv.visitMethod(access, name, desc, signature,exceptions); MethodVisitor wrappedMv = mv; if (mv != null) { //對于 "operation" 方法 if (name.equals("operation")) { //使用自定義 MethodVisitor，實際改寫方法內容 wrappedMv = new AddSecurityCheckMethodAdapter(mv); } } return wrappedMv; } }
|
下一步就是定義一個繼承自 MethodAdapter 的 AddSecurityCheckMethodAdapter，在“operation”方法首部插入對 SecurityChecker.checkSecurity() 的調用。
class AddSecurityCheckMethodAdapter extends MethodAdapter { public AddSecurityCheckMethodAdapter(MethodVisitor mv) { super(mv); } public void visitCode() { visitMethodInsn(Opcodes.INVOKESTATIC, "SecurityChecker", "checkSecurity", "()V"); } }
|
其中，ClassReader 讀到每個方法的首部時調用 visitCode()，在這個重寫方法里，我們用visitMethodInsn(Opcodes.INVOKESTATIC, "SecurityChecker","checkSecurity", "()V"); 插入了安全檢查功能。
最后，我們將集成上面定義的 ClassAdapter，ClassReader和ClassWriter 產生修改后的 Account 類文件:
import java.io.File; import java.io.FileOutputStream; import org.objectweb.asm.*; public class Generator{ public static void main() throws Exception { ClassReader cr = new ClassReader("Account"); ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); ClassAdapter classAdapter = new AddSecurityCheckClassAdapter(cw); cr.accept(classAdapter, ClassReader.SKIP_DEBUG); byte[] data = cw.toByteArray(); File file = new File("Account.class"); FileOutputStream fout = new FileOutputStream(file); fout.write(data); fout.close(); } }
|
執行完這段程序后，我們會得到一個新的 Account.class 文件，如果我們使用下面代碼：
public class Main { public static void main(String[] args) { Account account = new Account(); account.operation(); } }
|
使用這個 Account，我們會得到下面的輸出：
SecurityChecker.checkSecurity ... operation... |
也就是說，在 Account 原來的 operation 內容執行之前，進行了 SecurityChecker.checkSecurity() 檢查。
上面給出的例子是直接改造 Account 類本身的，從此 Account 類的 operation 方法必須進行 checkSecurity 檢查。但事實上，我們有時仍希望保留原來的 Account 類，因此把生成類定義為原始類的子類是更符合 AOP 原則的做法。下面介紹如何將改造后的類定義為 Account 的子類 Account$EnhancedByASM。其中主要有兩項工作:
- 改變 Class Description, 將其命名為
Account$EnhancedByASM，將其父類指定為Account。 - 改變構造函數，將其中對父類構造函數的調用轉換為對
Account構造函數的調用。
在 AddSecurityCheckClassAdapter 類中，將重寫 visit 方法：
public void visit(final int version, final int access, final String name, final String signature, final String superName, final String[] interfaces) { String enhancedName = name + "$EnhancedByASM"; //改變類命名 enhancedSuperName = name; //改變父類，這里是”Account” super.visit(version, access, enhancedName, signature, enhancedSuperName, interfaces); }
|
改進 visitMethod 方法，增加對構造函數的處理：
public MethodVisitor visitMethod(final int access, final String name, final String desc, final String signature, final String[] exceptions) { MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions); MethodVisitor wrappedMv = mv; if (mv != null) { if (name.equals("operation")) { wrappedMv = new AddSecurityCheckMethodAdapter(mv); } else if (name.equals("<init>")) { wrappedMv = new ChangeToChildConstructorMethodAdapter(mv, enhancedSuperName); } } return wrappedMv; }
|
這里 ChangeToChildConstructorMethodAdapter 將負責把 Account 的構造函數改造成其子類 Account$EnhancedByASM 的構造函數：
class ChangeToChildConstructorMethodAdapter extends MethodAdapter { private String superClassName; public ChangeToChildConstructorMethodAdapter(MethodVisitor mv, String superClassName) { super(mv); this.superClassName = superClassName; } public void visitMethodInsn(int opcode, String owner, String name, String desc) { //調用父類的構造函數時 if (opcode == Opcodes.INVOKESPECIAL && name.equals("<init>")) { owner = superClassName; } super.visitMethodInsn(opcode, owner, name, desc);//改寫父類為superClassName } }
|
最后演示一下如何在運行時產生并裝入產生的 Account$EnhancedByASM。 我們定義一個 Util 類，作為一個類工廠負責產生有安全檢查的 Account 類：
public class SecureAccountGenerator { private static AccountGeneratorClassLoader classLoader = new AccountGeneratorClassLoade(); private static Class secureAccountClass; public Account generateSecureAccount() throws ClassFormatError, InstantiationException, IllegalAccessException { if (null == secureAccountClass) { ClassReader cr = new ClassReader("Account"); ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); ClassAdapter classAdapter = new AddSecurityCheckClassAdapter(cw); cr.accept(classAdapter, ClassReader.SKIP_DEBUG); byte[] data = cw.toByteArray(); secureAccountClass = classLoader.defineClassFromClassFile( "Account$EnhancedByASM",data); } return (Account) secureAccountClass.newInstance(); } private static class AccountGeneratorClassLoader extends ClassLoader { public Class defineClassFromClassFile(String className, byte[] classFile) throws ClassFormatError { return defineClass("Account$EnhancedByASM", classFile, 0, classFile.length()); } } }
|
靜態方法 SecureAccountGenerator.generateSecureAccount() 在運行時動態生成一個加上了安全檢查的 Account 子類。著名的 Hibernate 和 Spring 框架，就是使用這種技術實現了 AOP 的“無損注入”。
|
|
最后，我們比較一下 ASM 和其他實現 AOP 的底層技術：
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE struts-config PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 1.1//EN"
"http://jakarta.apache.org/struts/dtds/struts-config.dtd">
<!-- struts-config.xml中的元素必須按照上述doc指令中的dtd文檔定義順序書寫，本例即遵從了dtd定義順序 -->
<!-- struts-config是整個xml的根元素，其他元素必須被包含其內 -->
<struts-config>
<!--
名稱:data-sources
描述：data-sources元素定義了web App所需要使用的數據源
數量：最多一個
子元素:data-source
-->
<data-sources>
<!--
名稱：data-source
描述：data-source元素定義了具體的數據源
數量：任意多個
屬性：
@key：當需要配置多個數據源時，相當于數據源的名稱，用來數據源彼此間進行區別
@type：可以使用的數據源實現的類，一般來自如下四個庫
Poolman，開放源代碼軟件
Expresso，Jcorporate
JDBC Pool，開放源代碼軟件
DBCP，Jakarta
-->
<data-source key="firstOne" type="org.apache.commons.dbcp.BasicDataSource">
<!--
名稱：set-property
描述：用來設定數據源的屬性
屬性：
@autoCommit:是否自動提交 可選值：true/false
@description:數據源描述
@driverClass:數據源使用的類
@maxCount:最大數據源連接數
@minCount:最小數據源連接數
@user:數據庫用戶
@password:數據庫密碼
@url:數據庫url
-->
<set-property property="autoCommit" value="true"/>
<set-property property="description" value="Hello!"/>
<set-property property="driverClass" value="com.mysql.jdbc.Driver"/>
<set-property property="maxCount" value="10"/>
<set-property property="minCount" value="2"/>
<set-property property="user" value="root"/>
<set-property property="password" value=""/>
<set-property property="url" value="jdbc:mysql://localhost:3306/helloAdmin"/>
</data-source>
</data-sources>
<!--
名稱：form-beans
描述：用來配置多個ActionForm Bean
數量：最多一個
子元素：form-bean
-->
<form-beans>
<!--
名稱：form-bean
描述：用來配置ActionForm Bean
數量：任意多個
子元素：form-property
屬性：
@className：指定與form-bean元素相對應的配置類，一般默認使用org.apaceh.struts.config.FormBeanConfig，如果自定義，則必須繼承 FormBeanConfig
@name：必備屬性！為當前form-bean制定一個全局唯一的標識符，使得在整個Struts框架內，可以通過該標識符來引用這個ActionForm Bean。
@type：必備屬性！指明實現當前ActionForm Bean的完整類名。
-->
<form-bean name="Hello" type="myPack.Hello">
<!--
名稱：form-property
描述：用來設定ActionForm Bean的屬性
數量：根據實際需求而定，例如，ActionForm Bean對應的一個登陸Form中有兩個文本框，name和password，ActionForm Bean中也有這兩個字段，則此處編寫兩個form-property來設定屬性
屬性：
@className：指定與form-property相對應的配置類，默認是org.apache.struts.config.FormPropertyConfig，如果自定義，則必須繼承FormPropertyConfig類
@name：所要設定的ActionForm Bean的屬性名稱
@type：所要設定的ActionForm Bean的屬性值的類
@initial：當前屬性的初值
-->
<form-property name="name" type="java.lang.String"/>
<form-property name="number" type="java.lang.Iteger" initial="18"/>
</form-bean>
</form-beans>
<!--
名稱：global-exceptions
描述：處理異常
數量：最多一個
子元素：exception
-->
<global-exceptions>
<!--
名稱：exception
描述：具體定義一個異常及其處理
數量：任意多個
屬性：
@className:指定對應exception的配置類，默認為org.apache.struts.config.ExceptionConfig
@handler:指定異常處理類，默認為org.apache.struts.action.ExceptionHandler
@key:指定在Resource Bundle種描述該異常的消息key
@path:指定當發生異常時，進行轉發的路徑
@scope:指定ActionMessage實例存放的范圍，默認為request，另外一個可選值是session
@type:必須要有！指定所需要處理異常類的名字。
@bundle:指定資源綁定
-->
<exception
key=""hello.error
path="/error.jsp"
scope="session"
type="hello.HandleError"/>
</global-exceptions>
<!--
名稱：global-forwards
描述：定義全局轉發
數量：最多一個
子元素：forward
-->
<global-forwards>
<!--
名稱：forward
描述：定義一個具體的轉發
數量：任意多個
屬性：
@className:指定和forward元素對應的配置類，默認為org.apache.struts.action.ActionForward
@contextRelative:如果為true，則指明使用當前上下文，路徑以“/”開頭，默認為false
@name:必須配有！指明轉發路徑的唯一標識符
@path:必須配有！指明轉發或者重定向的URI。必須以"/"開頭。具體配置要與contextRelative相應。
@redirect:為true時，執行重定向操作，否則執行請求轉發。默認為false
-->
<forward name="A" path="/a.jsp"/>
<forward name="B" path="/hello/b.do"/>
</global-forwards>
<!--
名稱：action-mappings
描述：定義action集合
數量：最多一個
子元素：action
-->
<action-mappings>
<!--
名稱：action
描述：定義了從特定的請求路徑到相應的Action類的映射
數量：任意多個
子元素：exception,forward（二者均為局部量）
屬性：
@attribute:制定與當前Action相關聯的ActionForm Bean在request和session范圍內的名稱（key）
@className:與Action元素對應的配置類。默認為org.apache.struts.action.ActionMapping
@forward:指名轉發的URL路徑
@include:指名包含的URL路徑
@input:指名包含輸入表單的URL路徑，表單驗證失敗時，請求會被轉發到該URL中
@name:指定和當前Acion關聯的ActionForm Bean的名字。該名稱必須在form-bean元素中定義過。
@path:指定訪問Action的路徑，以"/"開頭，沒有擴展名
@parameter:為當前的Action配置參數，可以在Action的execute()方法中，通過調用ActionMapping的getParameter()方法來獲取參數
@roles:指定允許調用該Aciton的安全角色。多個角色之間用逗號分割。處理請求時，RequestProcessor會根據該配置項來決定用戶是否有調用該Action的權限
@scope:指定ActionForm Bean的存在范圍，可選值為request和session。默認為session
@type:指定Action類的完整類名
@unknown:值為true時，表示可以處理用戶發出的所有無效的Action URL。默認為false
@validate:指定是否要先調用ActionForm Bean的validate()方法。默認為true
注意：如上屬性中，forward/include/type三者相斥，即三者在同一Action配置中只能存在一個。
-->
<action path="/search"
type="addressbook.actions.SearchAction"
name="searchForm"
scope="request"
validate="true"
input="/search.jsp">
<forward name="success" path="/display.jsp"/>
</action>
</action-mappings>
<!--
名稱：controller
描述：用于配置ActionServlet
數量：最多一個
屬性：
@bufferSize:指定上傳文件的輸入緩沖的大小.默認為4096
@className:指定當前控制器的配置類.默認為org.apache.struts.config.ControllerConfig
@contentType:指定相應結果的內容類型和字符編碼
@locale:指定是否把Locale對象保存到當前用戶的session中,默認為false
@processorClass:指定負責處理請求的Java類的完整類名.默認org.apache.struts.action.RequestProcessor
@tempDir:指定文件上傳時的臨時工作目錄.如果沒有設置,將才用Servlet容器為web應用分配的臨時工作目錄.
@nochache:true時,在相應結果中加入特定的頭參數:Pragma ,Cache-Control,Expires防止頁面被存儲在可數瀏覽器的緩存中,默認為false
-->
<controller
contentType="text/html;charset=UTF-8"
locale="true"
processorClass="CustomRequestProcessor">
</controller>
<!--
名稱:message-resources
描述:配置Resource Bundle.
數量:任意多個
屬性:
@className:指定和message-resources對應的配置類.默認為org.apache.struts.config.MessageResourcesConfig
@factory:指定資源的工廠類,默認為org.apache.struts.util.PropertyMessageResourcesFactory
@key:
@null:
@parameter:
-->
<message-resources
null="false"
parameter="defaultResource"/>
<message-resources
key="images"
null="false"
parameter="ImageResources"/>
<!--
名稱:plug-in
描述:用于配置Struts的插件
數量:任意多個
子元素:set-property
屬性:
@className:指定Struts插件類.此類必須實現org.apache.struts.action.PlugIn接口
-->
<plug-in
className="org.apache.struts.validator.ValidatorPlugIn">
<!--
名稱:set-property
描述:配置插件的屬性
數量:任意多個
屬性:
@property:插件的屬性名稱
@value:該名稱所配置的值
-->
<set-property
property="pathnames"
value="/WEB-INF/validator-rules.xml,/WEB-INF/vlaidation.xml"/>
</plug-in>
</struts-config>
2.利用修改過的請求信息調用資源。對請求的信息加以修改，然后繼續執行
3. 調用資源，但在發送響應到客戶機前對其進行修改
4. 阻止該資源調用，代之以轉到其他的資源，返回一個特定的狀態代碼或生成替換輸出。個人理解為請求被攔截時強制執行（跳轉）的操作
過濾器提供了幾個重要好處 ：
首先，它以一種模塊化的或可重用的方式封裝公共的行為。你有30個不同的serlvet或JSP頁面，需要壓縮它們的內容以減少下載時間嗎？沒問題：構造一個壓縮過濾器，然后將它應用到30個資源上即可。
其次，利用它能夠將高級訪問決策與表現代碼相分離。這對于JSP特別有價值，其中一般希望將幾乎整個頁面集中在表現上，而不是集中在業務邏輯上。例如，希 望阻塞來自某些站點的訪問而不用修改各頁面（這些頁面受到訪問限制）嗎？沒問題：建立一個訪問限制過濾器并把它應用到想要限制訪問的頁面上即可。
最后，過濾器使你能夠對許多不同的資源進行批量性的更改。你有許多現存資源，這些資源除了公司名要更改外其他的保持不變，能辦到么？沒問題：構造一個串替換過濾器，只要合適就使用它。
但要注意，過濾器只在與servlet規范2.3版兼容的服務器上有作用。如果你的Web應用需要支持舊版服務器，就不能使用過濾器。
1． 建立基本過濾器
建立一個過濾器涉及下列五個步驟：
1）建立一個實現Filter接口的類。這個類需要三個方法，分別是：doFilter、init和destroy。
doFilter方法包含主要的過濾代碼（見第2步），init方法建立設置操作，而destroy方法進行清楚。
2）在doFilter方法中放入過濾行為。doFilter方法的第一個參數為ServletRequest對象。此對象給過濾器提供了對進入的信息 （包括表單數據、cookie和HTTP請求頭）的完全訪問。第二個參數為ServletResponse，通常在簡單的過濾器中忽略此參數。最后一個參 數為FilterChain，如下一步所述，此參數用來調用servlet或JSP頁。
3）調用FilterChain對象的doFilter方法。Filter接口的doFilter方法取一個FilterChain對象作為它的一個參 數。在調用此對象的doFilter方法時，激活下一個相關的過濾器。如果沒有另一個過濾器與servlet或JSP頁面關聯，則servlet或JSP 頁面被激活。
4）對相應的servlet和JSP頁面注冊過濾器。在部署描述符文件（web.xml）中使用filter和filter-mapping元素。
5）禁用激活器servlet。防止用戶利用缺省servlet URL繞過過濾器設置。
1.1 建立一個實現Filter接口的類
所有過濾器都必須實現javax.servlet.Filter。這個接口包含三個方法，分別為doFilter、init和destroy。
public void doFilter(ServletRequset request,
ServletResponse response,
FilterChain chain)
thows ServletException, IOException
每當調用一個過濾器（即，每次請求與此過濾器相關的servlet或JSP頁面）時，就執行其doFilter方法。正是這個方法包含了大部分過濾邏輯。 第一個參數為與傳入請求有關的ServletRequest。對于簡單的過濾器，大多數過濾邏輯是基于這個對象的。如果處理HTTP請求，并且需要訪問諸 如getHeader或getCookies等在ServletRequest中無法得到的方法，就要把此對象構造成 HttpServletRequest。
第二個參數為ServletResponse。除了在兩個情形下要使用它以外，通常忽略這個參數。首先，如果希望完全阻塞對相關servlet或JSP頁 面的訪問?？烧{用response.getWriter并直接發送一個響應到客戶機。其次，如果希望修改相關的servlet或JSP頁面的輸出，可把響 應包含在一個收集所有發送到它的輸出的對象中。然后，在調用serlvet或JSP頁面后，過濾器可檢查輸出，如果合適就修改它，之后發送到客戶機。
DoFilter的最后一個參數為FilterChain對象。對此對象調用doFilter以激活與servlet或JSP頁面相關的下一個過濾器。如果沒有另一個相關的過濾器，則對doFilter的調用激活servlet或JSP本身。
public void init(FilterConfig config) thows ServletException
init方法只在此過濾器第一次初始化時執行，不是每次調用過濾器都執行它。對于簡單的過濾器，可提供此方法的一個空體，但有兩個原因需要使用init。 首先，FilterConfig對象提供對servlet環境及web.xml文件中指派的過濾器名的訪問。因此，普遍的辦法是利用init將 FilterConfig對象存放在一個字段中，以便doFilter方法能夠訪問servlet環境或過濾器名.其次，FilterConfig對象具 有一個getInitParameter方法，它能夠訪問部署描述符文件（web.xml）中分配的過濾器初始化參數。
public void destroy( )
大多數過濾器簡單地為此方法提供一個空體，不過，可利用它來完成諸如關閉過濾器使用的文件或數據庫連接池等清除任務。
1.2 將過濾行為放入doFilter方法
doFilter方法為大多數過濾器地關鍵部分。每當調用一個過濾器時，都要執行doFilter。對于大多數過濾器來說，doFilter執行的步驟是 基于傳入的信息的。因此，可能要利用作為doFilter的第一個參數提供的ServletRequest。這個對象常常構造為 HttpServletRequest類型，以提供對該類的更特殊方法的訪問。
1.3 調用FilterChain對象的doFilter方法
Filter接口的doFilter方法以一個FilterChain對象作為它的第三個參數。在調用該對象的doFilter方法時，激活下一個相關的 過濾器。這個過程一般持續到鏈中最后一個過濾器為止。在最后一個過濾器調用其FilterChain對象的doFilter方法時，激活servlet或 頁面自身。
但是，鏈中的任意過濾器都可以通過不調用其FilterChain的doFilter方法中斷這個過程。在這樣的情況下，不再調用JSP頁面的serlvet，并且中斷此調用過程的過濾器負責將輸出提供給客戶機。
1.4 對適當的servlet和JSP頁面注冊過濾器
部署描述符文件的2.3版本引入了兩個用于過濾器的元素，分別是：filter和filter-mapping。filter元素向系統注冊一個過濾對象，filter-mapping元素指定該過濾對象所應用的URL。
1.filter元素
filter元素位于部署描述符文件（web.xml）的前部，所有filter-mapping、servlet或servlet-mapping元素之前。filter元素具有如下六個可能的子元素：
1、 icon 這是一個可選的元素，它聲明IDE能夠使用的一個圖象文件。
2、filter-name 這是一個必需的元素，它給過濾器分配一個選定的名字。
3、display-name 這是一個可選的元素，它給出IDE使用的短名稱。
4、 description 這也是一個可選的元素，它給出IDE的信息，提供文本文檔。
5、 filter-class 這是一個必需的元素，它指定過濾器實現類的完全限定名。
6、 init-param 這是一個可選的元素，它定義可利用FilterConfig的getInitParameter方法讀取的初始化參數。單個過濾器元素可包含多個init-param元素。
請注意，過濾是在serlvet規范2.3版中初次引入的。因此，web.xml文件必須使用DTD的2.3版本。下面介紹一個簡單的例子：
<xml version="1.0" encoding="ISO-8859-1"?>
DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN" "
<web-app>
<filter>
<filter-name>MyFilterfilter-name>
<filter-class>myPackage.FilterClassfilter-class>
filter>
<filter-mapping>...filter-mapping>
<web-app>
2.filter-mapping元素
filter-mapping元素位于web.xml文件中filter元素之后serlvet元素之前。它包含如下三個可能的子元素：
1、 filter-name 這個必需的元素必須與用filter元素聲明時給予過濾器的名稱相匹配。
2、 url-pattern 此元素聲明一個以斜杠（/）開始的模式，它指定過濾器應用的URL。所有filter-mapping元素中必須提供url-pattern或 servlet-name。但不能對單個filter-mapping元素提供多個url-pattern元素項。如果希望過濾器適用于多個模式，可重復 整個filter-mapping元素。
3、 servlet-name 此元素給出一個名稱，此名稱必須與利用servlet元素給予servlet或JSP頁面的名稱相匹配。不能給單個filter-mapping元素提供 多個servlet-name元素項。如果希望過濾器適合于多個servlet名，可重復這個filter-mapping元素。
下面舉一個例子：
xml version="1.0" encoding="ISO-8859-1"?>
DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"
<web-app>
<filter>
<filter-name>MyFilterfilter-name>
<filter-class>myPackage.FilterClassfilter-class>
filter>
<filter-mapping>
<filter-name>MyFilterfilter-name>
<url-pattern>/someDirectory/SomePage.jspurl-pattern>
filter-mapping>
web-app>
1.5 禁用激活器servlet
在對資源應用過濾器時，可通過指定要應用過濾器的URL模式或servlet名來完成。如果提供servlet名，則此名稱必須與web.xml的 servlet元素中給出的名稱相匹配。如果使用應用到一個serlvet的URL模式，則此模式必須與利用web.xml的元素servlet- mapping指定的模式相匹配。但是，多數服務器使用“激活器servlet”為servlet體統一個缺省的URL：http: //host/WebAppPrefix/servlet/ServletName。需要保證用戶不利用這個URL訪問servlet（這樣會繞過過濾器 設置）。
例如，假如利用filter和filter-mapping指示名為SomeFilter的過濾器應用到名為SomeServlet的servlet，則如下：
<filter>
<filter-name>SomeFilterfilter-name>
<filter-class>somePackage.SomeFilterClassfilter-class>
<filter>
<filter-mapping>
<filter-name>SomeFilterfilter-name>
<servlet-name>SomeServletservlet-name>
<filter-mapping>
接著，用servlet和servlet-mapping規定URL http://host/webAppPrefix/Blah 應該調用SomeSerlvet，如下所示：
<filter>
<filter-name>SomeFilterfilter-name>
<filter-class>somePackage.SomeFilterClassfilter-class>
filter>
<filter-mapping>
<filter-name>SomeFilterfilter-name>
<servlet-name>/Blahservlet-name>
<filter-mapping>
現在，在客戶機使用URL http://host/webAppPrefix/Blah 時就會調用過濾器。過濾器不應用到
http://host/webAppPrefix/servlet/SomePackage.SomeServletClass。
盡管有關閉激活器的服務器專用方法。但是，可移植最強的方法時重新映射Web應用鐘的/servlet模式，這樣使所有包含此模式的請求被送到相同的 servlet中。為了重新映射此模式，首先應該建立一個簡單的servlet，它打印一條錯誤消息，或重定向用戶到頂層頁。然后，使用servlet和 servlet-mapping元素發送包含/servlet模式的請求到該servlet。程序清單9-1給出了一個簡短的例子。
程序清單9-1 web.xml（重定向缺省servlet URL的摘錄）
xml version="1.0" encoding="ISO-8859-1"?>
DOCTYPE web-app PUBLIC
"-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
"
<web-app>
<servlet>
<servlet-name>Errorservlet-name>
<servlet-class>somePackage.ErrorServletservlet-class>
servlet>
<servlet-mapping>
<servlet-name>Errorservlet-name>
<url-pattern>/servlet/*url-pattern>
servlet-mapping>
<web-app>
本文參考:http://www.javaeye.com/topic/140553
<html:javascript formName="searchSgbySjForm" dynamicJavascript="true" staticJavascript="false"/>
生成 :
var bCancel = false;
function validateSearchSgbySjForm(form)
{
if (bCancel) return true;
else return validateRequired(form) && validateDate(form);
}
function required ()
{
this.aa = new Array("sgfssjq", "事故發生時間起 不可為空.", new Function ("varName", "this.datePatternStrict='yyy-MM-dd'; return thisvarName];"));
this.ab = new Array("sgfssjz", "事故發生時間止 不可為空.", new Function ("varName", "this.datePatternStrict='yyy-MM-dd'; return this[varName];"));
}
function DateValidations ()
{
this.aa = new Array("sgfssjq", "事故發生時間起 不是有效的日期類型.", new Function ("varName", "this.datePatternStrict='yyy-MM-dd'; return this [varName];"));
this.ab = new Array("sgfssjz", "事故發生時間止 不是有效的日期類型.", new Function ("varName", "this.datePatternStrict='yyy-MM-dd'; return this[varName];"));
}
如果有多個的話required和DateValidations 都會重復的，而javascript是只認最后一個函數的。所以，會導致驗證出錯。
再寫一個標簽 ，主要根據原來的代碼修改，代碼如下:
package com.tmri.acd.tag;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import javax.servlet.jsp.JspException;
import javax.servlet.jsp.JspWriter;
import javax.servlet.jsp.PageContext;
import javax.servlet.jsp.tagext.BodyTagSupport;
import org.apache.commons.validator.Field;
import org.apache.commons.validator.Form;
import org.apache.commons.validator.ValidatorAction;
import org.apache.commons.validator.ValidatorResources;
import org.apache.commons.validator.util.ValidatorUtils;
import org.apache.commons.validator.Var;
import org.apache.struts.Globals;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.config.ModuleConfig;
import com.tmri.acd.tag.TagUtils;
import org.apache.struts.util.MessageResources;
import org.apache.struts.validator.Resources;
import org.apache.struts.validator.ValidatorPlugIn;
import java.util.StringTokenizer;
public class JavascriptValidatorTag extends BodyTagSupport
{
private static final Comparator actionComparator = new Comparator()
{
public int compare(Object o1, Object o2)
{
ValidatorAction va1 = (ValidatorAction) o1;
ValidatorAction va2 = (ValidatorAction) o2;
if ((va1.getDepends() == null || va1.getDepends().length() == 0) && (va2.getDepends() == null || va2.getDepends().length() == 0))
{
return 0;
}
else if ( (va1.getDepends() != null && va1.getDepends().length() > 0) && (va2.getDepends() == null || va2.getDepends().length() == 0))
{
return 1;
}
}
在客戶端顯示一個注釋.
JSP 語法
<!-- comment [ <%= expression %> ] -->
例子 1
<!-- This file displays the user login screen -->
在客戶端的HTML源代碼中產生和上面一樣的數據：
<!-- This file displays the user login screen -->
例子 2
<!-- This page was loaded on <%= (new java.util.Date()).toLocaleString() %> -->
在客戶端的HTML源代碼中顯示為:
<!-- This page was loaded on January 1, 2000 -->
描述
這種注釋和HTML中很像，也就是它可以在"查看源代碼"中看到.
唯一有些不同的就是，你可以在這個注釋中用表達式（例子2所示).這個表達示是不定的，由頁面不同而不同，你能夠使用各種表達式，只要是合法的就行。更多的請看表達式
隱藏注釋
寫在JSP程序中，但不是發給客戶。
JSP 語法
<%-- comment --%>
例子：
<%@ page language="java" %> <html> <head><title>A Comment Test</title></head> <body> <h2>A Test of Comments</h2> <%-- This comment will not be visible in the page source --%> </body> </html>
描述
用隱藏注釋標記的字符會在JSP編譯時被忽略掉。這個注釋在你希望隱藏或注釋你的JSP程序時是很有用的。JSP編譯器不是會對<%--and--%>之間的語句進行編譯的，它不會顯示在客戶的瀏覽器中，也不會在源代碼中看到
聲明
在JSP程序中聲明合法的變量和方法
JSP 語法
<%! declaration; [ declaration; ]+ ... %>
例子
<%! int i = 0; %>
<%! int a, b, c; %>
<%! Circle a = new Circle(2.0); %>
描述
聲明你將要在JSP程序中用到的變量和方法。你也必須這樣做，不然會出錯.
你可以一次性聲明多個變量和方法，只要以";"結尾就行，當然這些聲明在Java中要是合法的。
當你聲明方法或變量時，請注意以下的一些規則:
聲明必須以";"結尾(Scriptlet有同樣的規則，但是 表達式就不同了).
你可以直接使用在<% @ page %>中被包含進來的已經聲明的變量和方法，不需要對它們重新進行聲明.
一個聲明僅在一個頁面中有效。如果你想每個頁面都用到一些聲明，最好把它們寫成一個單獨的文件，然后用<%@ include %>或<jsp:include >元素包含進來。
表達式
包含一個符合JSP語法的表達式
JSP 語法
<%= expression %>
例子
<font color="blue"><%= map.size() %></font>
<b><%= numguess.getHint() %></b>.
描述
表達式元素表示的是一個在腳本語言中被定義的表達式，在運行后被自動轉化為字符串，然后插入到這個表達示在JSP文件的位置顯示。因為這個表達式的值已經被轉化為字符串，所以你能在一行文本中插入這個表達式（形式和ASP完全一樣).
當你在JSP中使用表達式時請記住以下幾點：
你不能用一個分號（"；"）來作為表達式的結束符.但是同樣的表達式用在scriptlet中就需要以分號來結尾了！查看Scriptlet
這個表達式元素能夠包括任何在Java Language Specification中有效的表達式.
有時候表達式也能做為其它JSP元素的屬性值.一個表達式能夠變得很復雜，它可能由一個或多個表達式組成，這些表達式的順序是從左到右。
[/b]Scriptlet [/b]
包含一個有效的程序段.
JSP 語法
<% code fragment %>
例子
<%
String name = null;
if (request.getParameter("name") == null) {
%>
<%@ include file="error.html" %>
<%
} else {
foo.setName(request.getParameter("name"));
if (foo.getName().equalsIgnoreCase("integra"))
name = "acura";
if (name.equalsIgnoreCase( "acura" )) {
%>
描述
一個scriptlet能夠包含多個jsp語句，方法，變量，表達式
因為scriptlet,我們便能做以下的事:
聲明將要用到的變量或方法（參考 聲明).
編寫JSP表達式（參考 表達式).
使用任何隱含的對象和任何用<jsp:useBean>聲明過的對象
編寫JSP語句 (如果你在使用Java語言，這些語句必須遵從Java Language Specification,).
任何文本，HTML標記，JSP元素必須在scriptlet之外
當JSP收到客戶的請求時，scriptlet就會被執行，如果scriptlet有顯示的內容，這些顯示的內容就被存在out對象中。
Include 指令
在JSP中包含一個靜態的文件，同時解析這個文件中的JSP語句.
JSP 語法
<%@ include file="relativeURL" %>
例子
include.jsp:
<html> <head><title>An Include Test</title></head> <body bgcolor="white"> <font color="blue"> The current date and time are <%@ include file="date.jsp" %> </font> </body> </html>
date.jsp:
<%@ page import="java.util.*" %> <%= (new java.util.Date() ).toLocaleString() %>
Displays in the page:
The current date and time are
Aug 30, 1999 2:38:40
描述
<%@include %>指令將會在JSP編譯時插入一個包含文本或代碼的文件，當你使用<%@ include %>指命時，這個包含的過程就當是靜態的。靜態的包含就是指這個被包含的文件將會被插入到JSP文件中去，這個包含的文件可以是JSP文件，HTML文件，文本文件。如果包含的是JSP文件，這個包含的JSP的文件中代碼將會被執行。
如果你僅僅只是用include 來包含一個靜態文件。那么這個包含的文件所執行的結果將會插入到JSP文件中放<% @ include %>的地方。一旦包含文件被執行，那么主JSP文件的過程將會被恢復，繼續執行下一行.
這個被包含文件可以是html文件，jsp文件，文本文件，或者只是一段Java代碼，但是你得注意在這個包含文件中不能使用<html>,</html>,<body>,</body>標記，因為這將會影響在原JSP文件中同樣的標記 ，這樣做有時會導致錯誤.
有一些<%@ include %>指命的行為是以特殊的JSP編譯條件為基礎，比如：
這個被包含的文件必須對所有客戶都有開放且必須f有效，或者它有安全限制
如果這個包含文件被改變，包含此文件的JSP文件將被重新編譯
屬性:
file="relativeURL"
這個包含文件的路徑名一般來說是指相對路徑，不需要什么端口，協議，和域名，如下:
"error.jsp""templates/onlinestore.html""/beans/calendar.jsp"
如果這個路徑以"/"開頭，那么這個路徑主要是參照JSP應用的上下關系路徑，如果路徑是以文件名或目錄名開頭，那么這個路徑就是正在使用的JSP文件的當前路徑.
Page 指令
定義JSP文件中的全局屬性.
JSP 語法
<%@ page
[ language="java" ]
[ extends="package.class" ]
[ import="{package.class | package.*}, ..." ]
[ session="true | false" ]
[ buffer="none | 8kb | sizekb" ]
[ autoFlush="true | false" ]
[ isThreadSafe="true | false" ]
[ info="text" ]
[ errorPage="relativeURL" ]
[ contentType="mimeType [ ;charset=characterSet ]" | "text/html ; charset=ISO-8859-1" ]
[ isErrorPage="true | false" ]
%>
例子
<%@ page import="java.util.*, java.lang.*" %>
<%@ page buffer="5kb" autoFlush="false" %>
<%@ page errorPage="error.jsp" %>
描述
<%@ page %>指令作用于整個JSP頁面，同樣包括靜態的包含文件。但是<% @ page %>指令不能作用于動態的包含文件，比如 <jsp:include>
你可以在一個頁面中用上多個<% @ page %>指令，但是其中的屬性只能用一次，不過也有個例外，那就是import屬性。因為import屬性和Java中的import語句差不多(參照Java Language)，所以你就能多用此屬性幾次了.
無論你把<% @ page %>指令放在JSP的文件的哪個地方，它的作用范圍都是整個JSP頁面。不過，為了JSP程序的可讀性，以及好的編程習慣，最好還是把它放在JSP文件的頂部.
屬性
language="java"
聲明腳本語言的種類，暫時只能用"java"
extends="package.class"
標明JSP編譯時需要加入的Java Class的全名，但是得慎重的使用它，它會限制JSP的編譯能力.
import="{package.class | package.* }, ..."
需要導入的Java包的列表，這些包就作用于程序段，表達式，以及聲明。
下面的包在JSP編譯時已經導入了，所以你就不需要再指明了:
java.lang.*
javax.servlet.*
javax.servlet.jsp.*
javax.servlet.http.*
session="true | false"
設定客戶是否需要HTTP Session.（學過ASP的人，應該對它不陌生)如果它為true,那么Session是有用的。
如果它有false,那么你就不能使用session對象，以及定義了scope=session的<jsp:useBean>元素。這樣的使用會導致錯誤.
缺省值是true.
buffer="none | 8kb | sizekb"
buffer的大小被out對象用于處理執行后的JSP對客戶瀏覽器的輸出。缺省值是8kb
autoFlush="true | false"
設置如果buffer溢出，是否需要強制輸出，如果其值被定義為true(缺省值)，輸出正常，如果它被設置為false,如果這個buffer溢出，就會導致一個意外錯誤的發生.如果你把buffer設置為none,那么你就不能把autoFlush設置為false.
isThreadSafe="true | false"
設置Jsp文件是否能多線程使用。缺省值是true,也就是說，JSP能夠同時處理多個用戶的請求，如果設置為false，一個jsp只能一次處理一個請求
info="text"
一個文本在執行JSP將會被逐字加入JSP中，你能夠使用Servlet.getServletInfo方法取回。
errorPage="relativeURL"
設置處理異常事件的JSP文件。
isErrorPage="true | false"
設置此頁是否為出錯頁，如果被設置為true,你就能使用exception對象.
contentType="mimeType [ ;charset=characterSet ]" | "text/html;charset=ISO-8859-1"
設置MIME類型 。缺省MIME 類型是: text/html, 缺省字符集為 ISO-8859-1.
<jsp:forward>
重定向一個HTML文件，JSP文件，或者是一個程序段.
JSP 語法
<jsp:forward page={"relativeURL" | "<%= expression %>"} />
or
<jsp:forward page={"relativeURL" | "<%= expression %>"} >
<jsp:param name="parameterName"
value="{parameterValue | <%= expression %>}" />+
</jsp:forward>
例子
<jsp:forward page="/servlet/login" />
<jsp:forward page="/servlet/login">
<jsp:param name="username" value="jsmith" />
</jsp:forward>
描述
<jsp:forward>標簽從一個JSP文件向另一個文件傳遞一個包含用戶請求的request對象.<jsp:forward>標簽以下的代碼，將不能執行.
你能夠向目標文件傳送參數和值，在這個例子中我們傳遞的參數名為username,值為scott,如果你使用了<jsp:param>標簽的話，目標文件必須是一個動態的文件，能夠處理參數.
如果你使用了非緩沖輸出的話，那么使用<jsp:forward>時就要小心。如果在你使用<jsp:forward>之前，jsp文件已經有了數據，那么文件執行就會出錯.
屬性
page="{relativeURL | <%= expression %>}"
這里是一個表達式或是一個字符串用于說明你將要定向的文件或URL.這個文件可以是JSP,程序段，或者其它能夠處理request對象的文件(如asp,cgi,php).
<jsp:param name="parameterName" value="{parameterValue | <%= expression %>}" />+
向一個動態文件發送一個或多個參數，這個文件一定是動態文件.
如果你想傳遞多個參數，你可以在一個JSP文件中使用多個<jsp:param>。name指定參數名，value指定參數值.
<jsp:getProperty>
獲取Bean的屬性值，用于顯示在頁面中
JSP 語法
<jsp:getProperty name="beanInstanceName" property="propertyName" />
例子
<jsp:useBean id="calendar" scope="page" class="employee.Calendar" />
<h2>
Calendar of <jsp:getProperty name="calendar" property="username" />
</h2>
描述
這個<jsp:getProperty>元素將獲得Bean的屬性值，并可以將其使用或顯示在JSP頁面中.在你使用<jsp:getProperty>之前，你必須用<jsp:useBean>創建它.
<jsp:getProperty>元素有一些限制:
你不能使用<jsp:getProperty>來檢索一個已經被索引了的屬性
你能夠和JavaBeans組件一起使用<jsp:getProperty>,但是不能與Enterprise Bean一起使用。
屬性
name="beanInstanceName"
bean的名字,由<jsp:useBean>指定
property="propertyName"
所指定的Bean的屬性名。
技巧:
在sun的JSP參考中提到，如果你使用<jsp:getProperty>來檢索的值是空值，那么NullPointerException將會出現，同時如果使用程序段或表達式來檢索其值，那么在瀏覽器上出現的是null（空).
<jsp:include>
包含一個靜態或動態文件.
JSP 語法
<jsp:include page="{relativeURL | <%= expression%>}" flush="true" />
or
<jsp:include page="{relativeURL | <%= expression %>}" flush="true" >
<jsp:param name="parameterName" value="{parameterValue | <%= expression %>}" />+
</jsp:include>
Examples
<jsp:include page="scripts/login.jsp" />
<jsp:include page="copyright.html" />
<jsp:include page="/index.html" />
<jsp:include page="scripts/login.jsp">
<jsp:param name="username" value="jsmith" />
</jsp:include>
描述
<jsp:include>元素允許你包含動態文件和靜態，這兩種包含文件的結果是不同的。如果文件僅是靜態文件，那么這種包含僅僅是把包含文件的內容加到jsp文件中去，而如果這個文件動態的，那么這個被包含文件也會被Jsp編譯器執行(這一切與asp相似)
你不能從文件名上判斷一個文件是動態的還是靜態的，比如aspcn.asp 就有可能只是包含一些信息而已，而不需要執行。<jsp:include>能夠同時處理這兩種文件，因此你就不需要包含時還要判斷此文件是動態的還是靜態的.
如果這個包含文件是動態的，那么你還可以用<jsp:param>還傳遞參數名和參數值。
屬性
page="{relativeURL | <%= expression %>}"
參數為一相對路徑，或者是代表相對路徑的表達式.
flush="true"
這里你必須使用flush="true",你不能使用false值.缺省值為false
<jsp:param name="parameterName" value="{parameterValue | <%= expression %> }" />+
<jsp:param>子句能讓你傳遞一個或多個參數給動態文件
你能在一個頁面中使用多個<jsp:param>來傳遞多個參數，
<jsp:plugin>
執行一個applet或Bean,有可能的話還要下載一個Java插件用于執行它.
JSP 語法
<jsp:plugin
type="bean | applet"
code="classFileName"
codebase="classFileDirectoryName"
[ name="instanceName" ]
[ archive="URIToArchive, ..." ]
[ align="bottom | top | middle | left | right" ]
[ height="displayPixels" ]
[ width="displayPixels" ]
[ hspace="leftRightPixels" ]
[ vspace="topBottomPixels" ]
[ jreversion="JREVersionNumber | 1.1" ]
[ nspluginurl="URLToPlugin" ]
[ iepluginurl="URLToPlugin" ] >
[ <jsp:params>
[ <jsp:param name="parameterName" value="{parameterValue | <%= expression %>}" /> ]+
</jsp:params> ]
[ <jsp:fallback> text message for user </jsp:fallback> ]
</jsp:plugin>
例子
<jsp:plugin type=applet code="Molecule.class" codebase="/html">
<jsp:params>
<jsp:param name="molecule" value="molecules/benzene.mol" />
</jsp:params>
<jsp:fallback>
<p>Unable to load applet</p>
</jsp:fallback>
</jsp:plugin>
描述
<jsp:plugin>元素用于在瀏覽器中播放或顯示一個對象（典型的就是applet和Bean),而這種顯示需要在瀏覽器的java插件。
當Jsp文件被編譯，送往瀏覽器時，<jsp:plugin>元素將會根據瀏覽器的版本替換成<object>或者<embed>元素。注意，<object>用于HTML 4.0 ，<embed>用于HTML 3.2.
一般來說，<jsp:plugin>元素會指定對象是Applet還是Bean,同樣也會指定class的名字，還有位置，另外還會指定將從哪里下載這個Java插件。具體如下:
屬性
type="bean | applet"
.將被執行的插件對象的類型，你必須得指定這個是Bean還是applet,因為這個屬性沒有缺省值.
code="classFileName"
將會被Java插件執行的Java Class的名字，必須以.class結尾。這個文件必須存在于codebase屬性指定的目錄中.
codebase="classFileDirectoryName"
將會被執行的Java Class文件的目錄（或者是路徑)，如果你沒有提供此屬性，那么使用<jsp:plugin>的jsp文件的目錄將會被使用.
name="instanceName"
這個Bean或applet實例的名字，它將會在Jsp其它的地方調用.
archive="URIToArchive, ..."
一些由逗號分開的路徑名，這些路徑名用于預裝一些將要使用的class,這會提高applet的性能.
align="bottom | top | middle | left | right"
圖形，對象，Applet的位置,有以下值:
bottom
top
middle
left
right
height="displayPixels" width="displayPixels"
Applet或Bean將要顯示的長寬的值，此值為數字，單位為象素.
hspace="leftRightPixels" vspace="topBottomPixels"
Applet或Bean顯示時在屏幕左右，上下所需留下的空間，單位為象素.
jreversion="JREVersionNumber | 1.1"
Applet或Bean運行所需的Java Runtime Environment (JRE) 的版本. 缺省值是 1.1.
nspluginurl="URLToPlugin"
Netscape Navigator用戶能夠使用的JRE的下載地址，此值為一個標準的URL，如http://www.aspcn.com/jsp
iepluginurl="URLToPlugin"
IE用戶能夠使用的JRE的下載地址，此值為一個標準的URL，如http://www.aspcn.com/jsp
<jsp:params> [ <jsp:param name="parameterName" value="{parameterValue | <%= expression %>}" /> ]+ </jsp:params>
你需要向applet或Bean傳送的參數或參數值。
<jsp:fallback> text message for user </jsp:fallback>
一段文字用于Java 插件不能啟動時顯示給用戶的，如果插件能夠啟動而applet或Bean不能，那么瀏覽器會有一個出錯信息彈出.
<jsp:setProperty>
設置Bean中的屬性值.
JSP語法
<jsp:setProperty
name="beanInstanceName"
{
property= "*" |
property="propertyName" [ param="parameterName" ] |
property="propertyName" value="{string | <%= expression %>}"
}
/>
例子
<jsp:setProperty name="mybean" property="*" />
<jsp:setProperty name="mybean" property="username" />
<jsp:setProperty name="mybean" property="username" value="Steve" />
描述
<jsp:setProperty>元素使用Bean給定的setter方法，在Bean中設置一個或多個屬性值。你在使用這個元素之前必須得使用<jsp:useBean>聲明此Bean.因為，<jsp:useBean>和<jsp:setProperty>是聯系在一起的，同時這他們使用的Bean實例的名字也應當相匹配（就是說，在<jsp:setProperty>中的name的值應當和<jsp:useBean>中id的值相同)
你能使用多種方法利用<jsp:setProperty>來設定屬性值 :
通過用戶輸入的所有值(被做為參數儲存中request對象中)來匹配Bean中的屬性
通過用戶輸入的指定的值來匹配Bean中指定的屬性
在運行時使用一個表達式來匹配Bean的屬性
每一種設定屬性值的方法都有其特定的語法，下面我們會來講解
屬性及其用法
name="beanInstanceName"
表示已經在<jsp:useBean>中創建的Bean實例的名字.
property="*"
儲存用戶在Jsp輸入的所有值，用于匹配Bean中的屬性。在Bean中的屬性的名字必須和request對象中的參數名一致.
從客戶傳到服器上的參數值一般都是字符類型 ，這些字符串為了能夠在Bean中匹配就必須轉換成其它的類型，下面的表中列出了Bean屬性的類型以及他們的轉換方法.
把字符串轉化為其它類型的方法. Property 類型
方法
boolean or Boolean
java.lang.Boolean.valueOf(String)
byte or Byte
java.lang.Byte.valueOf(String)
char or Character
java.lang.Character.valueOf(String)
double or Double
java.lang.Double.valueOf(String)
integer or Integer
java.lang.Integer.valueOf(String)
float or Float
java.lang.Float.valueOf(String)
long or Long
java.lang.Long.valueOf(String)
如果request對象的參數值中有空值，那么對應的Bean屬性將不會設定任何值。同樣的，如果Bean中有一個屬性沒有與之對應的Request參數值，那么這個屬性同樣也不會設定.
property="propertyName" [ param="parameterName" ]
使用request中的一個參數值來指定Bean中的一個屬性值。在這個語法中，property指定Bean的屬性名，param指定request中的參數名.
如果bean屬性和request參數的名字不同，那么你就必須得指定property和param ，如果他們同名，那么你就只需要指明property就行了.
如查參數值為空（或未初始化),對應的Bean屬性不被設定.
property="propertyName" value="{string | <%= expression %>}"
使用指定的值來設定Bean屬性。這個值可以是字符串，也可以是表達式。如果這個字符串，那么它就會被轉換成Bean屬性的類型（查看上面的表).如果它是一個表達式，那么它類型就必須和它將要設定的屬性值的類型一致。
如果參數值為空，那么對應的屬性值也不會被設定。另外，你不能在一個<jsp:setProperty>中同時使用param和value
技巧
如果你使用了property="*",那么Bean的屬性沒有必要按Html表單中的順序排序
<jsp:useBean>
創建一個Bean實例并指定它的名字和作用范圍.
JSP 語法
<jsp:useBean
id="beanInstanceName"
scope="page | request | session | application"
{
class="package.class" |
type="package.class" |
class="package.class" type="package.class" |
beanName="{package.class | <%= expression %>}" type="package.class"
}
{
/> |
> other elements </jsp:useBean>
}
例子
<jsp:useBean id="cart" scope="session" class="session.Carts" />
<jsp:setProperty name="cart" property="*" />
<jsp:useBean id="checking" scope="session" class="bank.Checking" >
<jsp:setProperty name="checking" property="balance" value="0.0" />
</jsp:useBean>
描述
<jsp:useBean>用于定位或示例一個JavaBeans組件。<jsp:useBean>首先會試圖定位一個Bean實例，如果這個Bean不存在，那么<jsp:useBean>就會從一個class或模版中進行示例。
為了定位或示例一個Bean，<jsp:useBean>會進行以下步聚，順序如下:
通過給定名字和范圍試圖定位一個Bean.
對這個Bean對象引用變量以你指定的名字命名.
如果發現了這個Bean,將會在這個變量中儲存這個引用。如果你也指定了類型，那么這個Bean也設置為相應的類型.
如果沒有發現這個Bean,將會從你指定的class中示例，并將此引用儲存到一個新的變量中去。如果這個class的名字代表的是一個模版，那么這個Bean被java.beans.Beans.instantiate示例.
如果<jsp:useBean>已經示例（不是定位）了Bean,同時<jsp:useBean>和</jsp:useBean>中有元素，那么將會執行其中的代碼.
<jsp:useBean>元素的主體通常包含有<jsp:setProperty>元素，用于設置Bean的屬性值。正如上面第五步所說的，<jsp:useBean>的主體僅僅只有在<jsp:useBean>示例Bean時才會被執行，如果這個Bean已經存在，<jsp:useBean>能夠定位它，那么主體中的內容將不會起作用
屬性以及用法
id="beanInstanceName"
在你所定義的范圍中確認Bean的變量，你能在后面的程序中使用此變量名來分辨不同的Bean
這個變量名對大小寫敏感，必須符合你所使用的腳本語言的規定，在Java Programming Language中，這個規定在Java Language 規范已經寫明。如果這個Bean已經在別的<jsp:useBean>中創建，那么這個id的值必須與原來的那個id值一致.
scope="page | request | session | application"
Bean存在的范圍以及id變量名的有效范圍。缺省值是page,以下是詳細說明：
page - 你能在包含<jsp:useBean>元素的JSP文件以及此文件中的所有靜態包含文件中使用Bean,直到頁面執行完畢向客戶端發回響應或轉到另一個文件為止。
request - 你在任何執行相同請求的Jsp文件中使用Bean,直到頁面執行完畢向客戶端發回響應或轉到另一個文件為止。你能夠使用Request對象訪問Bean,比如request.getAttribute(beanInstanceName)
session - 從創建Bean開始，你就能在任何使用相同session的Jsp文件中使用Bean.這個Bean存在于整個Session生存周期內，任何在分享此Session的Jsp文件都能使用同一Bean.注意在你創建Bean的Jsp文件中<% @ page %>指令中必須指定session=true
application - 從創建Bean開始，你就能在任何使用相同application的Jsp文件中使用Bean.這個Bean存在于整個application生存周期內，任何在分享此application的Jsp文件都能使用同一Bean.
class="package.class"
使用new關鍵字以及class構造器從一個class中示例一個bean.這個class不能是抽象的，必須有一個公用的，沒有參數的構造器.這個package的名字區別大小寫。
type="package.class"
如果這個Bean已經在指定的范圍中存在，那么寫這個Bean一個新的數據庫類型 。如果你沒有使用class或beanName指定type，Bean將不會被示例.package和class的名字，區分大小寫.
beanName="{package.class | <%= expression %>}" type="package.class"
使用java.beans.Beans.instantiate方法來從一個class或連續模版中示例一個Bean,同時指定Bean的類型。
beanName可以是package和class也可以是表達式,它的值會傳給Beans.instantiate.tupe的值可以和Bean相同。
package 和 class 名字區分大小寫.
1 引子
try…catch…finally恐怕是大家再熟悉不過的語句了，而且感覺用起來也是很簡單，邏輯上似乎也是很容易理解。不過，我親自體驗的“教訓”告訴我，這個東西可不是想象中的那么簡單、聽話。不信？那你看看下面的代碼，“猜猜”它執行后的結果會是什么？不要往后看答案、也不許執行代碼看真正答案哦。如果你的答案是正確，那么這篇文章你就不用浪費時間看啦。
public class TestException
{
public TestException()
{
}
boolean testEx() throws Exception
{
boolean ret = true;
try
{
ret = testEx1();
}
catch (Exception e)
{
System.out.println("testEx, catch exception");
ret = false;
throw e;
}
finally
{
System.out.println("testEx, finally; return value=" + ret);
return ret;
}
}
boolean testEx1() throws Exception
{
boolean ret = true;
try
{
ret = testEx2();
if (!ret)
{
return false;
}
System.out.println("testEx1, at the end of try");
return ret;
}
catch (Exception e)
{
System.out.println("testEx1, catch exception");
ret = false;
throw e;
}
finally
{
System.out.println("testEx1, finally; return value=" + ret);
return ret;
}
}
boolean testEx2() throws Exception
{
boolean ret = true;
try
{
int b = 12;
int c;
for (int i = 2; i >= -2; i--)
{
c = b / i;
System.out.println("i=" + i);
}
return true;
}
catch (Exception e)
{
System.out.println("testEx2, catch exception");
ret = false;
throw e;
}
finally
{
System.out.println("testEx2, finally; return value=" + ret);
return ret;
}
}
public static void main(String[] args)
{
TestException testException1 = new TestException();
try
{
testException1.testEx();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
你的答案是什么？是下面的答案嗎？
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, catch exception
testEx1, finally; return value=false
testEx, catch exception
testEx, finally; return value=false
如果你的答案真的如上面所說，那么你錯啦。^_^，那就建議你仔細看一看這篇文章或者拿上面的代碼按各種不同的情況修改、執行、測試，你會發現有很多事情不是原來想象中的那么簡單的。
現在公布正確答案：
i=2
i=1
testEx2, catch exception
testEx2, finally; return value=false
testEx1, finally; return value=false
testEx, finally; return value=false
2 基礎知識
2.1 相關概念
例外是在程序運行過程中發生的異常事件，比如除0溢出、數組越界、文件找不到等，這些事件的發生將阻止程序的正常運行。為了加強程序的魯棒性，程序設計時，必須考慮到可能發生的異常事件并做出相應的處理。C語言中，通過使用if語句來判斷是否出現了例外，同時，調用函數通過被調用函數的返回值感知在被調用函數中產生的例外事件并進行處理。全程變量ErroNo常常用來反映一個異常事件的類型。但是，這種錯誤處理機制會導致不少問題。
Java通過面向對象的方法來處理例外。在一個方法的運行過程中，如果發生了例外，則這個方法生成代表該例外的一個對象，并把它交給運行時系統，運行時系統尋找相應的代碼來處理這一例外。我們把生成例外對象并把它提交給運行時系統的過程稱為拋棄(throw)一個例外。運行時系統在方法的調用棧中查找，從生成例外的方法開始進行回朔，直到找到包含相應例外處理的方法為止，這一個過程稱為捕獲(catch)一個例外。
2.2 Throwable類及其子類
用面向對象的方法處理例外，就必須建立類的層次。類 Throwable位于這一類層次的最頂層，只有它的后代才可以做為一個例外被拋棄。圖1表示了例外處理的類層次。
從圖中可以看出，類Throwable有兩個直接子類：Error和Exception。Error類對象（如動態連接錯誤等），由Java虛擬機生成并拋棄（通常，Java程序不對這類例外進行處理）；Exception類對象是Java程序處理或拋棄的對象。它有各種不同的子類分別對應于不同類型的例外。其中類RuntimeException代表運行時由Java虛擬機生成的例外，如算術運算例外ArithmeticException(由除0錯等導致)、數組越界例外ArrayIndexOutOfBoundsException等；其它則為非運行時例外，如輸入輸出例外IOException等。Java編譯器要求Java程序必須捕獲或聲明所有的非運行時例外，但對運行時例外可以不做處理。
2.3 異常處理關鍵字
Java的異常處理是通過5個關鍵字來實現的：try，catch，throw，throws，finally。JB的在線幫助中對這幾個關鍵字是這樣解釋的：
Throws: Lists the exceptions a method could throw.
Throw: Transfers control of the method to the exception handler.
Try： Opening exception-handling statement.
Catch： Captures the exception.
Finally： Runs its code before terminating the program.
2.3.1 try語句
try語句用大括號{}指定了一段代碼，該段代碼可能會拋棄一個或多個例外。
2.3.2 catch語句
catch語句的參數類似于方法的聲明，包括一個例外類型和一個例外對象。例外類型必須為Throwable類的子類，它指明了catch語句所處理的例外類型，例外對象則由運行時系統在try所指定的代碼塊中生成并被捕獲，大括號中包含對象的處理，其中可以調用對象的方法。
catch語句可以有多個，分別處理不同類的例外。Java運行時系統從上到下分別對每個catch語句處理的例外類型進行檢測，直到找到類型相匹配的catch語句為止。這里，類型匹配指catch所處理的例外類型與生成的例外對象的類型完全一致或者是它的父類，因此，catch語句的排列順序應該是從特殊到一般。
也可以用一個catch語句處理多個例外類型，這時它的例外類型參數應該是這多個例外類型的父類，程序設計中要根據具體的情況來選擇catch語句的例外處理類型。
2.3.3 finally語句
try所限定的代碼中，當拋棄一個例外時，其后的代碼不會被執行。通過finally語句可以指定一塊代碼。無論try所指定的程序塊中拋棄或不拋棄例外，也無論catch語句的例外類型是否與所拋棄的例外的類型一致，finally所指定的代碼都要被執行，它提供了統一的出口。通常在finally語句中可以進行資源的清除工作。如關閉打開的文件等。
2.3.4 throws語句
throws總是出現在一個函數頭中，用來標明該成員函數可能拋出的各種異常。對大多數Exception子類來說，Java 編譯器會強迫你聲明在一個成員函數中拋出的異常的類型。如果異常的類型是Error或 RuntimeException， 或它們的子類，這個規則不起作用， 因為這在程序的正常部分中是不期待出現的。 如果你想明確地拋出一個RuntimeException，你必須用throws語句來聲明它的類型。
2.3.5 throw語句
throw總是出現在函數體中，用來拋出一個異常。程序會在throw語句后立即終止，它后面的語句執行不到，然后在包含它的所有try塊中（可能在上層調用函數中）從里向外尋找含有與其匹配的catch子句的try塊。
3 關鍵字及其中語句流程詳解
3.1 try的嵌套
你可以在一個成員函數調用的外面寫一個try語句，在這個成員函數內部，寫另一個try語句保護其他代碼。每當遇到一個try語句，異常的框架就放到堆棧上面，直到所有的try語句都完成。如果下一級的try語句沒有對某種異常進行處理，堆棧就會展開，直到遇到有處理這種異常的try語句。下面是一個try語句嵌套的例子。
class MultiNest {
static void procedure() {
try {
int a = 0;
int b = 42/a;
} catch(java.lang.ArithmeticException e) {
System.out.println("in procedure, catch ArithmeticException: " + e);
}
}
public static void main(String args[]) {
try {
procedure();
} catch(java.lang. Exception e) {
System.out.println("in main, catch Exception: " + e);
}
}
}
這個例子執行的結果為：
in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
成員函數procedure里有自己的try/catch控制，所以main不用去處理 ArrayIndexOutOfBoundsException；當然如果如同最開始我們做測試的例子一樣，在procedure中catch到異常時使用throw e;語句將異常拋出，那么main當然還是能夠捕捉并處理這個procedure拋出來的異常。例如在procedure函數的catch中的System.out語句后面增加throw e;語句之后，執行結果就變為：
in procedure, catch ArithmeticException: java.lang.ArithmeticException: / by zero
in main, catch Exception: java.lang.ArithmeticException: / by zero
3.2 try-catch程序塊的執行流程以及執行結果
相對于try-catch-finally程序塊而言，try-catch的執行流程以及執行結果還是比較簡單的。
首先執行的是try語句塊中的語句，這時可能會有以下三種情況：
1．如果try塊中所有語句正常執行完畢，那么就不會有其他的“動做”被執行，整個try-catch程序塊正常完成。
2．如果try語句塊在執行過程中碰到異常V，這時又分為兩種情況進行處理：
-->如果異常V能夠被與try相應的catch塊catch到，那么第一個catch到這個異常的catch塊（也是離try最近的一個與異常V匹配的catch塊）將被執行；如果catch塊執行正常，那么try-catch程序塊的結果就是“正常完成”；如果該catch塊由于原因R突然中止，那么try-catch程序塊的結果就是“由于原因R突然中止（completes abruptly）”。
-->如果異常V沒有catch塊與之匹配，那么這個try-catch程序塊的結果就是“由于拋出異常V而突然中止（completes abruptly）”。
3． 如果try由于其他原因R突然中止（completes abruptly），那么這個try-catch程序塊的結果就是“由于原因R突然中止（completes abruptly）”。
3.3 try-catch-finally程序塊的執行流程以及執行結果
try-catch-finally程序塊的執行流程以及執行結果比較復雜。
首先執行的是try語句塊中的語句，這時可能會有以下三種情況：
1．如果try塊中所有語句正常執行完畢，那么finally塊的居于就會被執行，這時分為以下兩種情況：
-->如果finally塊執行順利，那么整個try-catch-finally程序塊正常完成。
-->如果finally塊由于原因R突然中止，那么try-catch-finally程序塊的結局是“由于原因R突然中止（completes abruptly）”
2．如果try語句塊在執行過程中碰到異常V，這時又分為兩種情況進行處理：
-->如果異常V能夠被與try相應的catch塊catch到，那么第一個catch到這個異常的catch塊（也是離try最近的一個與異常V匹配的catch塊）將被執行；這時就會有兩種執行結果：
-->如果catch塊執行正常，那么finally塊將會被執行，這時分為兩種情況：
-->如果finally塊執行順利，那么整個try-catch-finally程序塊正常完成。
-->如果finally塊由于原因R突然中止，那么try-catch-finally程序塊的結局是“由于原因R突然中止（completes abruptly）”
-->如果catch塊由于原因R突然中止，那么finally模塊將被執行，分為兩種情況：
-->如果如果finally塊執行順利，那么整個try-catch-finally程序塊的結局是“由于原因R突然中止（completes abruptly）”。
-->如果finally塊由于原因S突然中止，那么整個try-catch-finally程序塊的結局是“由于原因S突然中止（completes abruptly）”，原因R將被拋棄。
（注意，這里就正好和我們的例子相符合，雖然我們在testEx2中使用throw e拋出了異常，但是由于testEx2中有finally塊，而finally塊的執行結果是complete abruptly的（別小看這個用得最多的return，它也是一種導致complete abruptly的原因之一啊——后文中有關于導致complete abruptly的原因分析），所以整個try-catch-finally程序塊的結果是“complete abruptly”，所以在testEx1中調用testEx2時是捕捉不到testEx1中拋出的那個異常的，而只能將finally中的return結果獲取到。
如果在你的代碼中期望通過捕捉被調用的下級函數的異常來給定返回值，那么一定要注意你所調用的下級函數中的finally語句，它有可能會使你throw出來的異常并不能真正被上級調用函數可見的。當然這種情況是可以避免的，以testEx2為例：如果你一定要使用finally而且又要將catch中throw的e在testEx1中被捕獲到，那么你去掉testEx2中的finally中的return就可以了。
這個事情已經在OMC2.0的MIB中出現過啦：服務器的異常不能完全被反饋到客戶端。）
-->如果異常V沒有catch塊與之匹配，那么finally模塊將被執行，分為兩種情況：
-->如果finally塊執行順利，那么整個try-catch-finally程序塊的結局就是“由于拋出異常V而突然中止（completes abruptly）”。
-->如果finally塊由于原因S突然中止，那么整個try-catch-finally程序塊的結局是“由于原因S突然中止（completes abruptly）”，異常V將被拋棄。
3．如果try由于其他原因R突然中止（completes abruptly），那么finally塊被執行，分為兩種情況：
-->如果finally塊執行順利，那么整個try-catch-finally程序塊的結局是“由于原因R突然中止（completes abruptly）”。
-->如果finally塊由于原因S突然中止，那么整個try-catch-finally程序塊的結局是“由于原因S突然中止（completes abruptly）”，原因R將被拋棄。
3.4 try-catch-finally程序塊中的return
從上面的try-catch-finally程序塊的執行流程以及執行結果一節中可以看出無論try或catch中發生了什么情況，finally都是會被執行的，那么寫在try或者catch中的return語句也就不會真正的從該函數中跳出了，它的作用在這種情況下就變成了將控制權（語句流程）轉到finally塊中；這種情況下一定要注意返回值的處理。
例如，在try或者catch中return false了，而在finally中又return true，那么這種情況下不要期待你的try或者catch中的return false的返回值false被上級調用函數獲取到，上級調用函數能夠獲取到的只是finally中的返回值，因為try或者catch中的return語句只是轉移控制權的作用。
3.5 如何拋出異常
如果你知道你寫的某個函數有可能拋出異常，而你又不想在這個函數中對異常進行處理，只是想把它拋出去讓調用這個函數的上級調用函數進行處理，那么有兩種方式可供選擇：
第一種方式：直接在函數頭中throws SomeException，函數體中不需要try/catch。比如將最開始的例子中的testEx2改為下面的方式，那么testEx1就能捕捉到testEx2拋出的異常了。
boolean testEx2() throws Exception{
boolean ret = true;
int b=12;
int c;
for (int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
}
return true;
}
第二種方式：使用try/catch，在catch中進行一定的處理之后（如果有必要的話）拋出某種異常。例如上面的testEx2改為下面的方式，testEx1也能捕獲到它拋出的異常：
boolean testEx2() throws Exception{
boolean ret = true;
try{
int b=12;
int c;
for (int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
}
return true;
}catch (Exception e){
System.out.println("testEx2, catch exception");
Throw e;
}
}
第三種方法：使用try/catch/finally，在catch中進行一定的處理之后（如果有必要的話）拋出某種異常。例如上面的testEx2改為下面的方式，testEx1也能捕獲到它拋出的異常：
boolean testEx2() throws Exception{
boolean ret = true;
try{
int b=12;
int c;
for (int i=2;i>=-2;i--){
c=b/i;
System.out.println("i="+i);
throw new Exception("aaa");
}
return true;
}catch (java.lang.ArithmeticException e){
System.out.println("testEx2, catch exception");
ret = false;
throw new Exception("aaa");
}finally{
System.out.println("testEx2, finally; return value="+ret);
}
}
4 關于abrupt completion
前面提到了complete abruptly（暫且理解為“突然中止”或者“異常結束”吧），它主要包含了兩種大的情形：abrupt completion of expressions and statements，下面就分兩種情況進行解釋。
4.1 Normal and Abrupt Completion of Evaluation
每一個表達式（expression）都有一種使得其包含的計算得以一步步進行的正常模式，如果每一步計算都被執行且沒有異常拋出，那么就稱這個表達式“正常結束（complete normally）”；如果這個表達式的計算拋出了異常，就稱為“異常結束（complete abruptly）”。異常結束通常有一個相關聯的原因（associated reason），通常也就是拋出一個異常V。
與表達式、操作符相關的運行期異常有：
-->A class instance creation expression, array creation expression , or string concatenation operatior expression throws an OutOfMemoryError if there is insufficient memory available.
-->An array creation expression throws a NegativeArraySizeException if the value of any dimension expression is less than zero.
-->A field access throws a NullPointerException if the value of the object reference expression is null.
-->A method invocation expression that invokes an instance method throws a NullPointerException if the target reference is null.
-->An array access throws a NullPointerException if the value of the array reference expression is null.
-->An array access throws an ArrayIndexOutOfBoundsException if the value of the array index expression is negative or greater than or equal to the length of the array.
-->A cast throws a ClassCastException if a cast is found to be impermissible at run time.
-->An integer division or integer remainder operator throws an ArithmeticException if the value of the right-hand operand expression is zero.
-->An assignment to an array component of reference type throws an ArrayStoreException when the value to be assigned is not compatible with the component type of the array.
4.2 Normal and Abrupt Completion of Statements
正常情況我們就不多說了，在這里主要是列出了abrupt completion的幾種情況：
-->break, continue, and return 語句將導致控制權的轉換，從而使得statements不能正常地、完整地執行。
-->某些表達式的計算也可能從java虛擬機拋出異常，這些表達式在上一小節中已經總結過了；一個顯式的的throw語句也將導致異常的拋出。拋出異常也是導致控制權的轉換的原因（或者說是阻止statement正常結束的原因）。
如果上述事件發生了，那么這些statement就有可能使得其正常情況下應該都執行的語句不能完全被執行到，那么這些statement也就是被稱為是complete abruptly.
導致abrupt completion的幾種原因：
-->A break with no label
-->A break with a given label
-->A continue with no label
-->A continue with a given label
-->A return with no value
-->A return with a given value A
-->throw with a given value, including exceptions thrown by the Java virtual machine
5 關于我們的編程的一點建議
弄清楚try-catch-finally的執行情況后我們才能正確使用它。
如果我們使用的是try-catch-finally語句塊，而我們又需要保證有異常時能夠拋出異常，那么在finally語句中就不要使用return語句了（finally語句塊的最重要的作用應該是釋放申請的資源），因為finally中的return語句會導致我們的throw e被拋棄，在這個try-catch-finally的外面將只能看到finally中的返回值（除非在finally中拋出異常）。（我們需要記?。翰粌Hthrow語句是abrupt completion 的原因，return、break、continue等這些看起來很正常的語句也是導致abrupt completion的原因。）
1）DOM（JAXP Crimson解析器）
DOM是用與平臺和語言無關的方式表示XML文檔的官方W3C標準。DOM是以層次結構組織的節點或信息片斷的集合。這個層次結構允許開發人員在樹中尋找特定信息。分析該結構通常需要加載整個文檔和構造層次結構，然后才能做任何工作。由于它是基于信息層次的，因而DOM被認為是基于樹或基于對象的。DOM以及廣義的基于樹的處理具有幾個優點。首先，由于樹在內存中是持久的，因此可以修改它以便應用程序能對數據和結構作出更改。它還可以在任何時候在樹中上下導航，而不是像SAX那樣是一次性的處理。DOM使用起來也要簡單得多。
2）SAX
SAX處理的優點非常類似于流媒體的優點。分析能夠立即開始，而不是等待所有的數據被處理。而且，由于應用程序只是在讀取數據時檢查數據，因此不需要將數據存儲在內存中。這對于大型文檔來說是個巨大的優點。事實上，應用程序甚至不必解析整個文檔；它可以在某個條件得到滿足時停止解析。一般來說，SAX還比它的替代者DOM快許多。
選擇DOM還是選擇SAX？ 對于需要自己編寫代碼來處理XML文檔的開發人員來說， 選擇DOM還是SAX解析模型是一個非常重要的設計決策。 DOM采用建立樹形結構的方式訪問XML文檔，而SAX采用的事件模型。
DOM解析器把XML文檔轉化為一個包含其內容的樹，并可以對樹進行遍歷。用DOM解析模型的優點是編程容易，開發人員只需要調用建樹的指令，然后利用navigation APIs訪問所需的樹節點來完成任務?？梢院苋菀椎奶砑雍托薷臉渲械脑?。然而由于使用DOM解析器的時候需要處理整個XML文檔，所以對性能和內存的要求比較高，尤其是遇到很大的XML文件的時候。由于它的遍歷能力，DOM解析器常用于XML文檔需要頻繁的改變的服務中。
SAX解析器采用了基于事件的模型，它在解析XML文檔的時候可以觸發一系列的事件，當發現給定的tag的時候，它可以激活一個回調方法，告訴該方法制定的標簽已經找到。SAX對內存的要求通常會比較低，因為它讓開發人員自己來決定所要處理的tag.特別是當開發人員只需要處理文檔中所包含的部分數據時，SAX這種擴展能力得到了更好的體現。但用SAX解析器的時候編碼工作會比較困難，而且很難同時訪問同一個文檔中的多處不同數據。
3）JDOM http://www.jdom.org
JDOM的目的是成為Java特定文檔模型，它簡化與XML的交互并且比使用DOM實現更快。由于是第一個Java特定模型，JDOM一直得到大力推廣和促進。正在考慮通過“Java規范請求JSR-102”將它最終用作“Java標準擴展”。從2000年初就已經開始了JDOM開發。
JDOM與DOM主要有兩方面不同。首先，JDOM僅使用具體類而不使用接口。這在某些方面簡化了API，但是也限制了靈活性。第二，API大量使用了Collections類，簡化了那些已經熟悉這些類的Java開發者的使用。
JDOM文檔聲明其目的是“使用20%（或更少）的精力解決80%（或更多）Java/XML問題”（根據學習曲線假定為20%）。JDOM對于大多數Java/XML應用程序來說當然是有用的，并且大多數開發者發現API比DOM容易理解得多。JDOM還包括對程序行為的相當廣泛檢查以防止用戶做任何在XML中無意義的事。然而，它仍需要您充分理解XML以便做一些超出基本的工作（或者甚至理解某些情況下的錯誤）。這也許是比學習DOM或JDOM接口都更有意義的工作。
JDOM自身不包含解析器。它通常使用SAX2解析器來解析和驗證輸入XML文檔（盡管它還可以將以前構造的DOM表示作為輸入）。它包含一些轉換器以將JDOM表示輸出成SAX2事件流、DOM模型或XML文本文檔。JDOM是在Apache許可證變體下發布的開放源碼。
4）DOM4J http://dom4j.sourceforge.net
雖然DOM4J代表了完全獨立的開發結果，但最初，它是JDOM的一種智能分支。它合并了許多超出基本XML文檔表示的功能，包括集成的XPath支持、XML Schema支持以及用于大文檔或流化文檔的基于事件的處理。它還提供了構建文檔表示的選項，它通過DOM4J API和標準DOM接口具有并行訪問功能。從2000下半年開始，它就一直處于開發之中。
為支持所有這些功能，DOM4J使用接口和抽象基本類方法。DOM4J大量使用了API中的Collections類，但是在許多情況下，它還提供一些替代方法以允許更好的性能或更直接的編碼方法。直接好處是，雖然DOM4J付出了更復雜的API的代價，但是它提供了比JDOM大得多的靈活性。
在添加靈活性、XPath集成和對大文檔處理的目標時，DOM4J的目標與JDOM是一樣的：針對Java開發者的易用性和直觀操作。它還致力于成為比JDOM更完整的解決方案，實現在本質上處理所有Java/XML問題的目標。在完成該目標時，它比JDOM更少強調防止不正確的應用程序行為。
DOM4J是一個非常非常優秀的Java XML API，具有性能優異、功能強大和極端易用使用的特點，同時它也是一個開放源代碼的軟件。如今你可以看到越來越多的Java軟件都在使用DOM4J來讀寫XML，特別值得一提的是連Sun的JAXM也在用DOM4J.
2。比較
1）DOM4J性能最好，連Sun的JAXM也在用DOM4J.目前許多開源項目中大量采用DOM4J，例如大名鼎鼎的Hibernate也用DOM4J來讀取XML配置文件。如果不考慮可移植性，那就采用DOM4J.
2）JDOM和DOM在性能測試時表現不佳，在測試10M文檔時內存溢出。在小文檔情況下還值得考慮使用DOM和JDOM.雖然JDOM的開發者已經說明他們期望在正式發行版前專注性能問題，但是從性能觀點來看，它確實沒有值得推薦之處。另外，DOM仍是一個非常好的選擇。DOM實現廣泛應用于多種編程語言。它還是許多其它與XML相關的標準的基礎，因為它正式獲得W3C推薦（與基于非標準的Java模型相對），所以在某些類型的項目中可能也需要它（如在JavaScript中使用DOM）。
3）SAX表現較好，這要依賴于它特定的解析方式－事件驅動。一個SAX檢測即將到來的XML流，但并沒有載入到內存（當然當XML流被讀入時，會有部分文檔暫時隱藏在內存中）。
3. 四種xml操作方式的基本使用方法
xml文件：
- <?xml version="1.0" encoding="gbk"?><list><node><name>weidewei</name><space>http://wishlife.javaeye.com</space></node><node><name>flying</name><space>http://user.qzone.qq.com/94611981</space></node></list>
程序代碼:
- import java.io.File;
- import java.util.Iterator;
- import java.util.List;
- import javax.xml.parsers.DocumentBuilder;
- import javax.xml.parsers.DocumentBuilderFactory;
- import javax.xml.parsers.SAXParser;
- import javax.xml.parsers.SAXParserFactory;
- import org.dom4j.io.SAXReader;
- import org.jdom.Element;
- import org.jdom.input.SAXBuilder;
- import org.w3c.dom.Document;
- import org.w3c.dom.NodeList;
- import org.xml.sax.Attributes;
- import org.xml.sax.InputSource;
- import org.xml.sax.SAXException;
- import org.xml.sax.helpers.DefaultHandler;
- public class MyXMLReader extends DefaultHandler {
- java.util.Stack tags = new java.util.Stack();
- public MyXMLReader() {
- super();
- }
- /**
- * DOM方式
- * @since V2.0
- * @author David.Wei
- * @date 2008-4-11
- * @return void
- */
- public void DOM() {
- long lasting = System.currentTimeMillis();
- try {
- File f = new File("F:/xmltest.xml");
- DocumentBuilderFactory factory = DocumentBuilderFactory
- .newInstance();
- DocumentBuilder builder = factory.newDocumentBuilder();
- Document doc = builder.parse(f);
- NodeList nl = doc.getElementsByTagName("node");
- for (int i = 0; i < nl.getLength(); i++) {
- System.out.println("|| Name: |"
- + doc.getElementsByTagName("name").item(i)
- .getFirstChild().getNodeValue());
- System.out.println("||Space: |"
- + doc.getElementsByTagName("space").item(i)
- .getFirstChild().getNodeValue());
- System.out.println("-------------------------------------------------"); }
- } catch (Exception e) {
- e.printStackTrace();
- }
- System.out.println("DOM RUNTIME："
- + (System.currentTimeMillis() - lasting) + " MS");
- }
- /**
- * SAX方式
- * @since V2.0
- * @author David.Wei
- * @date 2008-4-11
- * @return void
- */
- public void SAX() {
- long lasting = System.currentTimeMillis();
- try {
- SAXParserFactory sf = SAXParserFactory.newInstance();
- SAXParser sp = sf.newSAXParser();
- MyXMLReader reader = new MyXMLReader();
- sp.parse(new InputSource("F:/xmltest.xml"), reader);
- } catch (Exception e) {
- e.printStackTrace();
- }
- System.out.println("SAX RUNTIME："
- + (System.currentTimeMillis() - lasting) + " MS");
- }
- public void startElement(String uri, String localName, String qName,
- Attributes attrs) {
- tags.push(qName);
- }
- public void characters(char ch[], int start, int length)
- throws SAXException {
- String tag = (String) tags.peek();
- if (tag.equals("name")) {
- System.out.println("|| Name: |" + new String(ch, start, length));
- }
- if (tag.equals("space")) {
- System.out.println("||Space: |" + new String(ch, start, length));
- }
- System.out.println("-------------------------------------------------");
- }
- /**
- * JDOM方式
- * @since V2.0
- * @author David.Wei
- * @date 2008-4-11
- * @return void
- */
- public void JDOM() {
- long lasting = System.currentTimeMillis();
- try {
- SAXBuilder builder = new SAXBuilder();
- org.jdom.Document doc = builder.build(new File("F:/xmltest.xml"));
- Element foo = doc.getRootElement();
- List allChildren = foo.getChildren();
- for (int i = 0; i < allChildren.size(); i++) {
- System.out.println("|| Name: |"
- + ((Element) allChildren.get(i)).getChild("name")
- .getText());
- System.out.println("||Space: |"
- + ((Element) allChildren.get(i)).getChild("space")
- .getText());
- System.out.println("-------------------------------------------------"); }
- } catch (Exception e) {
- e.printStackTrace();
- }
- System.out.println("JDOM RUNTIME："
- + (System.currentTimeMillis() - lasting) + " MS");
- }
- /**
- * DOM4J方式
- * @since V2.0
- * @author David.Wei
- * @date 2008-4-11
- * @return void
- */
- public void DOM4J() {
- long lasting = System.currentTimeMillis();
- try {
- File f = new File("F:/xmltest.xml");
- SAXReader reader = new SAXReader();
- org.dom4j.Document doc = reader.read(f);
- org.dom4j.Element root = doc.getRootElement();
- org.dom4j.Element foo;
- for (Iterator i = root.elementIterator("node"); i.hasNext();) {
- foo = (org.dom4j.Element) i.next();
- System.out.println("|| Name: |" + foo.elementText("name"));
- System.out.println("||Space: |" + foo.elementText("space"));
- System.out.println("-------------------------------------------------");
- }
- } catch (Exception e) {
- e.printStackTrace();
- }
- System.out.println("DOM4J RUNTIME："
- + (System.currentTimeMillis() - lasting) + " MS");
- }
- public static void main(String arge[]) {
- MyXMLReader myXML = new MyXMLReader();
- System.out.println("=====================DOM=========================");
- myXML.DOM();
- System.out.println("=====================SAX=========================");
- myXML.SAX();
- System.out.println("=====================JDOM========================");
- myXML.JDOM();
- System.out.println("=====================DOM4J=======================");
- myXML.DOM4J();
- System.out.println("=================================================");
- }
- }
運行結果:
- =====================DOM=========================
- || Name: |weidewei
- ||Space: |http://wishlife.javaeye.com
- -------------------------------------------------
- || Name: |flying
- ||Space: |http://user.qzone.qq.com/94611981
- -------------------------------------------------
- DOM RUNTIME：62 MS
- =====================SAX=========================
- || Name: |weidewei
- -------------------------------------------------
- ||Space: |http://wishlife.javaeye.com
- -------------------------------------------------
- || Name: |flying
- -------------------------------------------------
- ||Space: |http://user.qzone.qq.com/94611981
- -------------------------------------------------
- SAX RUNTIME：16 MS
- =====================JDOM========================
- || Name: |weidewei
- ||Space: |http://wishlife.javaeye.com
- -------------------------------------------------
- || Name: |flying
- ||Space: |http://user.qzone.qq.com/94611981
- -------------------------------------------------
- JDOM RUNTIME：78 MS
- =====================DOM4J=======================
- || Name: |weidewei
- ||Space: |http://wishlife.javaeye.com
- -------------------------------------------------
- || Name: |flying
- ||Space: |http://user.qzone.qq.com/94611981
- -------------------------------------------------
- DOM4J RUNTIME：78 MS
- =================================================
String s = "I AM an Object!";
boolean isObject = s instanceof Object;
我們聲明了一個String對象引用，指向一個String對象，然后用instancof來測試它所指向的對象是否是Object類的一個實例，顯然，這是真的，所以返回true，也就是isObject的值為True。
instanceof有一些用處。比如我們寫了一個處理賬單的系統，其中有這樣三個類：
public class Bill {//省略細節}
public class PhoneBill extends Bill {//省略細節}
public class GasBill extends Bill {//省略細節}
在處理程序里有一個方法，接受一個Bill類型的對象，計算金額。假設兩種賬單計算方法不同，而傳入的Bill對象可能是兩種中的任何一種，所以要用instanceof來判斷：
public double calculate(Bill bill) {
if (bill instanceof PhoneBill) {
//計算電話賬單
}
if (bill instanceof GasBill) {
//計算燃氣賬單
}
...
}
這樣就可以用一個方法處理兩種子類。
然而，這種做法通常被認為是沒有好好利用面向對象中的多態性。其實上面的功能要求用方法重載完全可以實現，這是面向對象變成應有的做法，避免回到結構化編程模式。只要提供兩個名字和返回值都相同，接受參數類型不同的方法就可以了：
public double calculate(PhoneBill bill) {
//計算電話賬單
}
public double calculate(GasBill bill) {
//計算燃氣賬單
}
所以，使用instanceof在絕大多數情況下并不是推薦的做法，應當好好利用多態。