java 初始化

解析 Java 類和對象的初始化過程 由一個單態模式引出的問題談起

文檔選項 打印本頁 將此頁作為電子郵件發送 級別： 初級 張 國建 (guojian.zhang@gmail.com), 軟件工程師, 北京高偉達西南分軟 2006 年 8 月 31 日 類的初始化和對象初始化是 JVM 管理的類型生命周期中非常重要的兩個環節，Google 了一遍網絡，有關類裝載機制的文章倒是不少，然而類初始化和對象初始化的文章并不多，特別是從字節碼和 JVM 層次來分析的文章更是鮮有所見。 本文主要對類和對象初始化全過程進行分析，通過一個實際問題引入，將源代碼轉換成 JVM 字節碼后，對 JVM 執行過程的關鍵點進行全面解析，并在文中穿插入了相關 JVM 規范和 JVM 的部分內部理論知識，以理論與實際結合的方式介紹對象初始化和類初始化之間的協作以及可能存在的沖突問題。 問題引入 近日我在調試一個枚舉類型的解析器程序，該解析器是將數據庫內一萬多條枚舉代碼裝載到緩存中，為了實現快速定位枚舉代碼和具體枚舉類別的所有枚舉元素，該類在裝載枚舉代碼的同時對其采取兩種策略建立內存索引。由于該類是一個公共服務類，在程序各個層面都會使用到它，因此我將它實現為一個單例類。這個類在我調整類實例化語句位置之前運行正常，但當我把該類實例化語句調整到靜態初始化語句之前時，我的程序不再為我工作了。 下面是經過我簡化后的示例代碼： ［清單一］ package com.ccb.framework.enums; import java.util.Collections; import java.util.HashMap; import java.util.Map; public class CachingEnumResolver { //單態實例　一切問題皆由此行引起 private static final CachingEnumResolver SINGLE_ENUM_RESOLVER = new CachingEnumResolver(); /*MSGCODE->Category內存索引*/ private static Map CODE_MAP_CACHE; static { CODE_MAP_CACHE = new HashMap(); //為了說明問題,我在這里初始化一條數據 CODE_MAP_CACHE.put("0","北京市"); } //private, for single instance private CachingEnumResolver() { //初始化加載數據 引起問題，該方法也要負點責任 initEnums(); } /** * 初始化所有的枚舉類型 */ public static void initEnums() { // ~~~~~~~~~問題從這里開始暴露 ~~~~~~~~~~~// if (null == CODE_MAP_CACHE) { System.out.println("CODE_MAP_CACHE為空,問題在這里開始暴露."); CODE_MAP_CACHE = new HashMap(); } CODE_MAP_CACHE.put("1", "北京市"); CODE_MAP_CACHE.put("2", "云南省"); //..... other code... } public Map getCache() { return Collections.unmodifiableMap(CODE_MAP_CACHE); } /** * 獲取單態實例 * * @return */ public static CachingEnumResolver getInstance() { return SINGLE_ENUM_RESOLVER; } public static void main(String[] args) { System.out.println(CachingEnumResolver.getInstance().getCache()); } } 想必大家看了上面的代碼后會感覺有些茫然，這個類看起來沒有問題啊，這的確屬于典型的餓漢式單態模式啊，怎么會有問題呢？ 是的，他看起來的確沒有問題，可是如果將他 run 起來時，其結果是他不會為你正確 work。運行該類，它的執行結果是： ［清單二］ CODE_MAP_CACHE為空,問題在這里開始暴露. {0=北京市} 我的程序怎么會這樣？為什么在 initEnum() 方法里 CODE_MAP_CACHE 為空？為什么我輸出的 CODE_MAP_CACHE 內容只有一個元素，其它兩個元素呢？？？？！！ 看到這里，如果是你在調試該程序，你此刻一定覺得很奇怪，難道是我的 Jvm 有問題嗎？非也！如果不是，那我的程序是怎么了？這絕對不是我想要的結果?？墒聦嵣蠠o論怎么修改 initEnum() 方法都無濟于事，起碼我最初是一定不會懷疑到問題可能出在創建 CachingEnumResolver 實例這一環節上。正是因為我太相信我創建 CachingEnumResolver 實例的方法，加之對 Java 類初始化與對象實例化底層原理理解有所偏差，使我為此付出了三、四個小時--約半個工作日的大好青春。 那么問題究竟出在哪里呢？為什么會出現這樣的怪事呢？在解決這個問題之前，先讓我們來了解一下JVM的類和對象初始化的底層機制。 回頁首 類的生命周期 上圖展示的是類生命周期流向；在本文里，我只打算談談類的"初始化"以及"對象實例化"兩個階段。 回頁首 類初始化 類"初始化"階段，它是一個類或接口被首次使用的前階段中的最后一項工作，本階段負責為類變量賦予正確的初始值。 Java 編譯器把所有的類變量初始化語句和類型的靜態初始化器通通收集到 <clinit> 方法內，該方法只能被 Jvm 調用，專門承擔初始化工作。 除接口以外，初始化一個類之前必須保證其直接超類已被初始化，并且該初始化過程是由 Jvm 保證線程安全的。另外，并非所有的類都會擁有一個 <clinit>() 方法，在以下條件中該類不會擁有 <clinit>() 方法： 該類既沒有聲明任何類變量，也沒有靜態初始化語句； 該類聲明了類變量，但沒有明確使用類變量初始化語句或靜態初始化語句初始化； 該類僅包含靜態 final 變量的類變量初始化語句，并且類變量初始化語句是編譯時常量表達式。 回頁首 對象初始化 在類被裝載、連接和初始化，這個類就隨時都可能使用了。對象實例化和初始化是就是對象生命的起始階段的活動，在這里我們主要討論對象的初始化工作的相關特點。 Java 編譯器在編譯每個類時都會為該類至少生成一個實例初始化方法--即 "<init>()" 方法。此方法與源代碼中的每個構造方法相對應，如果類沒有明確地聲明任何構造方法，編譯器則為該類生成一個默認的無參構造方法，這個默認的構造器僅僅調用父類的無參構造器，與此同時也會生成一個與默認構造方法對應的 "<init>()" 方法. 通常來說，<init>() 方法內包括的代碼內容大概為：調用另一個 <init>() 方法；對實例變量初始化；與其對應的構造方法內的代碼。 如果構造方法是明確地從調用同一個類中的另一個構造方法開始，那它對應的 <init>() 方法體內包括的內容為：一個對本類的 <init>() 方法的調用；對應用構造方法內的所有字節碼。 如果構造方法不是通過調用自身類的其它構造方法開始，并且該對象不是 Object 對象，那 <init>() 法內則包括的內容為：一個對父類 <init>() 方法的調用；對實例變量初始化方法的字節碼；最后是對應構造子的方法體字節碼。 如果這個類是 Object，那么它的 <init>() 方法則不包括對父類 <init>() 方法的調用。 回頁首 類的初始化時機 本文到目前為止，我們已經大概有了解到了類生命周期中都經歷了哪些階段，但這個類的生命周期的開始階段--類裝載又是在什么時候被觸發呢？類又是何時被初始化的呢？讓我們帶著這三個疑問繼續去尋找答案。 Java 虛擬機規范為類的初始化時機做了嚴格定義："initialize on first active use"--" 在首次主動使用時初始化"。這個規則直接影響著類裝載、連接和初始化類的機制--因為在類型被初始化之前它必須已經被連接，然而在連接之前又必須保證它已經被裝載了。 在與初始化時機相關的類裝載時機問題上，Java 虛擬機規范并沒有對其做嚴格的定義，這就使得 JVM 在實現上可以根據自己的特點提供采用不同的裝載策略。我們可以思考一下 Jboss AOP 框架的實現原理，它就是在對你的 class 文件裝載環節做了手腳--插入了 AOP 的相關攔截字節碼，這使得它可以對程序員做到完全透明化，哪怕你用 new 操作符創建出的對象實例也一樣能被 AOP 框架攔截--與之相對應的 Spring AOP，你必須通過他的 BeanFactory 獲得被 AOP 代理過的受管對象，當然 Jboss AOP 的缺點也很明顯--他是和 JBOSS 服務器綁定很緊密的，你不能很輕松的移植到其它服務器上。嗯~……，說到這里有些跑題了，要知道 AOP 實現策略足可以寫一本厚厚的書了，嘿嘿，就此打住。 說了這么多，類的初始化時機就是在"在首次主動使用時"，那么，哪些情形下才符合首次主動使用的要求呢？ 首次主動使用的情形： 創建某個類的新實例時--new、反射、克隆或反序列化； 調用某個類的靜態方法時； 使用某個類或接口的靜態字段或對該字段賦值時（final字段除外）； 調用Java的某些反射方法時 初始化某個類的子類時 在虛擬機啟動時某個含有main()方法的那個啟動類。 除了以上幾種情形以外，所有其它使用JAVA類型的方式都是被動使用的，他們不會導致類的初始化。 回頁首 我的問題究竟出在哪里 好了，了解了JVM的類初始化與對象初始化機制后，我們就有了理論基礎，也就可以理性的去分析問題了。 下面讓我們來看看前面[清單一]的JAVA源代碼反組譯出的字節碼： ［清單三］ public class com.ccb.framework.enums.CachingEnumResolver extends java.lang.Object{ static {}; Code: 0: new #2; //class CachingEnumResolver 3: dup 4: invokespecial #14; //Method "<init>":()V ① 7: putstatic #16; //Field SINGLE_ENUM_RESOLVER:Lcom/ccb/framework/enums/CachingEnumResolver; 10: new #18; //class HashMap ② 13: dup 14: invokespecial #19; //Method java/util/HashMap."<init>":()V 17: putstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 20: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 23: ldc #23; //String 0 25: ldc #25; //String 北京市 27: invokeinterface #31, 3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ③ 32: pop 33: return private com.ccb.framework.enums.CachingEnumResolver(); Code: 0: aload_0 1: invokespecial #34; //Method java/lang/Object."<init>":()V 4: invokestatic #37; //Method initEnums:()V ④ 7: return public static void initEnums(); Code: 0: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; ⑤ 3: ifnonnull 24 6: getstatic #44; //Field java/lang/System.out:Ljava/io/PrintStream; 9: ldc #46; //String CODE_MAP_CACHE為空,問題在這里開始暴露. 11: invokevirtual #52; //Method java/io/PrintStream.println:(Ljava/lang/String;)V 14: new #18; //class HashMap 17: dup 18: invokespecial #19; //Method java/util/HashMap."<init>":()V ⑥ 21: putstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 24: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 27: ldc #54; //String 1 29: ldc #25; //String 北京市 31: invokeinterface #31, 3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ⑦ 36: pop 37: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 40: ldc #56; //String 2 42: ldc #58; //String 云南省 44: invokeinterface #31, 3; //InterfaceMethod java/util/Map.put:(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object; ⑧ 49: pop 50: return public java.util.Map getCache(); Code: 0: getstatic #21; //Field CODE_MAP_CACHE:Ljava/util/Map; 3: invokestatic #66; //Method java/util/Collections.unmodifiableMap:(Ljava/util/Map;)Ljava/util/Map; 6: areturn public static com.ccb.framework.enums.CachingEnumResolver getInstance(); Code: 0: getstatic #16; //Field SINGLE_ENUM_RESOLVER:Lcom/ccb/framework/enums/CachingEnumResolver; ⑨ 3: areturn } 如果上面［清單一］顯示，清單內容是在 JDK1.4 環境下的字節碼內容，可能這份清單對于很大部分兄弟來說確實沒有多少吸引力，因為這些 JVM 指令確實不像源代碼那樣漂亮易懂。但它的的確確是查找和定位問題最直接的辦法，我們想要的答案就在這份 JVM 指令清單里。 現在，讓我們對該類從類初始化到對象實例初始化全過程分析[清單一]中的代碼執行軌跡。 如前面所述，類初始化是在類真正可用時的最后一項前階工作，該階段負責對所有類正確的初始化值，此項工作是線程安全的，JVM會保證多線程同步。 第１步：調用類初始化方法 CachingEnumResolver.<clinit>()，該方法對外界是不可見的，換句話說是 JVM 內部專用方法，<clinit>() 內包括了 CachingEnumResolver 內所有的具有指定初始值的類變量的初始化語句。要注意的是并非每個類都具有該方法，具體的內容在前面已有敘述。 第２步：進入 <clinit>() 方法內，讓我們看字節碼中的 "①" 行，該行與其上面兩行組合起來代表 new 一個 CachingEnumResolver 對象實例，而該代碼行本身是指調用 CachingEnumResolver 類的 <init>（）方法。每一個 Java 類都具有一個 <init>() 方法，該方法是 Java 編譯器在編譯時生成的，對外界不可見，<init>() 方法內包括了所有具有指定初始化值的實例變量初始化語句和java類的構造方法內的所有語句。對象在實例化時，均通過該方法進行初始化。然而到此步，一個潛在的問題已經在此埋伏好，就等著你來犯了。 第３步：讓我們順著執行順序向下看，"④" 行，該行所在方法就是該類的構造器，該方法先調用父類的構造器 <init>() 對父對象進行初始化，然后調用 CachingEnumResolver.initEnum() 方法加載數據。 第４步："⑤" 行，該行獲取 "CODE_MAP_CACHE" 字段值，其運行時該字段值為 null。注意，問題已經開始顯現了。（作為程序員的你一定是希望該字段已經被初始化過了，而事實上它還沒有被初始化）。通過判斷，由于該字段為 NULL，因此程序將繼續執行到 "⑥" 行，將該字段實例化為 HashMap()。 第５步：在 "⑦"、"⑧" 行，其功能就是為 "CODE_MAP_CACHE" 字段填入兩條數據。 第６步：退出對象初始化方法 <init>()，將生成的對象實例初始化給類字段 "SINGLE_ENUM_RESOLVER"。（注意，此刻該對象實例內的類變量還未初始化完全，剛才由 <init>() 調用 initEnum() 方法賦值的類變量 "CODE_MAP_CACHE" 是 <clinit>() 方法還未初始化字段，它還將在后面的類初始化過程再次被覆蓋）。 第７步：繼續執行 <clinit>（）方法內的后繼代碼，"②" 行，該行對 "CODE_MAP_CACHE" 字段實例化為 HashMap 實例（注意：在對象實例化時已經對該字段賦值過了，現在又重新賦值為另一個實例，此刻，"CODE_MAP_CACHE"變量所引用的實例的類變量值被覆蓋，到此我們的疑問已經有了答案）。 第8步：類初始化完畢，同時該單態類的實例化工作也完成。 通過對上面的字節碼執行過程分析，或許你已經清楚了解到導致錯誤的深層原因了，也或許你可能早已被上面的分析過程給弄得暈頭轉向了，不過也沒折，雖然我也可以從源代碼的角度來闡述問題，但這樣不夠深度，同時也會有僅為個人觀點、不足可信之嫌。 回頁首 如何解決 要解決上面代碼所存在的問題很簡單，那就是將 "SINGLE_ENUM_RESOLVER" 變量的初始化賦值語句轉移到 getInstance() 方法中去即可。換句話說就是要避免在類還未初始化完成時從內部實例化該類或在初始化過程中引用還未初始化的字段。 回頁首 寫在最后 靜下浮燥之心，仔細思量自己是否真的掌握了本文主題所引出的知識，如果您覺得您已經完全或基本掌握了，那么很好，在最后，我將前面的代碼稍做下修改，請思考下面兩組程序是否同樣會存在問題呢？ 程序一 public class CachingEnumResolver { public static Map CODE_MAP_CACHE; static { CODE_MAP_CACHE = new HashMap(); //為了說明問題,我在這里初始化一條數據 CODE_MAP_CACHE.put("0","北京市"); initEnums(); } 程序二 public class CachingEnumResolver { private static final CachingEnumResolver SINGLE_ENUM_RESOLVER; public static Map CODE_MAP_CACHE; static { CODE_MAP_CACHE = new HashMap(); //為了說明問題,我在這里初始化一條數據 CODE_MAP_CACHE.put("0","北京市"); SINGLE_ENUM_RESOLVER = new CachingEnumResolver(); initEnums(); } 最后，一點關于 JAVA 群體的感言：時下正是各種開源框架盛行時期，Spring 更是大行其道，吸引著一大批 JEE 開發者的眼球（我也是 fans 中的一員）。然而，讓我們仔細觀察一下--以 Spring 群體為例，在那么多的 Spring fans 當中，有多少人去研究過 Spring 源代碼？又有多少人對 Spring 設計思想有真正深入了解呢？當然，我是沒有資格以這樣的口吻來說事的，我只是想表明一個觀點--學東西一定要"正本清源"。 獻上此文，謹以共勉。 關于作者   北京高偉達西南分軟 Java EE 軟件工程師，三年 Java EE 項目經驗，行業方向為銀行 OCRM 系統。對 JAVA 有著濃厚的興趣，業余研究 AOP/ESB 方向。

posted @ 2009-12-16 22:48 ammay 閱讀(700) | 評論 (0) | 編輯 收藏

泛型

import java.util.*;

/**

* A tree is a data structure that holds values of type V.

* Each tree has a single value of type V and can have any number of

* branches, each of which is itself a Tree.

*/

public class Tree {

// The value of the tree is of type V.

V value;



// A Tree can have branches, each of which is also a Tree



List<tree branches = new ArrayList<tree();



// Here's the constructor. Note the use of the type variable V.

public Tree(V value) { this.value = value; }



// These are instance methods for manipulating the node value and branches.

// Note the use of the type variable V in the arguments or return types.

V getValue() { return value; }

void setValue(V value) { this.value = value; }

int getNumBranches() { return branches.size(); }

Tree getBranch(int n) { return branches.get(n); }

void addBranch(Tree branch) { branches.add(branch); }

}

import java.io.Serializable;

import java.util.*;



public class Tree>

implements Serializable, Comparable<tree



{

V value;

List<tree branches = new ArrayList<tree();



public Tree(V value) { this.value = value; }



// Instance methods

V getValue() { return value; }

void setValue(V value) { this.value = value; }

int getNumBranches() { return branches.size(); }

Tree getBranch(int n) { return branches.get(n); }

void addBranch(Tree branch) { branches.add(branch); }



// This method is a nonrecursive implementation of Comparable<tree



// It only compares the value of this node and ignores branches.

public int compareTo(Tree that) {

if (this.value == null && that.value == null) return 0;

if (this.value == null) return -1;

if (that.value == null) return 1;

return this.value.compareTo(that.value);

}



// javac -Xlint warns us if we omit this field in a Serializable class

private static final long serialVersionUID = 833546143621133467L;

}

public class Tree {

// These fields hold the value and the branches

V value;

List<tree<? extends V>> branches = new ArrayList<tree<? extends V>>();



// Here's a constructor

public Tree(V value) { this.value = value; }



// These are instance methods for manipulating value and branches

V getValue() { return value; }

void setValue(V value) { this.value = value; }

int getNumBranches() { return branches.size(); }

Tree<? extends V> getBranch(int n) { return branches.get(n); }

void addBranch(Tree<? extends V> branch) { branches.add(branch); }

}

Tree t = new Tree(0); // Note autoboxing

t.addBranch(new Tree(1));  // int 1 autoboxed to Integer

Tree<? extends Number> b = t.getBranch(0);

Tree<?> b2 = t.getBranch(0);

Tree b3 = t.getBranch(0); // compilation error

Tree<? extends Number> b = t.getBranch(0);

Number value = b.getValue();

b.setValue(3.0); // Illegal, value type is unknown

b.addBranch(new Tree(Math.PI));

/** Recursively compute the sum of the values of all nodes on the tree */

public static double sum(Tree<? extends Number> t) {

double total = t.value.doubleValue();

for(Tree<? extends Number> b : t.branches) total += sum(b);

return total;

}

public static  double sum(Tree t) {

N value = t.value;

double total = value.doubleValue();

for(Tree<? extends N> b : t.branches) total += sum(b);

return total;

}

// This method returns the largest of two trees, where tree size

// is computed by the sum() method. The type variable ensures that 

// both trees have the same value type and that both can be passed to sum().

public static  Tree max(Tree t, Tree u) {

double ts = sum(t);

double us = sum(u);

if (ts > us) return t;

else return u;

}

public static 

Tree<? extends Number> max(Tree t, Tree u) {...}

public static Tree<? extends Number> max(Tree<? extends Number> t,

Tree<? extends Number> u) {...}

public static  Tree max(Tree t, Tree u) {...}

Tree x = new Tree(1);

Tree y = new Tree(2);

Tree z = Tree.max(x, y);

public class Util {

/** Set all elements of a to the value v; return a. */

public static  T[] fill(T[] a, T v) {

for(int i = 0; i < a.length; i++) a[i] = v;

return a;

}

}

Boolean[] booleans = Util.fill(new Boolean[100], Boolean.TRUE);

Object o = Util.fill(new Number[5], new Integer(42));

Set empty = Collections.emptySet();

Set empty = Collections.emptySet();

printWords(Collections.emptySet());

/** Return the largest of the specified values or null if there are none */

public static > T max(T... values) { ... }

public interface Command {

public void doit(String arg) throws X;

}

Command save = new Command() {

public void doit(String filename) throws IOException {

PrintWriter out = new PrintWriter(new FileWriter(filename));

out.println("hello world");

out.close();

}

};



try { save.doit("/tmp/foo"); }

catch(IOException e) { System.out.println(e); }

public final class Integer extends Number implements Comparable

public class BigInteger extends Number implements Comparable

>

public static  boolean addAll(Collection<? super T> c, T... a)

public class Enum> implements Comparable, Serializable

泛型類型

public static void main(String[] args) {

    // This list is intended to hold only strings.

    // The compiler doesn't know that so we have to remember ourselves.

    List wordlist = new ArrayList();  



    // Oops! We added a String[] instead of a String.

    // The compiler doesn't know that this is an error.

    wordlist.add(args);



    // Since List can hold arbitrary objects, the get() method returns

    // Object.  Since the list is intended to hold strings, we cast the

    // return value to String but get a ClassCastException because of

    // the error above.

    String word = (String)wordlist.get(0);

}

public static void main(String[] args) {

    // This list can only hold String objects

    List<String> wordlist = new ArrayList<String>();



    // args is a String[], not String, so the compiler won't let us do this

    wordlist.add(args);  // Compilation error!



    // We can do this, though.  

    // Notice the use of the new for/in looping statement

    for(String arg : args) wordlist.add(arg);



    // No cast is required.  List<String>.get() returns a String.

    String word = wordlist.get(0);

}

public static void main(String[] args) {

    // A map from strings to their position in the args[] array

    Map<String,Integer> map = new HashMap<String,Integer>();



    // Note that we use autoboxing to wrap i in an Integer object.

    for(int i=0; i < args.length; i++) map.put(args[i], i);  



    // Find the array index of a word.  Note no cast is required!

    Integer position = map.get("hello");



    // We can also rely on autounboxing to convert directly to an int,

    // but this throws a NullPointerException if the key does not exist 

    // in the map

    int pos = map.get("world");

}

// Look at all those nested angle brackets!

Map<String, List<List<int[]>>> map = getWeirdMap();



// The compiler knows all the types and we can write expressions

// like this without casting.  We might still get NullPointerException

// or ArrayIndexOutOfBounds at runtime, of course.

int value = map.get(key).get(0).get(0)[0];



// Here's how we break that expression down step by step.

List<List<int[]>> listOfLists = map.get(key);

List<int[]> listOfIntArrays = listOfLists.get(0);

int[] array = listOfIntArrays.get(0);

int element = array[0];

List<String> words = // ...initialized elsewhere...

Iterator<String> iterator = words.iterator();

String firstword = iterator.next();

List l = new ArrayList();

l.add("hello");  

l.add(new Integer(123));

Object o = l.get(0);

List<Object> l = new ArrayList<Object>();

l.add("hello");  

l.add(123);              // autoboxing

Object o = l.get(0);

ArrayList<Integer> l = new ArrayList<Integer>();

List<Integer> m = l;                            // okay

Collection<Integer> n = l;                      // okay

ArrayList<Number> o = l;                        // error

Collection<Object> p = (Collection<Object>)l;   // error, even with cast

List<Integer> li = new ArrayList<Integer>();

li.add(123);



// The line below will not compile.  But for the purposes of this

// thought-experiment, assume that it does compile and see how much

// trouble we get ourselves into.

List<Object> lo = li;  



// Now we can retrieve elements of the list as Object instead of Integer

Object number = lo.get(0);



// But what about this?

lo.add("hello world");



// If the line above is allowed then the line below throws ClassCastException

Integer i = li.get(1);  // Can't cast a String to Integer!

// Here's a basic parameterized list.

List<Integer> li = new ArrayList<Integer>();



// It is legal to assign a parameterized type to a nonparameterized variable

List l = li;   



// This line is a bug, but it compiles and runs.

// The Java 5.0 compiler will issue an unchecked warning about it.

// If it appeared as part of a legacy class compiled with Java 1.4, however,

// then we'd never even get the warning.  

l.add("hello");



// This line compiles without warning but throws ClassCastException at runtime.

// Note that the failure can occur far away from the actual bug.

Integer i = li.get(0);

// Here's a basic parameterized list.

List<Integer> li = new ArrayList<Integer>();



// Wrap it for runtime type safety

List<Integer> cli = Collections.checkedList(li, Integer.class);



// Now widen the checked list to the raw type

List l = cli;   



// This line compiles but fails at runtime with a ClassCastException.

// The exception occurs exactly where the bug is, rather than far away

l.add("hello");

String[] words = new String[10];

Object[] objs = words;

objs[0] = 1;  // 1 autoboxed to an Integer, throws ArrayStoreException

List<String>[] wordlists = new ArrayList<String>[10];

ArrayList<Integer> ali = new ArrayList<Integer>();

ali.add(123);

Object[] objs = wordlists;

objs[0] = ali;                       // No ArrayStoreException

String s = wordlists[0].get(0);      // ClassCastException!

public static void printList(PrintWriter out, List list) {

    for(int i=0, n=list.size(); i < n; i++) {

        if (i > 0) out.print(", ");

        out.print(list.get(i).toString());

    }

}

public static void printList(PrintWriter out, List<Object> list) {

    for(int i=0, n=list.size(); i < n; i++) {

        if (i > 0) out.print(", ");

        out.print(list.get(i).toString());

    }

}

public static void printList(PrintWriter out, List<?> list) {

    for(int i=0, n=list.size(); i < n; i++) {

        if (i > 0) out.print(", ");

        Object o = list.get(i);

        out.print(o.toString());

    }

}

List<Object> l = new ArrayList<Object>();

public static double sumList(List<?> list) {

    double total = 0.0;

    for(Object o : list) {

        Number n = (Number) o;  // A cast is required and may fail

        total += n.doubleValue();

    }

    return total;

}

public static double sumList(List<? extends Number> list) {

    double total = 0.0;

    for(Number n : list) total += n.doubleValue();

    return total;

}

posted @ 2009-12-14 22:53 ammay 閱讀(396) | 評論 (0) | 編輯 收藏

泛型

泛型是 Sun 公司發布的 JDK 5.0 中的一個重要特性，它的最大優點是提供了程序的類型安全同可以向后兼容。為了幫助讀者更好地理解和使用泛型，本文通過一些示例從基本原理，重要概念，關鍵技術，以及相似技術比較等多個角度對 Java 語言中的泛型技術進行了介紹，重點強調了泛型中的一些基本但又不是很好理解的概念。

為了避免和 C++ 中的模板混淆，本文簡要介紹了 Java 中的泛型和 C++ 中的模板的主要區別，希望這種比較能夠幫助讀者加深對泛型的理解。

引言

很多 Java 程序員都使用過集合（Collection），集合中元素的類型是多種多樣的，例如，有些集合中的元素是 Byte 類型的，而有些則可能是 String 類型的，等等。Java 語言之所以支持這么多種類的集合，是因為它允許程序員構建一個元素類型為 Object 的 Collection，所以其中的元素可以是任何類型。

當使用 Collection 時，我們經常要做的一件事情就是要進行類型轉換，當轉換成所需的類型以后，再對它們進行處理。很明顯，這種設計給編程人員帶來了極大的不便，同時也容易引入錯誤。

在很多 Java 應用中，上述情況非常普遍，為了解決這個問題，使 Java 語言變得更加安全好用，近些年的一些編譯器對 Java 語言進行了擴充，使 Java 語言支持了"泛型"，特別是 Sun 公司發布的 JDK 5.0 更是將泛型作為其中一個重要的特性加以推廣。

本文首先對泛型的基本概念和特點進行簡單介紹，然后通過引入幾個實例來討論帶有泛型的類，泛型中的子類型，以及范化方法和受限類型參數等重要概念。為了幫助讀者更加深刻的理解并使用泛型，本文還介紹了泛型的轉化，即，如何將帶有泛型的 Java 程序轉化成一般的沒有泛型的 Java 程序。這樣，讀者對泛型的理解就不會僅僅局限在表面上了。考慮到多數讀者僅僅是使用泛型，因此本文并未介紹泛型在編譯器中的具體實現。Java 中的泛型和 C++ 中的模板表面上非常相似，但實際上二者還是有很大區別的，本文最后簡單介紹了 Java 中的泛型與 C++ 模板的主要區別。

回頁首

泛型概覽

泛型本質上是提供類型的"類型參數"，它們也被稱為參數化類型（parameterized type）或參量多態（parametric polymorphism）。其實泛型思想并不是 Java 最先引入的，C++ 中的模板就是一個運用泛型的例子。

GJ（Generic Java）是對 Java 語言的一種擴展，是一種帶有參數化類型的 Java 語言。用 GJ 編寫的程序看起來和普通的 Java 程序基本相同，只不過多了一些參數化的類型同時少了一些類型轉換。實際上，這些 GJ 程序也是首先被轉化成一般的不帶泛型的 Java 程序后再進行處理的，編譯器自動完成了從 Generic Java 到普通 Java 的翻譯。具體的轉化過程大致分為以下幾個部分：

• 將參數化類型中的類型參數"擦除"（erasure）掉；
• 將類型變量用"上限（upper bound）"取代，通常情況下這些上限是 Object。這里的類型變量是指實例域，本地方法域，方法參數以及方法返回值中用來標記類型信息的"變量"，例如：實例域中的變量聲明 A elem;，方法聲明 Node (A elem){};，其中，A 用來標記 elem 的類型，它就是類型變量。
• 添加類型轉換并插入"橋方法"（bridge method），以便覆蓋（overridden）可以正常的工作。

轉化后的程序和沒有引入泛型時程序員不得不手工完成轉換的程序是非常一致的，具體的轉化過程會在后面介紹。GJ 保持了和 Java 語言以及 Java 虛擬機很好的兼容性，下面對 GJ 的特點做一個簡要的總結。

• 類型安全。 泛型的一個主要目標就是提高 Java 程序的類型安全。使用泛型可以使編譯器知道變量的類型限制，進而可以在更高程度上驗證類型假設。如果沒有泛型，那么類型的安全性主要由程序員來把握，這顯然不如帶有泛型的程序安全性高。
• 消除強制類型轉換。泛型可以消除源代碼中的許多強制類型轉換，這樣可以使代碼更加可讀，并減少出錯的機會。
• 向后兼容。支持泛型的 Java 編譯器（例如 JDK5.0 中的 Javac）可以用來編譯經過泛型擴充的 Java 程序（GJ 程序），但是現有的沒有使用泛型擴充的 Java 程序仍然可以用這些編譯器來編譯。
• 層次清晰，恪守規范。無論被編譯的源程序是否使用泛型擴充，編譯生成的字節碼均可被虛擬機接受并執行。也就是說不管編譯器的輸入是 GJ 程序，還是一般的 Java 程序，經過編譯后的字節碼都嚴格遵循《Java 虛擬機規范》中對字節碼的要求。可見，泛型主要是在編譯器層面實現的，它對于 Java 虛擬機是透明的。
• 性能收益。目前來講，用 GJ 編寫的代碼和一般的 Java 代碼在效率上是非常接近的。 但是由于泛型會給 Java 編譯器和虛擬機帶來更多的類型信息，因此利用這些信息對 Java 程序做進一步優化將成為可能。

以上是泛型的一些主要特點，下面通過幾個相關的例子來對 Java 語言中的泛型進行說明。

回頁首

帶有泛型的類

為了幫助大家更好地理解 Java 語言中的泛型，我們在這里先來對比兩段實現相同功能的 GJ 代碼和 Java 代碼。通過觀察它們的不同點來對 Java 中的泛型有個總體的把握，首先來分析一下不帶泛型的 Java 代碼，程序如下：

1	interface Collection {
            2	   	public void add (Object x);
            3		public Iterator iterator ();
            4	}
            5
            6	interface Iterator {
            7	   	public Object next ();
            8		public boolean hasNext ();
            9	}
            10
            11	class NoSuchElementException extends RuntimeException {}
            12
            13	class LinkedList implements Collection {
            14
            15		protected class Node {
            16		   	Object elt;
            17			Node next = null;
            18			Node (Object elt) { this.elt = elt; }
            19		}
            20
            21		protected Node head = null, tail = null;
            22
            23		public LinkedList () {}
            24
            25		public void add (Object elt) {
            26			if (head == null) { head = new Node(elt); tail = head; }
            27			else { tail.next = new Node(elt); tail = tail.next; }
            28		}
            29
            30		public Iterator iterator () {
            31
            32			return new Iterator () {
            33				protected Node ptr = head;
            34				public boolean hasNext () { return ptr != null; }
            35				public Object next () {
            36					if (ptr != null) {
            37						Object elt = ptr.elt; ptr = ptr.next; return elt;
            |-------10--------20--------30--------40--------50--------60--------70--------80--------9|
            |-------- XML error:  The previous line is longer than the max of 90 characters ---------|
            38					} else throw new NoSuchElementException ();
            39				}
            40			};
            41		}
            42	}
            

接口 Collection 提供了兩個方法，即添加元素的方法 add(Object x)，見第 2 行，以及返回該 Collection 的 Iterator 實例的方法 iterator()，見第 3 行。Iterator 接口也提供了兩個方法，其一就是判斷是否有下一個元素的方法 hasNext()，見第 8 行，另外就是返回下一個元素的方法 next()，見第 7 行。LinkedList 類是對接口 Collection 的實現，它是一個含有一系列節點的鏈表，節點中的數據類型是 Object，這樣就可以創建任意類型的節點了，比如 Byte， String 等等。上面這段程序就是用沒有泛型的傳統的 Java 語言編寫的代碼。接下來我們分析一下傳統的 Java 語言是如何使用這個類的。

代碼如下：

1	class Test {
            2		    public static void main (String[] args) {
            3			// byte list
            4			LinkedList xs = new LinkedList();
            5			xs.add(new Byte(0)); xs.add(new Byte(1));
            6			Byte x = (Byte)xs.iterator().next();
            7			// string list
            8			LinkedList ys = new LinkedList();
            9			ys.add("zero"); ys.add("one");
            10			String y = (String)ys.iterator().next();
            11			// string list list
            12			LinkedList zss = new LinkedList();
            13			zss.add(ys);
            14			String z = (String)((LinkedList)zss.iterator().next()).iterator().next();
            |-------10--------20--------30--------40--------50--------60--------70--------80--------9|
            |-------- XML error:  The previous line is longer than the max of 90 characters ---------|
            15			// string list treated as byte list
            16			Byte w = (Byte)ys.iterator().next(); // run-time exception
            17			}
            18	}
            

從上面的程序我們可以看出，當從一個鏈表中提取元素時需要進行類型轉換，這些都要由程序員顯式地完成。如果我們不小心從 String 類型的鏈表中試圖提取一個 Byte 型的元素，見第 15 到第 16 行的代碼，那么這將會拋出一個運行時的異常。請注意，上面這段程序可以順利地經過編譯，不會產生任何編譯時的錯誤，因為編譯器并不做類型檢查，這種檢查是在運行時進行的。不難發現，傳統 Java 語言的這一缺陷推遲了發現程序中錯誤的時間，從軟件工程的角度來看，這對軟件的開發是非常不利的。接下來，我們討論一下如何用 GJ 來實現同樣功能的程序。源程序如下：

1	interface Collection<A> {
            2		public void add(A x);
            3		public Iterator<A> iterator();
            4	}
            5
            6	interface Iterator<A> {
            7		public A next();
            8		public boolean hasNext();
            9	}
            10
            11	class NoSuchElementException extends RuntimeException {}
            12
            13	class LinkedList<A> implements Collection<A> {
            14		protected class Node {
            15			A elt;
            16			Node next = null;
            17			Node (A elt) { this.elt = elt; }
            18		}
            19
            20		protected Node head = null, tail = null;
            21
            22		public LinkedList () {}
            23
            24		public void add (A elt) {
            25			if (head == null) { head = new Node(elt); tail = head; }
            26			else { tail.next = new Node(elt); tail = tail.next; }
            27		}
            28
            29		public Iterator<A> iterator () {
            30			return new Iterator<A> () {
            31				protected Node ptr = head;
            32				public boolean hasNext () { return ptr != null; }
            33				public A next () {
            34					if (ptr != null) {
            35						A elt = ptr.elt; ptr = ptr.next; return elt;
            |-------10--------20--------30--------40--------50--------60--------70--------80--------9|
            |-------- XML error:  The previous line is longer than the max of 90 characters ---------|
            36					} else throw new NoSuchElementException ();
            37				}
            38			};
            39	 	}
            40	}
            

程序的功能并沒有任何改變，只是在實現方式上使用了泛型技術。我們注意到上面程序的接口和類均帶有一個類型參數 A，它被包含在一對尖括號（< >）中，見第 1，6 和 13 行，這種表示法遵循了 C++ 中模板的表示習慣。這部分程序和上面程序的主要區別就是在 Collection, Iterator, 或 LinkedList 出現的地方均用 Collection<A>, Iterator<A>, 或 LinkedList<A> 來代替，當然，第 22 行對構造函數的聲明除外。

下面再來分析一下在 GJ 中是如何對這個類進行操作的，程序如下：

1	class Test {
            2		public static void main (String [] args) {
            3			// byte list
            4			LinkedList<Byte> xs = new LinkedList<Byte>();
            5			xs.add(new Byte(0)); xs.add(new Byte(1));
            6			Byte x = xs.iterator().next();
            7			// string list
            8			LinkedList<String> ys = new LinkedList<String>();
            9			ys.add("zero"); ys.add("one");
            10			String y = ys.iterator().next();
            11			// string list list
            12			LinkedList<LinkedList<String>>zss=
            newLinkedList<LinkedList<String>>();
            13			zss.add(ys);
            14			String z = zss.iterator().next().iterator().next();
            15			// string list treated as byte list
            16			Byte w = ys.iterator().next(); // compile-time error
            17		}
            18	}
            

在這里我們可以看到，有了泛型以后，程序員并不需要進行顯式的類型轉換，只要賦予一個參數化的類型即可，見第 4，8 和 12 行，這是非常方便的，同時也不會因為忘記進行類型轉換而產生錯誤。另外需要注意的就是當試圖從一個字符串類型的鏈表里提取出一個元素，然后將它賦值給一個 Byte 型的變量時，見第 16 行，編譯器將會在編譯時報出錯誤，而不是由虛擬機在運行時報錯，這是因為編譯器會在編譯時刻對 GJ 代碼進行類型檢查，此種機制有利于盡早地發現并改正錯誤。

類型參數的作用域是定義這個類型參數的整個類，但是不包括靜態成員函數。這是因為當訪問同一個靜態成員函數時，同一個類的不同實例可能有不同的類型參數，所以上述提到的那個作用域不應該包括這些靜態函數，否則就會引起混亂。

回頁首

泛型中的子類型

在 Java 語言中，我們可以將某種類型的變量賦值給其父類型所對應的變量，例如，String 是 Object 的子類型，因此，我們可以將 String 類型的變量賦值給 Object 類型的變量，甚至可以將 String [ ] 類型的變量（數組）賦值給 Object [ ] 類型的變量，即 String [ ] 是 Object [ ] 的子類型。

上述情形恐怕已經深深地印在了廣大讀者的腦中，對于泛型來講，上述情形有所變化，因此請廣大讀者務必引起注意。為了說明這種不同，我們還是先來分析一個小例子，代碼如下所示：

1			List<String> ls = new ArrayList<String>();
            2			List<Object> lo = ls;
            3	lo.add(new Integer());
            4	String s = ls.get(0);
            

上述代碼的第二行將 List<String> 賦值給了 List<Object>，按照以往的經驗，這種賦值好像是正確的，因為 List<String> 應該是 List<Object> 的子類型。這里需要特別注意的是，這種賦值在泛型當中是不允許的！List<String> 也不是 List<Object> 的子類型。

如果上述賦值是合理的，那么上面代碼的第三行的操作將是可行的，因為 lo 是 List<Object>，所以向其添加 Integer 類型的元素應該是完全合法的。讀到此處，我們已經看到了第二行的這種賦值所潛在的危險，它破壞了泛型所帶來的類型安全性。

一般情況下，如果 A 是 B 的子類型，C 是某個泛型的聲明，那么 C<A> 并不是 C<B> 的子類型，我們也不能將 C<A> 類型的變量賦值給 C<B> 類型的變量。這一點和我們以前接觸的父子類型關系有很大的出入，因此請讀者務必引起注意。

回頁首

泛化方法和受限類型參數

在這一部分我們將討論有關泛化方法（generic method ）和受限類型參數（bounded type parameter）的內容，這是泛型中的兩個重要概念，還是先來分析一下與此相關的代碼。

1	interface Comparable<A> {
            2		public int compareTo(A that);
            3	}
            4
            5	class Byte implements Comparable<Byte> {
            6		private byte value;
            7		public Byte(byte value) {this.value = value;}
            8		public byte byteValue() {return value;}
            9		public int compareTo(Byte that) {
            10			return this.value - that.value;
            11		}
            12	}
            13
            14	class Collections {
            15		public static <A implements Comparable<A>>
            16	            A max (Collection<A> xs) {
            17			    	Iterator<A> xi = xs.iterator();
            18			    	A w = xi.next();
            19			    	while (xi.hasNext()) {
            20						A x = xi.next();
            21						if (w.compareTo(x) < 0) w = x;
            22					}
            23					return w;
            24		}
            25	}
            

這里定義了一個接口 Comparable<A>，用來和 A 類型的對象進行比較。類 Byte 實現了這個接口，并以它自己作為類型參數，因此，它們自己就可以和自己進行比較了。

第 14 行到第 25 行的代碼定義了一個類 Collections，這個類包含一個靜態方法 max(Collection<A> xs)，它用來在一個非空的 Collection 中尋找最大的元素并返回這個元素。這個方法的兩個特點就是它是一個泛化方法并且有一個受限類型參數。

之所以說它是泛化了的方法，是因為這個方法可以應用到很多種類型上。當要將一個方法聲明為泛化方法時，我們只需要在這個方法的返回類型（A）之前加上一個類型參數（A），并用尖括號（< >）將它括起來。這里的類型參數（A）是在方法被調用時自動實例化的。例如，假設對象 m 的類型是 Collection<Byte>，那么當使用下面的語句：

Byte x = Collections.max(m);
            

調用方法 max 時，該方法的參數 A 將被推測為 Byte。

根據上面討論的內容，泛化方法 max 的完整聲明應該是下面的形式：

            < A >  A max (Collection<A> xs) {
            max 的方法體
            }
            

但是，我們見到的 max 在 < A > 中還多了 "implements Comparable<A>" 一項，這是什么呢？這就是我們下面將要談到的"受限的類型參數"。在上面的例子中，類型參數 A 就是一個受限的的類型參數，因為它不是泛指任何類型，而是指那些自己和自己作比較的類型。例如參數可以被實例化為 Byte，因為程序中有 Byte implements Comparable<Byte> 的語句，參見第 5 行。這種限制（或者說是范圍）通過如下的方式表示，"類型參數 implements 接口"，或是 "類型參數 extend 類"，上面程序中的"Byte implements Comparable<Byte>"就是一例。

回頁首

泛型的轉化

在前面的幾部分內容當中，我們介紹了有關泛型的基礎知識，到此讀者對 Java 中的泛型技術應該有了一定的了解，接下來的這部分內容將討論有關泛型的轉化，即如何將帶有泛型的 Java 代碼轉化成一般的沒有泛型 Java 代碼。其實在前面的部分里，我們或多或少地也提到了一些相關的內容，下面再來詳細地介紹一下。

首先需要明確的一點是上面所講的這種轉化過程是由編譯器（例如：Javac）完成的，虛擬機并不負責完成這一任務。當編譯器對帶有泛型的 Java 代碼進行編譯時，它會去執行類型檢查和類型推斷，然后生成普通的不帶泛型的字節碼，這種字節碼可以被一般的Java虛擬機接收并執行，這種技術被稱為擦除（erasure）。

可見，編譯器可以在對源程序（帶有泛型的 Java 代碼）進行編譯時使用泛型類型信息保證類型安全，對大量如果沒有泛型就不會去驗證的類型安全約束進行驗證，同時在生成的字節碼當中，將這些類型信息清除掉。

對于不同的情況，擦除技術所執行的"擦除"動作是不同的，主要分為以下幾種情況：

• 對于參數化類型，需要刪除其中的類型參數，例如，LinkedList<A> 將被"擦除"為 LinkedList；
• 對于非參數化類型，不作擦除，或者說用它自己來擦除自己，例如 String 將被"擦除"為 String；
• 對于類型變量（有關類型變量的說明請參考"泛型概覽"相關內容），要用它們的上限來對它們進行替換。多數情況下這些上限是 Object，但是也有例外，后面的部分將會對此進行介紹。

除此之外，還需要注意的一點是，在某些情況下，擦除技術需要引入類型轉換（cast），這些情況主要包括：

情況 1. 方法的返回類型是類型參數；

情況 2. 在訪問數據域時，域的類型是一個類型參數。

例如在本文"帶有泛型的類"一小節的最后，我們給出了一段測試程序，一個 Test 類。這個類包含以下幾行代碼：

8			LinkedList<String> ys = new LinkedList<String>();
            9			ys.add("zero"); ys.add("one");
            10			String y = ys.iterator().next();
            這部分代碼轉換后就變成了如下的代碼：
            8	       	LinkedList ys = new LinkedList();
            9           ys.add("zero"); ys.add("one");
            10	String y = (String)ys.iterator().next();
            

第 10 行的代碼進行了類型轉換，這是因為在調用 next() 方法時，編譯器發現該方法的返回值類型是類型參數 A（請參見對方法 next() 的定義），因此根據上面提到的情況 1，需要進行類型轉換。

上面介紹了泛型轉化中的擦除技術，接下來，我們討論一下泛型轉化中的另外一個重要問題－－橋方法（bridge method）。

Java 是一種面向對象的語言，因此覆蓋（overridden）是其中的一項重要技術。覆蓋能夠正常"工作"的前提是方法名和方法的參數類型及個數完全匹配（參數的順序也應一致），為了滿足這項要求，編譯器在泛型轉化中引入了橋方法（bridge method）。接下來，我們通過一個例子來分析一下橋方法在泛型轉化中所起的作用。在本文"泛化方法和受限類型參數"一小節所給出的代碼中，第 9 行到第 11 行的程序如下所示：

    9		public int compareTo(Byte that) {
            10			return this.value - that.value;
            11		}
            這部分代碼經過轉化，就變成了下面的樣子：
            9		public int compareTo(Byte that) {
            10			return this.value - that.value;
            11		}
            12  public int compareTo(Object that){
            13			return this.compareTo((Byte)that);
            14		}
            

第 12 行的方法 compareTo(Object that) 就是一個橋方法，在這里引入這個方法是為了保證覆蓋能夠正常的發生。我們在前面提到過，覆蓋必須保證方法名和參數的類型及數目完全匹配，在這里通過引入這個"橋"即可達到這一目的，由這個"橋"進行類型轉換，并調用第 9 行參數類型為 Byte 的方法 compareTo(Byte that)，需要注意的一點是這里的 "Object" 也并不一定是完全匹配的類型，但由于它是 Java 語言中類層次結構的根，所以這里用 "Object" 可以接受其他任何類型的參數。

根據面向對象的基本概念，我們知道，重載（overloading）允許橋方法和原來的方法共享同一個方法名，正如上面例子所顯示的那樣，因此橋方法的引入是完全合法的。一般情況下，當一個類實現了一個參數化的接口或是繼承了一個參數化的類時，需要引入橋方法。

到此，我們對泛型中的子類型，帶有泛型的類，泛化方法，受限類型參數以及泛型的轉化進行了簡要的介紹，下面部分將結合這些技術對前面提到的例子進行一下總結，以便能夠幫助讀者更深刻更全面地理解泛型。

首先來分析一下本文提到的那個 Collection 的例子。這里先是定義了兩個接口 Collection 和 Iterator，然后又定義了一個對接口 Collection 的一個實現 LinkedList。根據上面所介紹的對泛型的轉化過程，這段代碼轉化后的 Java 程序為：

1	interface Collection {
            2	   	public void add (Object x);
            3	        public Iterator iterator ();
            4	}
            5
            6	interface Iterator {
            7	       	public Object next ();
            8	        public boolean hasNext ();
            9	}
            10
            11	class NoSuchElementException extends RuntimeException {}
            12
            13	class LinkedList implements Collection {
            14
            15		protected class Node {
            16	       	Object elt;
            17	        Node next = null;
            18	        Node (Object elt) { this.elt = elt; }
            19		}
            20
            21		protected Node head = null, tail = null;
            22
            23		public LinkedList () {}
            24
            25		public void add (Object elt) {
            26	       	if (head == null) {
            27		       	head = new Node(elt); tail = head;
            28			} else {
            29		       	tail.next = new Node(elt); tail = tail.next;
            30			}
            31		}
            32
            33		public Iterator iterator () {
            34	       	return new Iterator () {
            35		       	protected Node ptr = head;
            36	            public boolean hasNext () { return ptr != null; }
            37		       	public Object next () {
            38			       	if (ptr != null) {
            39				       	Object elt = ptr.elt; ptr = ptr.next; return elt;
            40					} else {
            41				       		throw new NoSuchElementException ();
            42						}
            43				}
            44			};
            45		}
            46	}
            

通過分析上述代碼，我們不難發現，所有參數化類型 Collection, Iterator 和 LinkedList 中的類型參數 "A" 全都被擦除了。另外，剩下的類型變量 "A" 都用其上限進行了替換，這里的上限是 Object，見黑體字標出的部分，這是轉化的關鍵部分。

下面我們分析一下在介紹有關泛化方法（generic method）和受限類型參數（bounded type parameter）時舉的那個例子，該段 GJ 代碼經過轉換后的等價 Java 程序如下所示：

1	interface Comparable {
            2		public int compareTo(Object that);
            3	}
            4
            5	class Byte implements Comparable {
            6		private byte value;
            7		public Byte(byte value) {this.value = value;}
            8		public byte byteValue(){return value;}
            9		public int compareTo(Byte that) {
            10			return this.value - that.value;
            11		}
            12      public int compareTo(Object that){
            13			return this.compareTo((Byte)that);
            14		}
            15	}
            16
            17	class Collections {
            18		public static Comparable max(Collection xs){
            19			Iterator xi = xs.iterator();
            20			Comparable w = (Comparable)xi.next();
            21			while (xi.hasNext()) {
            22				Comparable x = (Comparable)xi.next();
            23				if (w.compareTo(x) < 0) w = x;
            23			}
            24			return w;
            25		}
            26	}
            

同樣請讀者注意黑體字標出的部分，這些關鍵點我們在前面已經介紹過了，故不贅述。唯一需要注意的一點就是第 18，20，22 行出現的Comparable。在泛型轉化中，類型變量應該用其上限來替換，一般情況下這些上限是 "Object"，但是當遇到受限的類型參數時，這個上限就不再是 "Object" 了，編譯器會用限制這些類型參數的類型來替換它，上述代碼就用了對 A 進行限制的類型 "Comparable" 來替換 A。

橋方法的引入，為解決覆蓋問題帶來了方便，但是這種方法還存在一些問題，例如下面這段代碼：

1	interface Iterator<A> {
            2		public boolean hasNext ();
            3		public A next ();
            4	}
            5	class Interval implements Iterator<Integer> {
            6		private int i;
            7		private int n;
            8		public Interval (int l, int u) { i = l; n = u; }
            9		public boolean hasNext () { return (i <= n); }
            10		public Integer next () { return new Integer(i++); }
            11	}
            

根據以上所講的內容，這部分代碼轉換后的 Java 程序應該是如下這個樣子：

1	interface Iterator {
            2
            3		public boolean hasNext ();
            4		public Object next ();
            5
            6	}
            7
            8	class Interval implements Iterator {
            9
            10		private int i;
            11		private int n;
            12		public Interval (int l, int u) { i = l; n = u; }
            13		public boolean hasNext () { return (i <= n); }
            14		public Integer next%1% () { return new Integer(i++); }
            15		// bridge
            16		public Object next%2%() { return next%1%(); }
            17
            18	}
            

相信有些讀者已經發現了這里的問題，這不是一段合法的 Java 源程序，因為第 14 行和第 16 行的兩個 next() 有相同的參數，無法加以區分。代碼中的 %1% 和 %2% 是為了區分而人為加入的，并非 GJ 轉化的結果。

不過，這并不是什么太大的問題，因為 Java 虛擬機可以區分這兩個 next() 方法，也就是說，從 Java 源程序的角度來看，上述程序是不正確的，但是當編譯成字節碼時，JVM 可以對兩個 next() 方法進行識別。這是因為，在 JVM 中，方法定義時所使用的方法簽名包括方法的返回類型，這樣一來，只要 GJ 編譯出的字節碼符合Java字節碼的規范即可，這也正好說明了 GJ 和 JVM 中字節碼規范要求的一致性！

最后，值得一提的是，JDK 5.0 除了在編譯器層面對 Java 中的泛型進行了支持，Java 的類庫為支持泛型也做了相應地調整，例如，集合框架中所有的標準集合接口都進行了泛型化，同時，集合接口的實現也都進行了相應地泛型化。

回頁首

Java 中的泛型與 C++ 模板的比較

GJ 程序的語法在表面上與 C++ 中的模板非常類似，但是二者之間有著本質的區別。

首先，Java 語言中的泛型不能接受基本類型作為類型參數――它只能接受引用類型。這意味著可以定義 List<Integer>，但是不可以定義 List<int>。

其次，在 C++ 模板中，編譯器使用提供的類型參數來擴充模板，因此，為 List<A> 生成的 C++ 代碼不同于為 List<B> 生成的代碼，List<A> 和 List<B> 實際上是兩個不同的類。而 Java 中的泛型則以不同的方式實現，編譯器僅僅對這些類型參數進行擦除和替換。類型 ArrayList<Integer> 和 ArrayList<String> 的對象共享相同的類，并且只存在一個 ArrayList 類。

回頁首

總結

本文通過一些示例從基本原理，重要概念，關鍵技術，以及相似技術比較等多個角度對 Java 語言中的泛型技術進行了介紹，希望這種介紹方法能夠幫助讀者更好地理解和使用泛型。本文主要針對廣大的 Java 語言使用者，在介紹了泛型的基本概念后，重點介紹了比較底層的泛型轉化技術，旨在幫助讀者更加深刻地掌握泛型，筆者相信這部分內容可以使讀者避免對泛型理解的表面化，也所謂知其然更知其所以然。

參考資料

• 診斷 Java 代碼: 輕松掌握 Java 泛型（developerWorks，2003 年 5 月）：在本文當中，Eric Allen 通過描述諸如基本類型限制和多態方法等特性來說明泛型的優缺點。
  
  
• Java 理論和實踐: 了解泛型（developerWorks，2005 年 1 月）：在本文當中，Brian Goetz 通過示例分析了剛剛接觸泛型的新用戶常犯的錯誤，從反面給用戶以警示。
  
  
• 介紹 JDK 5.0 中的泛型（developerWorks，2004 年 12 月）：一篇關于 JDK 5.0 中的泛型的教程，該教程解釋了在 Java 語言中引入泛型的動機，詳細介紹了泛型的語法和語義，并講述了如何在自己的類中使用泛型。
  
  
• 馴服 Tiger系列專欄：詳細地討論有關 Java SE 5 平臺的改變，并提供一些例子作為快速參考。
  
  
• Java 理論與實踐系列專欄：探索設計模式，可靠軟件設計原則，以及應用于實際問題的“最佳實踐”。
  
  
• GJ: Extending the Java programming language with type parameters：Gilad Bracha, Martin Odersky 等人寫的一篇介紹 GJ 基本概念的文章。
  
  
• Generics in the Java Programming Language：Gilad Bracha 寫的一篇詳細介紹 JDK 5.0 中的泛型的文章。

關于作者

		周晶，2006年4月畢業于北京航空航天大學計算機學院，獲計算機碩士學位。主要研究領域為高級編譯技術，Java虛擬機技術。 beyond.zhou@gmail.com

posted @ 2009-12-14 22:52 ammay 閱讀(203) | 評論 (0) | 編輯 收藏

泛型

Jdk1.5中的新特性 --泛型 (詳細版)

本來只轉載了個鏈接，和一個簡單的使用程序，但昨天不小心看到有人批判jdk1.5，先說java要強制轉型不好的問題沒解決，
容器不能放基類型不好，接著說泛型沒用。而恰恰Jdk1.5中解決了這些問題，所以感嘆之余，把這篇文章改一下，詳細的說說泛型。

一，Java中的泛型：
在Java中能使用到泛型的多是容器類,如各種list map set，因為Java是單根繼承，所以容器里邊可以放的
內容是任何Object，所以從意義上講原本的設計才是泛型。但用過Java的人是否感覺每次轉型很麻煩呢？
而且會有些錯誤，比如一個容器內放入了異質對象，強制轉型的時候會出現cast異常。而這中錯誤在編譯器是
無從發現的。所以jdk1.5中提供了泛型，這個泛型其實是向c++靠攏了.好，我們先看幾個實例再細說原理。

二，泛型的用法:(多個實例)

1 實例A
2 ArrayList < String >  strList  =   new  ArrayList < String > ();
3 strList.add( " 1 " );
4 strList.add( " 2 " );
5 strList.add( " 3 " );
6 // 關鍵點（1） 注意下邊這行，沒有強制轉型
7 String str  =  strList.get( 1 );
8 // 關鍵點（2）然後我們加入，這個時候你會發現編譯器報錯，錯誤在編譯器被發現，錯誤當然是發現的越早越好
9 strList.add( new  Object());

1 實例B
2 ArrayList < Integer >  iList  =   new  ArrayList < Integer > ();
3 // 關鍵點（3） 注意直接把整數放入了集合中，而沒有用Integer包裹
4 iList.add( 1 );
5 iList.add( 2 );
6 iList.add( 3 );
7 // 關鍵點（4）同樣直接取出就是int
8 int  num  =  iList.get( 1 );

1 實例C
2 // 關鍵點（5）展示一下key-value的時候要怎么寫，同時key和value也可以是基本類型了。
3 HashMap < Integer,Integer >  map  =   new  HashMap < Integer,Integer > ();
4 map.put( 1 ,  11 );
5 map.put( 2 ,  22 );
6 map.put( 3 ,  33 );
7 int  inum  =  map.get( 1 );
8

三，看完了實例了，詳細來說說為什么吧
首先jdk1.5中的泛型，第一個解決的問題，就是Java中很多不必要的強制轉型了，具體的實現,我們以ArrayList
為例,下邊是ArrayList中的片斷代碼:

 1ArrayList類的定義，這里加入了<E>
 2public class ArrayList<E> extends AbstractList<E>
 3        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
 4
 5//get方法,返回不再是Object 而是E
 6public E get(int index) {
 7    RangeCheck(index);
 8    return elementData[index];
 9}
10//add方法,參數不再是Object 而是E
11public boolean add(E o) {
12    ensureCapacity(size + 1);  // Increments modCount!!
13    elementData[size++] = o;
14    return true;
15}
16

四，Boxing 和UnBoxing
看到上邊的關鍵點（3）和（4）是否感覺驚奇呢，因為Java中煩人的除了強制轉型，另一個就是基礎類型了
放入容器的時候要包裝，取出了還要轉回。Jdk1.5中解決了這個問題.如上邊的使用方法

五，泛型的生命周期（使用注意事項）
如果我們試著把ArrayList<String> list的內容序列化，然後再讀取出來，在使用的過程中會發現出錯，
為什么呢？用Stream讀取一下回來的數據，你會發現<String>不見了，list變成了普通的ArrayList，而不是
參數化型別的ArrayList了，為什么會這樣呢 ？見下邊的比較

六，C++的泛型和Java的泛型
在泛型的實現上，C++和Java有著很大的不同，
Java是擦拭法實現的
C++是膨脹法實現的
因為Java原本實現就是泛型的，現在加入型別，其實是"窄化",所以采用擦拭法，在實現上，其實是封裝了原本的
ArrayList,這樣的話，對于下邊這些情況，Java的實現類只有一個。

1ArrayList<Integer>  .;   public class ArrayList
2ArrayList<String>  ..;   --同上--
3ArrayList<Double>  ..;   --同上--
4而C++采用的是膨脹法,對于上邊的三種情況實際是每一種型別都對應一個實現，實現類有多個
5list<int> li;                class list; //int 版本
6list<string> ls;             class list; //string 版本
7list<double> ld;             class list; //double 版本    

這就造成了，在序列化后，Java不能分清楚原來的ArrayList是
ArrayList<Integer>還是ArrayList

七，題外話，在很多東西的實現上C++和Java有很多不同
例如運算符的問題i=i++問題，詳細看這里
例如在C++中能很好實現的double-checked locking單態模式，在Java中幾乎很難實現 詳細看這里
還有就是上邊提到的泛型實現上。

八，Jdk 1.5加入了不少新東西，有些能很大的提高開發質量，例如Jdk1.4 ，Jdk.15中StringBuffer的不同
因為從1。4轉入1。5不久，所以慢慢會發一些在1。5的使用過程中發現的東西。

最后，我們還可以自己寫類似ArrayList這樣的泛型類，至于如何自定義泛型類，泛型方法請參見候捷先生的文章

posted @ 2009-12-14 22:51 ammay 閱讀(185) | 評論 (0) | 編輯 收藏

xquery

posted @ 2009-12-03 22:43 ammay 閱讀(191) | 評論 (0) | 編輯 收藏

mysql triger

posted @ 2009-11-26 22:56 ammay 閱讀(183) | 評論 (0) | 編輯 收藏

mysql 觸發器

我們在MySQL 5.0中包含對觸發器的支持是由于以下原因:
MySQL早期版本的用戶長期有需要觸發器的要求。
我們曾經許諾支持所有ANSI標準的特性。
您可以使用它來檢查或預防壞的數據進入數據庫。
您可以改變或者取消INSERT, UPDATE以及DELETE語句。
您可以在一個會話中監視數據改變的動作。在這里我假定大家都讀過"MySQL新特性"叢書的第一集--"MySQL存儲過程"，那么大家都應該知道MySQL至此存儲過程和函數，那是很重要的知識，因為在觸發器中你可以使用在函數中使用的語句。特別舉個例子：
復合語句(BEGIN / END)是合法的.
流控制（Flow-of-control）語句(IF, CASE, WHILE, LOOP, WHILE, REPEAT, LEAVE,ITERATE)也是合法的.
變量聲明(DECLARE)以及指派(SET)是合法的.
允許條件聲明.
異常處理聲明也是允許的.
但是在這里要記住函數有受限條件:不能在函數中訪問表.

因此在函數中使用以下語句是非法的。
ALTER 'CACHE INDEX' CALL COMMIT CREATE DELETE
DROP 'FLUSH PRIVILEGES' GRANT INSERT KILL
LOCK OPTIMIZE REPAIR REPLACE REVOKE
ROLLBACK SAVEPOINT 'SELECT FROM table'
'SET system variable' 'SET TRANSACTION'
SHOW 'START TRANSACTION' TRUNCATE UPDATE

在觸發器中也有完全一樣的限制.觸發器相對而言比較新，因此會有（bugs）缺陷.所以我在這里給大家警告，就像我在存儲過程書中所說那樣.不要在含有重要數據的數據庫中使用這個觸發器，如果需要的話在一些以測試為目的的數據庫上使用，同時在你對表創建觸發器時確認這些數據庫是默認的。

語法
1. 語法：命名規則

CREATE TRIGGER <觸發器名稱> <--
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE }
ON <表名稱>
FOR EACH ROW
<觸發器SQL語句>
觸發器必須有名字，最多64個字符，可能后面會附有分隔符.它和MySQL中其他對象的命名方式基本相象.

這里我有個習慣：就是用表的名字＋'_'＋觸發器類型的縮寫.因此如果是表t26，觸發器是在事件UPDATE（參考下面的點（2）和（3））之前（BEFORE）的，那么它的名字就是t26_bu。
2. 語法：觸發時間

CREATE TRIGGER <觸發器名稱>
{ BEFORE | AFTER } <--
{ INSERT | UPDATE | DELETE }
ON <表名稱>
FOR EACH ROW
<觸發的SQL語句>

觸發器有執行的時間設置：可以設置為事件發生前或后。

3. 語法：事件

CREATE TRIGGER <觸發器名稱>
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE } <--
ON <表名稱>
FOR EACH ROW
<觸發的SQL語句>

同樣也能設定觸發的事件：它們可以在執行insert、update或delete的過程中觸發。
4. 語法：表

CREATE TRIGGER <觸發器名稱>
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE }
ON <表名稱> <--
FOR EACH ROW
<觸發的SQL語句>

觸發器是屬于某一個表的:當在這個表上執行插入、
更新或刪除操作的時候就導致觸發器的激活.
我們不能給同一張表的同一個事件安排兩個觸發器。

5. 語法：（ 步長）觸發間隔

CREATE TRIGGER <觸發器名稱>
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE }
ON <表名稱>
FOR EACH ROW <--
<觸發的SQL語句>

觸發器的執行間隔：FOR EACH ROW子句通知觸發器
每隔一行執行一次動作，而不是對整個表執行一次。

6. 語法：語句

CREATE TRIGGER <觸發器名稱>
{ BEFORE | AFTER }
{ INSERT | UPDATE | DELETE }
ON <表名稱>
FOR EACH ROW
<觸發的SQL語句> <--

觸發器包含所要觸發的SQL語句：這里的語句可以是任何合法的語句，
包括復合語句，但是這里的語句受的限制和函數的一樣。
Privileges權限

你必須擁有相當大的權限才能創建觸發器（CREATE TRIGGER）。
如果你已經是Root用戶，那么就足夠了。這跟SQL的標準有所不同。

因此在下一個版本的MySQL中，
你完全有可能看到有一種叫做CREATE TRIGGER的新權限。
然后通過這樣的方法賦予：
GRANT CREATE TRIGGER ON <表名稱> TO <用戶或用戶列表>;
也可以通過這樣收回權限：
REVOKE CREATE TRIGGER ON <表名稱> FROM <用戶或用戶列表>;
關于舊的和新創建的列的標識

在觸發器的SQL語句中，你可以關聯表中的任意列。但你不能僅使用列的名稱去標識，那會使系統混淆，因為那里可能會有列的新名（這可能正是你要修改的，你的動作可能正是要修改列名），還有列的舊名存在。因此你必須用這樣的語法來標識： "NEW . column_name"或者"OLD . column_name".這樣在技術上處理（NEW | OLD . column_name）新和舊的列名屬于創建了過渡變量（"transition variables"）。

對于INSERT語句,只有NEW是合法的；對于DELETE語句，只有OLD才合法；而UPDATE語句可以在和NEW以及OLD同時使用。下面是一個UPDATE中同時使用NEW和OLD的例子。
CREATE TRIGGER t21_au
BEFORE UPDATE ON t22
FOR EACH ROW
BEGIN
SET @old = OLD . s1;
SET @new = NEW.s1;
END;//

現在如果t21表中的s1列的值是55，那么執行了
"UPDATE t21 SET s1 = s1 + 1"之后@old的值會變成55，
而@new的值將會變成56。Example of CREATE and INSERT CREATE和INSERT的例子
創建有觸發器的表
這里所有的例程中我都假定大家的分隔符已經設置成//（DELIMITER //）。
CREATE TABLE t22 (s1 INTEGER)//
CREATE TRIGGER t22_bi
BEFORE INSERT ON t22
FOR EACH ROW
BEGIN
SET @x = 'Trigger was activated!';
SET NEW.s1 = 55;
END;//
在最開始我創建了一個名字為t22的表，然后在表t22上創建了一個觸發器t22_bi，當我們要向表中的行插入時，觸發器就會被激活，執行將s1列的值改為55的動作。

使用觸發器執行插入動作

mysql> INSERT INTO t22 VALUES (1)//

讓我們看如果向表t2中插入一行數據觸發器對應的表會怎么樣？ 這里的插入的動作是很常見的，我們不需要觸發器的權限來執行它。甚至不需要知道是否有觸發器關聯。
mysql> SELECT @x, t22.* FROM t22//
+------------------------+------+
| @x | s1 |
+------------------------+------+
| Trigger was activated! | 55 |
+------------------------+------+
1 row in set (0.00 sec)
大家可以看到INSERT動作之后的結果，和我們預期的一樣，x標記被改動了，同時這里插入的數據不是我們開始輸入的插入數據，而是觸發器自己的數據。
"check"完整性約束例子
什么是"check"約束
在標準的SQL語言中，我們可以在（CREATE TABLE）創建表的過程中使用"CHECK (condition)"，
例如：
CREATE TABLE t25
(s1 INT, s2 CHAR(5), PRIMARY KEY (s1),
CHECK (LEFT(s2,1)='A'))
ENGINE=INNODB;
這里CHECK的意思是"當s2列的最左邊的字符不是'A'時，insert和update語句都會非法"，MySQL的視圖不支持CHECK，我個人是很希望它能支持的。但如果你很需要在表中使用這樣的功能，我建議大家使用觸發器來實現。
CREATE TABLE t25
(s1 INT, s2 CHAR(5),
PRIMARY KEY (s1))
ENGINE=INNODB//

CREATE TRIGGER t25_bi
BEFORE INSERT ON t25
FOR EACH ROW
IF LEFT(NEW.s2,1)<>'A' THEN SET NEW.s1=0; END IF;//

CREATE TRIGGER t25_bu
BEFORE UPDATE ON t25
FOR EACH ROW
IF LEFT(NEW.s2,1)<>'A' THEN SET NEW.s1=0; END IF;//
我只需要使用BEFORE INSERT和BEFORE UPDATE語句就行了，刪除了觸發器不會對表有影響，同時AFTER的觸發器也不能修改NEW的過程變量（transition variables）。為了激活觸發器，我執行了向表中的行插入s1＝0的數據，之后只要執行符合LEFT(s2,1) <> 'A'條件的動作都會失?。?
INSERT INTO t25 VALUES (0,'a') /* priming the pump */ //
INSERT INTO t25 VALUES (5,'b') /* gets error '23000' */ //
Don't Believe The Old MySQL Manual

本文來自CSDN博客，轉載請標明出處：http://blog.csdn.net/crazy_rain/archive/2007/07/05/1680128.aspx

posted @ 2009-11-26 22:31 ammay 閱讀(283) | 評論 (0) | 編輯 收藏

ant工程配置

終于把ANT搞定了，現在發布一個通用的ANT的build.xml文件，以備后用。

Java代碼

1. <project name="hnwt114" default="build" basedir=".">   
2.     <!-- 工程根目錄 -->   
3.     <property name="hnwt144.home" value="."/>   
4.     <!-- 工程根名 -->   
5.     <property name="hnwt144.name" value="HNWT114"/>   
6.     <!-- tomcat路徑 -->   
7.     <property name="tomcat.home" value="D:\apache-tomcat-5.5.26"/>   
8.     <!-- tomcat部署路徑 -->   
9.     <property name="webapps.home" value="${tomcat.home}/webapps"/>   
10.     <!-- JAVA源文件路徑 -->   
11.     <property name="src.home" value="${hnwt144.home}/src"/>   
12.        
13.     <!-- class文件存放位置 -->   
14.     <property name="classes.home" value="${hnwt144.home}/classes"/>   
15.     <!-- 發布文件夾 -->   
16.     <property name="deploy.home" value="${hnwt144.home}/deploy"/>   
17.     <!-- webRoot路徑 -->   
18.     <property name="web.home" value="${hnwt144.home}/webRoot"/>   
19.        
20.     <!-- 創建工程路徑 -->   
21.     <property name="build.home" value="${hnwt144.home}/build"/>   
22.     <!-- /WEB-INF/classes -->   
23.     <property name="build.classes" value="${hnwt144.home}/WEB-INF/classes"/>   
24.     <!-- /WEB-INF/lib -->   
25.     <property name="build.lib" value="${hnwt144.home}/WEB-INF/lib"/>   
26.     <!-- 工程引用包 -->   
27.     <property name="lib.home" value="${web.home}/WEB-INF/lib"/>   
28.        
29.        
30.     <!-- 編譯工程所需的JAR包 -->   
31.     <path id="compile.classpath">   
32.         <pathelement location="${classes.home}"/>   
33.         <fileset dir="${lib.home}">   
34.                 <include name="*.jar"/>   
35.                 <include name="*.zip"/>   
36.         </fileset>   
37.         <fileset dir="${tomcat.home}/common/lib">   
38.             <include name="*.jar"/>   
39.         </fileset>   
40.         <pathelement location="${tomcat.home}/common/classes"/>   
41.     </path>   
42.        
43.        
44.     <!-- 測試ANT -->   
45.     <target name="help">   
46.         <echo message="Please specify a target![usage:ant&lt;targetname&gt;]"/>   
47.         <echo message="Here is a list of possible targets:"/>   
48.         <echo message="  clean-all....Delete build dir,all .class and war files"/>   
49.         <echo message="  perpare....Creates directories if requied"/>   
50.         <echo message="  compile....Compiles source files"/>   
51.         <echo message="  build......Build war file from.class and other files"/>   
52.         <echo message="  deploy......Copy war file to the webapps directory"/>   
53.     </target>   
54.        
55.        
56.     <!-- 清除 -->   
57.     <target name="clean-all">   
58.         <delete dir="${build.home}"/>   
59.         <delete dir="${classes.home}"/>   
60.         <delete dir="${deploy.home}"/>   
61.            
62.         <delete dir="${webapps.home}/${hnwt114.home}" failonerror="false"/>   
63.         <delete dir="${webapps.home}/${hnwt114.name}.war"/>   
64.     </target>   
65.        
66.        
67.     <!-- 準備工作 -->   
68.     <target name="prepare">   
69.         <echo message="Tomcat Home=${tomcat.home}"/>   
70.         <echo message="Webapps Home=${webapps.home}"/>   
71.            
72.         <mkdir dir="${classes.home}"/>   
73.         <mkdir dir="${deploy.home}"/>        
74.            
75.         <mkdir dir="${build.home}"/>   
76.         <mkdir dir="${build.home}/WEB-INF"/>   
77.         <mkdir dir="${build.home}/WEB-INF/classes"/>   
78.         <mkdir dir="${build.home}/WEB-INF/lib"/>   
79.     </target>   
80.        
81.        
82.     <!-- 編譯 -->   
83.     <target name="compile" depends="prepare">   
84.         <javac srcdir="${src.home}" destdir="${classes.home}" debug="no">   
85.             <classpath refid="compile.classpath"/>   
86.         </javac>   
87.     </target>   
88.        
89.     <!-- 構建臨時工程 -->   
90.     <target name="build" depends="compile">   
91.         <copy todir="${build.home}">   
92.             <fileset dir="${web.home}"/>   
93.         </copy>   
94.         <copy todir="${build.home}/WEB-INF/classes">   
95.             <fileset dir="${classes.home}"/>   
96.         </copy>   
97.            
98.         <copy todir="${build.home}/WEB-INF/classes">   
99.             <fileset dir="${src.home}">   
100.                 <include name="**/*.properties"/>   
101.                 <include name="**/*.prop"/>   
102.             </fileset>   
103.         </copy>   
104.            
105.         <jar jarfile="${deploy.home}/${hnwt144.name}.war" basedir="${build.home}"/>   
106.     </target>   
107.     <!-- 發布 -->   
108.     <target name="deploy" depends="build">   
109.         <copy todir="${webapps.home}" file="${deploy.home}/${hnwt144.name}.war"/>   
110.     </target>   
111.            
112.     </project>  

posted @ 2009-11-19 21:16 ammay 閱讀(322) | 評論 (0) | 編輯 收藏

ant 的使用說明

>>>>>>>>>>>聲明
1.目的是學習，備忘，共享。個人表達能力有限，看不懂，表達錯誤的，見諒
>>>>>>>>>>>ant是什么
1.專業一點說是構建工具，是協助開發人員管理工程的工具
2.通俗一點說是懶人工具，幫助我們做一些重復的勞動
3.舉個例子：發布一個web工程，你會如何做
a.將web工程打包
b.停止web工程
c.上傳web工程
d.重啟web工程
　通常，你可能會用IDE打包，然后登陸到服務器，把WEB工程shutdown，再用上傳工具傳war包，然后再重啟
　有了ant，你不用這么累了，運行一個build.xml就OK。

>>>>>>>>>>ant的特點
1.跨平臺，因為用JAVA寫的
2.功能強大(這是一個口號)，擴展性比較好(這倒是實話，但代價是你得找支持的jar包)
3.上手容易，因為語法簡單

>>>>>>>>>>ant的應用,eclipse下
1.傳說牛人都不用IDE，我用eclipse，這玩意兒還是免費的，真棒。
2.exlipse3.0以后應該都內嵌ant，找找看：$eclipse\plugins\org.apache.ant_1.6.5

3.新建工程，工程根目錄下新建build.xml
4.試試好不用，運行一下

Java代碼

1. <?xml version="1.0" encoding="UTF-8"?>   
2. <project name="WebTest" basedir="E:\work_ccats2\WebTest" default="main">   
3. <target name="main" depends="test" description="Main target">   
4. </target>   
5. <target name="test" description="test">   
6.     <echo> task start </echo>   
7. </target>   
8. </project>  

	<?xml version="1.0" encoding="UTF-8"?>
<project name="WebTest" basedir="E:\work_ccats2\WebTest" default="main">
<target name="main" depends="test" description="Main target">
</target>
<target name="test" description="test">
<echo> task start </echo>
</target>
</project>

5.ftp功能：
a.下載commons-net-1.4.0.jar jakarta-oro-2.0.8.jar NetComponents.jar optional.jar
b.上面這些jar，如果你的ant或jdk版本高，有的沒有，但如果不是，勸你都下
c.eclipse下: Window->Preferance->Ant->Runtime->Ant Home Entries->自己加上jar

6.ssh:
a.下載jsch-0.1.41.jar
b.后面同[5]

7.給一個build.xml樣例

Java代碼

1. <?xml version="1.0" encoding="UTF-8"?>   
2. <project name="WebTest" basedir="E:\work_ccats2\WebTest" default="main">   
3.     <target name="main" depends="taskover" description="Main target">   
4.     </target>   
5.        
6.     <!-- ***************************變量定義開始************************* -->   
7.     <!--工程名稱-->   
8.     <property name="project.name" value="WebTest"/>   
9.     <!--打包war文件存放的位置-->   
10.     <property name="war.dir" location="E:\war"/>   
11.     <!--服務器IP-->   
12.     <property name="hostIP" value="10.4.116.212" />   
13.     <!--服務器OS帳戶-->   
14.     <property name="userID" value="esb" />   
15.     <!--服務器OS密碼-->   
16.     <property name="password" value="esb" />   
17.     <!--服務器tomcat路徑-->   
18.     <property name="hostHome" value="/home/esb" />   
19.     <!-- *************************變量定義結束************************* -->   
20.        
21.     <!--　測試 -->   
22.     <target name="test" description="test">   
23.         <echo> task start </echo>   
24.     </target>   
25.     <!--　打包war文件 -->   
26.     <target name="pgWar" depends="test" description="Package application as a war">   
27.         <mkdir dir="${war.dir}" />   
28.         <war destfile="${war.dir}/${project.name}.war" webxml="web.xml">   
29.             <fileset dir="${basedir}">   
30.             </fileset>   
31.         </war>   
32.     </target>   
33.        
34.        
35.     <target name="remote-tomcat-stop" depends="pgWar" >   
36.             <sshexec host="${hostIP}" username="${userID}"  password="${password}"    
37.                 command="ps -ef|grep tomcat55|grep -v grep |awk '{print $2}'|xargs -n1 kill -9;ls;rm -rf /home/esb/tomcat55/webapps/WebTest*"    
38.                 trust="true" />   
39.             <sleep seconds="5"/>   
40.     </target>   
41.        
42.     <!-- 上傳文件-->   
43.     <target name="uploadFile" depends="remote-tomcat-stop" >   
44.         <ftp server="${hostIP}" remotedir="${hostHome}/tomcat55/webapps" userid="${userID}"    
45.             password="${password}" depends="yes" >   
46.             <fileset dir="${war.dir}">   
47.                 <include name="**/*.war"/>   
48.             </fileset>   
49.         </ftp>   
50.     </target>   
51.        
52.     <!-- 遠程重啟tomcat-->   
53.         <target name="remote-tomcat-start" depends="uploadFile" >   
54.             <sshexec host="${hostIP}" username="${userID}"  password="${password}"    
55.                 command="cd /home/esb/tomcat55/bin;JAVA_HOME=/home/esb/jdk1.5/jdk1.5.0_06 export JAVA_HOME;nohup sh startup.sh;ls"    
56.                 trust="true" />   
57.             <sleep seconds="5"/>   
58.         </target>   
59.            
60.         <target name="taskover" depends="remote-tomcat-start" >   
61.             <echo> task over </echo>   
62.         </target>   
63.        
64. </project>  

<?xml version="1.0" encoding="UTF-8"?>
<project name="WebTest" basedir="E:\work_ccats2\WebTest" default="main">
<target name="main" depends="taskover" description="Main target">
</target>
<!-- ***************************變量定義開始************************* -->
<!--工程名稱-->
<property name="project.name" value="WebTest"/>
<!--打包war文件存放的位置-->
<property name="war.dir" location="E:\war"/>
<!--服務器IP-->
<property name="hostIP" value="10.4.116.212" />
<!--服務器OS帳戶-->
<property name="userID" value="esb" />
<!--服務器OS密碼-->
<property name="password" value="esb" />
<!--服務器tomcat路徑-->
<property name="hostHome" value="/home/esb" />
<!-- *************************變量定義結束************************* -->
<!--　測試 -->
<target name="test" description="test">
<echo> task start </echo>
</target>
<!--　打包war文件 -->
<target name="pgWar" depends="test" description="Package application as a war">
<mkdir dir="${war.dir}" />
<war destfile="${war.dir}/${project.name}.war" webxml="web.xml">
<fileset dir="${basedir}">
</fileset>
</war>
</target>
<target name="remote-tomcat-stop" depends="pgWar" >
<sshexec host="${hostIP}" username="${userID}"  password="${password}"
command="ps -ef|grep tomcat55|grep -v grep |awk '{print $2}'|xargs -n1 kill -9;ls;rm -rf /home/esb/tomcat55/webapps/WebTest*"
trust="true" />
<sleep seconds="5"/>
</target>
<!-- 上傳文件-->
<target name="uploadFile" depends="remote-tomcat-stop" >
<ftp server="${hostIP}" remotedir="${hostHome}/tomcat55/webapps" userid="${userID}"
password="${password}" depends="yes" >
<fileset dir="${war.dir}">
<include name="**/*.war"/>
</fileset>
</ftp>
</target>
<!-- 遠程重啟tomcat-->
<target name="remote-tomcat-start" depends="uploadFile" >
<sshexec host="${hostIP}" username="${userID}"  password="${password}"
command="cd /home/esb/tomcat55/bin;JAVA_HOME=/home/esb/jdk1.5/jdk1.5.0_06 export JAVA_HOME;nohup sh startup.sh;ls"
trust="true" />
<sleep seconds="5"/>
</target>
<target name="taskover" depends="remote-tomcat-start" >
<echo> task over </echo>
</target>
</project>

>>>>>>>>>>>>>命令行下的ant應用
1.環境變量設一下
ANT_HOME= $ant路徑
PATH = %ANT_HOME%;%ANT_HOME%\bin

2.測試
輸入ant，看有反應沒

posted @ 2009-11-19 21:09 ammay 閱讀(599) | 評論 (0) | 編輯 收藏