如何為每一個錯誤消息顯示一個圖片

使用CSS style來實現該功能.例如,你有如下的代碼來顯示消息:

<div align="center">
 <h:messages id="errMsgs" styleClass="errorFeedback" layout="table" />
</div>

??errorFeedback style class 可能是下面的代碼:

.errorFeedback {
 color: black;
 vertical-align: middle;
 background-image: url(/AccountSetup/images/warning_feedback.gif);
 background-repeat: no-repeat;
 background-position: left top;
 font-family: Verdana, Arial, Helvetica, sans-serif;
 font-weight: bold;
 line-height: 18px;
 font-size: 10pt;
 text-align: left;
 text-indent: 22px;}

(轉) 從 Filter和Servlet中如何訪問FacesContext?

?

J2EE 全面簡介(轉載)

from:http://www.javaeye.com/topic/9706

數據庫對象的緩存策略

前言
本文探討Jive(曾經開源的Java論壇)和Hibernate（Java開源持久層）的數據庫對象的緩存策略，并闡述作者本人的Lightor（Java開源持久層）采用的數據庫對象緩存策略。
本文的探討基于以前開源的Jive代碼，Hibernate2.1.7源碼，和作者本人的Lightor代碼。
本文用ID (Identifier的縮寫)來代表數據記錄的關鍵字。
數據對象查詢一般分為兩種：條件查詢，返回一個滿足條件的數據對象列表； ID查詢，返回ID對應的數據對象。
本文主要探討“條件查詢”和“ID查詢”這兩種情況的緩存策略。
本文只探討一個JVM內的數據緩存策略，不涉及分布式緩存；本文只探討對應單表的數據對象的緩存，不涉及關聯表對象的情況。

一、Jive的緩存策略
1．Jive的緩存策略的過程描述：
(1)條件查詢的時候，Jive用 select id from table_name where …. （只選擇ID字段）這樣的SQL語句查詢數據庫，來獲得一個ID列表。
(2) Jive根據ID列表中的每個ID，首先查看緩存中是否存在對應ID的數據對象：如果存在，那么直接取出，加入到 結果列表中；如果不存在，那么通過一條select * from table_name where id = {ID value} 這樣的SQL查詢數據庫，取出對應的數據對象，放入到結果列表，并把這個數據對象按照ID放入到緩存中。
(3) ID查詢的時候，Jive執行類似第(2)步的過程，先從緩存中查找該ID，查不到，再查詢數據庫，然后把結果放入到緩存。
(4) 刪除、更新、增加數據的時候，同時更新緩存。
2．Jive緩存策略的優點：
(1) ID查詢的時候，如果該ID已經存在于緩存中，那么可以直接取出。節省了一條數據庫查詢。
(2) 當多次條件查詢的結果集相交的情況下，交集里面的數據對象不用重復從數據庫整個獲取，直接從緩存中獲取即可。
比如，第一次查詢的ID列表為{1, 2}，然后根據ID列表的ID從數據庫中一個一個取出數據對象，結果集為{a(id = 1), b(id = 2)}。
下一次查詢的ID列表為{2, 3}，由于ID = 2的數據對象已經存在于緩存中，那么只要從數據庫中取出ID = 3的數據對象即可。
3．Jive緩存策略的缺點：
(1) 在根據條件查找數據對象列表的過程中，DAO的第(1)步用來獲得ID列表的那一次數據庫查詢，是必不可少的。
(2) 如果第(1)步返回的ID列表中有n個ID，在最壞的命中率（緩存中一個對應ID都沒有）情況下，Jive還要再查詢n次數據庫。最壞情況下，共需要n + 1數據庫查詢。

二、Hibernate的二級緩存策略
Hibernate用Session類包裝了數據庫連接從打開到關閉的過程。
Session內部維護一個數據對象集合，包括了本Session內選取的、操作的數據對象。這稱為Session內部緩存，是Hibernate的第一級最快緩存，屬于Hibernate的既定行為，不需要進行配置(也沒有辦法配置 :-)。
Session的生命期很短，存在于Session內部的第一級最快緩存的生命期當然也很短，命中率自然也很低。當然，這個Session內部緩存的主要作用是保持Session內部數據狀態同步。
如果需要跨Session的命中率較高的全局緩存，那么必須對Hibernate進行二級緩存配置。一般來說，同樣數據類型（Class）的數據對象，共用一個二級緩存（或其中的同一塊）。
1．Hibernate二級緩存策略的過程描述：
(1)條件查詢的時候，總是發出一條select * from table_name where …. （選擇所有字段）這樣的SQL語句查詢數據庫，一次獲得所有的數據對象。
(2) 把獲得的所有數據對象根據ID放入到第二級緩存中。
(3) 當Hibernate根據ID訪問數據對象的時候，首先從Session一級緩存中查；查不到，如果配置了二級緩存，那么從二級緩存中查；查不到，再查詢數據庫，把結果按照ID放入到緩存。
(4) 刪除、更新、增加數據的時候，同時更新緩存。

2．Hibernate二級緩存策略的優點：
(1) 具有Jive緩存策略同樣的第(1)條優點：ID查詢的時候，如果該ID已經存在于緩存中，那么可以直接取出。節省了一條數據庫查詢。
(2) 不具有Jive緩存策略的第(2)條缺點，即hibernate不會有最壞情況下的 n + 1次數據庫查詢。
3．Hibernate二級緩存策略的缺點：
(1) 同Jive緩存策略的第(1)條缺點一樣，條件查詢的時候，第(1)步的數據庫查詢語句是不可少的。而且Hibernate選擇所有的字段，比只選擇ID字段花費的時間和空間都多。
(2) 不具備Jive緩存策略的第(2)條優點。條件查詢的時候，必須把數據庫對象從數據庫中整個取出，即使該數據庫的ID已經存在于緩存中。

三、Hibernate的Query緩存策略
可以看到，Jive緩存和Hibernate的二級緩存策略，都只是針對于ID查詢的緩存策略，對于條件查詢則毫無作用。（盡管Jive緩存的第(2)個優點，能夠避免重復從數據庫獲取同一個ID對應的數據對象，但select id from …這條數據庫查詢是每次條件查詢都必不可少的）。
為此，Hibernate提供了針對條件查詢的Query緩存。
1．Hibernate的Query緩存策略的過程描述：
(1) 條件查詢的請求一般都包括如下信息：SQL, SQL需要的參數，記錄范圍（起始位置rowStart，最大記錄個數maxRows)，等。
(2) Hibernate首先根據這些信息組成一個Query Key，根據這個Query Key到Query緩存中查找對應的結果列表。如果存在，那么返回這個結果列表；如果不存在，查詢數據庫，獲取結果列表，把整個結果列表根據Query Key放入到Query緩存中。
(3) Query Key中的SQL涉及到一些表名，如果這些表的任何數據發生修改、刪除、增加等操作，這些相關的Query Key都要從緩存中清空。
2．Hibernate的Query緩存策略的優點
(1) 條件查詢的時候，如果Query Key已經存在于緩存，那么不需要再查詢數據庫。命中的情況下，一次數據庫查詢也不需要。
3．Hibernate的Query緩存策略的缺點
(1) 條件查詢涉及到的表中，如果有任何一條記錄增加、刪除、或改變，那么緩存中所有和該表相關的Query Key都會失效。
比如，有這樣幾組Query Key，它們的SQL里面都包括table1。
SQL = select * from table1 where c1 = ? …., parameter = 1, rowStart = 11, maxRows = 20.
SQL = select * from table1 where c1 = ? …., parameter = 1, rowStart = 21, maxRows = 20.
SQL = select * from table1 where c1 = ? ….., parameter = 2, rowStart = 11, maxRows = 20.
SQL = select * from table1 where c1 = ? ….., parameter = 2, rowStart = 11, maxRows = 20.
SQL = select * from table1 where c2 = ? …., parameter = ‘abc’, rowStart = 11, maxRows = 20.

當table1的任何數據對象（任何字段）改變、增加、刪除的時候，這些Query Key對應的結果集都不能保證沒有發生變化。
很難做到根據數據對象的改動精確判斷哪些Query Key對應的結果集受到影響。最簡單的實現方法，就是清空所有SQL包含table1的Query Key。

(2) Query緩存中，Query Key對應的是數據對象列表，假如不同的Query Key對應的數據對象列表有交集，那么，交集部分的數據對象就是重復存儲的。
比如，Query Key 1對應的數據對象列表為{a(id = 1), b(id = 2)}，Query Key 2對應的數據對象列表為{a(id = 1), c(id = 3)}，這個a就在兩個List同時存在了兩份。

4．二級緩存和Query緩存同步的困惑
假如，Query緩存中，一個Query Key對應的結果列表為{a (id = 1) , b (id = 2), c (id = 3)}; 二級緩存里面有也id = 1對應的數據對象a。
這兩個數據對象a之間是什么關系？能夠保持狀態同步嗎？
我閱讀Hibernate的相關源碼，沒有發現兩個緩存之間的這種同步關系。
或者兩者之間毫無關系。就像我上面所說的，只要表數據發生變化，相關的Query Key都要被清空。所以不用考慮同步問題？

四、Lightor的緩存策略
Lightor是我做的Java開源持久層框架。Lightor的意思是，Lightweight O/R。Hibernate，JDO，EJB CMP這些持久層框架，都是Layer。Lightor算不上Layer，而只是一個Helper。這里的O/R意思不是Object/Relational，而是Object/ResultSet的意思。:-)
Lightor的緩存策略，主要參照Hibernate的緩存思路，Lightor的緩存也分為 Query緩存和ID緩存。但其中有一點不同，兩者之間并不是毫無聯系的，而是相互關聯的。
1．Lightor的緩存策略的過程描述：
(1) 條件查詢的請求一般都包括如下信息：SQL, 對應SQL的參數，起始記錄位置(rowStart)，最大記錄個數(maxRows)，等。
(2) Lightor首先根據這些信息組成一個Query Key，根據這個Query Key到Query緩存中查找對應的結果ID列表。注意，這里獲取的是ID列表。
如果結果ID列表存在于Query緩存，那么根據這個ID列表的每個ID，到ID緩存中取對應的數據對象。如果所有ID對應的數據對象都找到，那個返回這個數據對象結果列表。注意，這里獲取的是整個數據對象（所有字段）的列表。
如果結果ID列表不存在于Query緩存，或者結果ID列表中的某一個ID不存在于ID緩存，那么，就查詢數據庫，獲取結果列表。然后，把獲取的每個數據對象按照ID放入到ID緩存；并組裝成一個ID列表，按照Query Key存放到Query緩存中。注意，這里是把ID列表，而不是整個對象列表，放入到Query緩存中。
(3) ID查詢的時候，Lightor先從ID緩存中查找該ID，如果不存在，那么查詢數據庫，把結果放入ID緩存。
(4) Query Key中的SQL涉及到一些表名，如果這些表的任何數據發生修改、刪除、增加等操作，這些相關的Query Key都要從緩存中清空。
2．Lightor的緩存策略的優點
(1) Lightor的ID緩存具有Jive緩存，和Hibernate二級ID緩存的優點。ID查詢的時候，如果該ID已經存在于緩存中，那么可以直接取出。節省了一條數據庫查詢。
(2) Lightor的Query緩存具有Hibernate的Query緩存的優點。條件查詢的時候，如果Query Key已經存在于緩存，那么不需要再查詢數據庫。命中的情況下，一次數據庫查詢也不需要。
(3) Lightor的Query緩存中，Query Key對應的是ID列表，而不是數據對象列表，真正的數據對象只存在于ID緩存中。所以，不同的Query Key對應的ID列表如果有交集，ID對應的數據對象也不會在ID緩存中重復存儲。
(4) Lightor的緩存也沒有Jive緩存的最壞情況n + 1次數據庫查詢缺點。
3．Lightor的緩存策略的缺點
(1) Lightor的Query緩存具有Hibernate的Query緩存的缺點。條件查詢涉及到的表中，如果有任何一條記錄增加、刪除、或改變，那么緩存中所有和該表相關的Query Key都會失效。
(2) Lightor的ID緩存也具有hibernate的二級ID緩存具有的缺點。條件查詢的時候，即使ID已經存在于緩存中，也需要重新把數據對象整個從數據庫取出，放入到緩存中。

五、Query Key的效率
Query緩存的Query Key的空間和時間開銷比較大。
Query Key里面存放的東西不少，SQL, 參數，范圍（起始，個數）。
這里面最大的東西就是SQL。又占地方，又花時間（hashCode, equals）。
Query Key最關鍵的兩個方法是hashCode和equals，重點是SQL的hashCode和equals。

Lightor的做法是，由于Lightor直接使用SQL，不用HQL、OQL之類，所以推薦盡量使用static final String的SQL，能夠節省空間和時間，以至于Query Key的效率能夠相當于ID Key的效率。
至于Hibernate的QueryKey，有興趣的讀者可以去下載閱讀Hibernate的各個版本的源代碼，跟蹤一下QueryKey的實現優化過程。

六、總結
這里列一個表，綜合表示Jive, Hibernate, Lightor的緩存策略的特征。
N + 1問題 重復ID緩存問題 Query緩存支持
Jive緩存 有 無 不支持
Hibernate緩存 無 有 支持
Lightor緩存 無 有 支持

注：
“重復ID緩存問題”的含義是，每次條件查詢，不是只取ID列表，而是取出完整對象（所有字段）的列表。這樣，同一個ID對應的數據對象，即使在緩存中已經存在，也可能被重新放入緩存。參見相關緩存的缺點描述。
“重復ID緩存問題”的負面效應到底有多大，就看你的select id from …（只選擇ID）比你的 select * from … (選擇所有字段)快多少。主要影響因素是，字段的個數，字段值的長度，與數據庫服務器之間網絡傳輸速度。
不管怎么說，即使選擇所有字段，也只是一次數據庫查詢。而N + 1問題帶來的可能最壞的負面效應（N + 1次數據查詢）卻是非常大的。
選擇緩存策略的時候，應根據這些情況發生的概率和正負面效應進行取舍。

----- added later

看到Robbin在04年6月的一篇相關文章。

Hibernate Iterator JCS分析
http://www.hibernate.org.cn/71.html

Hashtable和HashMap的區別：
1.Hashtable是Dictionary的子類，HashMap是Map接口的一個實現類；
2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情況下是非同步的。即是說，在多線程應用程序中，不用專門的操作就安全地可以使用Hashtable了；而對于HashMap，則需要額外的同步機制。但HashMap的同步問題可通過Collections的一個靜態方法得到解決：
Map Collections.synchronizedMap(Map m)
這個方法返回一個同步的Map，這個Map封裝了底層的HashMap的所有方法，使得底層的HashMap即使是在多線程的環境中也是安全的。
3.在HashMap中，null可以作為鍵，這樣的鍵只有一個；可以有一個或多個鍵所對應的值為null。當get()方法返回null值時，即可以表示HashMap中沒有該鍵，也可以表示該鍵所對應的值為null。因此，在HashMap中不能由get()方法來判斷HashMap中是否存在某個鍵，而應該用containsKey()方法來判斷。

Vector、ArrayList和List的異同

線性表，鏈表，哈希表是常用的數據結構，在進行Java開發時，JDK已經為我們提供了一系列相應的類來實現基本的數據結構。這些類均在java.util包中。本文試圖通過簡單的描述，向讀者闡述各個類的作用以及如何正確使用這些類。

Collection
├List
│├LinkedList
│├ArrayList
│└Vector
│　└Stack
└Set
Map
├Hashtable
├HashMap
└WeakHashMap

Collection接口
　　Collection是最基本的集合接口，一個Collection代表一組Object，即Collection的元素（Elements）。一些Collection允許相同的元素而另一些不行。一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類，Java SDK提供的類都是繼承自Collection的“子接口”如List和Set。
　　所有實現Collection接口的類都必須提供兩個標準的構造函數：無參數的構造函數用于創建一個空的Collection，有一個Collection參數的構造函數用于創建一個新的Collection，這個新的Collection與傳入的Collection有相同的元素。后一個構造函數允許用戶復制一個Collection。
　　如何遍歷Collection中的每一個元素？不論Collection的實際類型如何，它都支持一個iterator()的方法，該方法返回一個迭代子，使用該迭代子即可逐一訪問Collection中每一個元素。典型的用法如下：
　　　　Iterator it = collection.iterator(); // 獲得一個迭代子
　　　　while(it.hasNext()) {
　　　　　　Object obj = it.next(); // 得到下一個元素
　　　　}
　　由Collection接口派生的兩個接口是List和Set。

List接口
　　List是有序的Collection，使用此接口能夠精確的控制每個元素插入的位置。用戶能夠使用索引（元素在List中的位置，類似于數組下標）來訪問List中的元素，這類似于Java的數組。
和下面要提到的Set不同，List允許有相同的元素。
　　除了具有Collection接口必備的iterator()方法外，List還提供一個listIterator()方法，返回一個ListIterator接口，和標準的Iterator接口相比，ListIterator多了一些add()之類的方法，允許添加，刪除，設定元素，還能向前或向后遍歷。
　　實現List接口的常用類有LinkedList，ArrayList，Vector和Stack。

LinkedList類
　　LinkedList實現了List接口，允許null元素。此外LinkedList提供額外的get，remove，insert方法在LinkedList的首部或尾部。這些操作使LinkedList可被用作堆棧（stack），隊列（queue）或雙向隊列（deque）。
　　注意LinkedList沒有同步方法。如果多個線程同時訪問一個List，則必須自己實現訪問同步。一種解決方法是在創建List時構造一個同步的List：
　　　　List list = Collections.synchronizedList(new LinkedList(...));

ArrayList類
　　ArrayList實現了可變大小的數組。它允許所有元素，包括null。ArrayList沒有同步。
size，isEmpty，get，set方法運行時間為常數。但是add方法開銷為分攤的常數，添加n個元素需要O(n)的時間。其他的方法運行時間為線性。
　　每個ArrayList實例都有一個容量（Capacity），即用于存儲元素的數組的大小。這個容量可隨著不斷添加新元素而自動增加，但是增長算法并沒有定義。當需要插入大量元素時，在插入前可以調用ensureCapacity方法來增加ArrayList的容量以提高插入效率。
　　和LinkedList一樣，ArrayList也是非同步的（unsynchronized）。

Vector類
　　Vector非常類似ArrayList，但是Vector是同步的。由Vector創建的Iterator，雖然和ArrayList創建的Iterator是同一接口，但是，因為Vector是同步的，當一個Iterator被創建而且正在被使用，另一個線程改變了Vector的狀態（例如，添加或刪除了一些元素），這時調用Iterator的方法時將拋出ConcurrentModificationException，因此必須捕獲該異常。

Stack 類
　　Stack繼承自Vector，實現一個后進先出的堆棧。Stack提供5個額外的方法使得Vector得以被當作堆棧使用。基本的push和pop方法，還有peek方法得到棧頂的元素，empty方法測試堆棧是否為空，search方法檢測一個元素在堆棧中的位置。Stack剛創建后是空棧。

Set接口
　　Set是一種不包含重復的元素的Collection，即任意的兩個元素e1和e2都有e1.equals(e2)=false，Set最多有一個null元素。
　　很明顯，Set的構造函數有一個約束條件，傳入的Collection參數不能包含重復的元素。
　　請注意：必須小心操作可變對象（Mutable Object）。如果一個Set中的可變元素改變了自身狀態導致Object.equals(Object)=true將導致一些問題。

Map接口
　　請注意，Map沒有繼承Collection接口，Map提供key到value的映射。一個Map中不能包含相同的key，每個key只能映射一個value。Map接口提供3種集合的視圖，Map的內容可以被當作一組key集合，一組value集合，或者一組key-value映射。

Hashtable類
　　Hashtable繼承Map接口，實現一個key-value映射的哈希表。任何非空（non-null）的對象都可作為key或者value。
　　添加數據使用put(key, value)，取出數據使用get(key)，這兩個基本操作的時間開銷為常數。
Hashtable通過initial capacity和load factor兩個參數調整性能。通常缺省的load factor 0.75較好地實現了時間和空間的均衡。增大load factor可以節省空間但相應的查找時間將增大，這會影響像get和put這樣的操作。
使用Hashtable的簡單示例如下，將1，2，3放到Hashtable中，他們的key分別是”one”，”two”，”three”：
　　　　Hashtable numbers = new Hashtable();
　　　　numbers.put(“one”, new Integer(1));
　　　　numbers.put(“two”, new Integer(2));
　　　　numbers.put(“three”, new Integer(3));
　　要取出一個數，比如2，用相應的key：
　　　　Integer n = (Integer)numbers.get(“two”);
　　　　System.out.println(“two = ” + n);
　　由于作為key的對象將通過計算其散列函數來確定與之對應的value的位置，因此任何作為key的對象都必須實現hashCode和equals方法。hashCode和equals方法繼承自根類Object，如果你用自定義的類當作key的話，要相當小心，按照散列函數的定義，如果兩個對象相同，即obj1.equals(obj2)=true，則它們的hashCode必須相同，但如果兩個對象不同，則它們的hashCode不一定不同，如果兩個不同對象的hashCode相同，這種現象稱為沖突，沖突會導致操作哈希表的時間開銷增大，所以盡量定義好的hashCode()方法，能加快哈希表的操作。
　　如果相同的對象有不同的hashCode，對哈希表的操作會出現意想不到的結果（期待的get方法返回null），要避免這種問題，只需要牢記一條：要同時復寫equals方法和hashCode方法，而不要只寫其中一個。
　　Hashtable是同步的。

HashMap類
　　HashMap和Hashtable類似，不同之處在于HashMap是非同步的，并且允許null，即null value和null key。，但是將HashMap視為Collection時（values()方法可返回Collection），其迭代子操作時間開銷和HashMap的容量成比例。因此，如果迭代操作的性能相當重要的話，不要將HashMap的初始化容量設得過高，或者load factor過低。

WeakHashMap類
　　WeakHashMap是一種改進的HashMap，它對key實行“弱引用”，如果一個key不再被外部所引用，那么該key可以被GC回收。

總結
　　如果涉及到堆棧，隊列等操作，應該考慮用List，對于需要快速插入，刪除元素，應該使用LinkedList，如果需要快速隨機訪問元素，應該使用ArrayList。
　　如果程序在單線程環境中，或者訪問僅僅在一個線程中進行，考慮非同步的類，其效率較高，如果多個線程可能同時操作一個類，應該使用同步的類。
　　要特別注意對哈希表的操作，作為key的對象要正確復寫equals和hashCode方法。
　　盡量返回接口而非實際的類型，如返回List而非ArrayList，這樣如果以后需要將ArrayList換成LinkedList時，客戶端代碼不用改變。這就是針對抽象編程。

     摘要: （轉載文章） 1 什么是Java、Java2、JDK?JDK后面的1.3、1.4.2版本號又是怎么回事? 　　答:Java是一種通用的，并發的，強類型的，面向對象的編程語言(摘自Java規范第二版) JDK是Sun公司分發的免費Java開發工具，正式名稱為J2SDK(Java2 Software Develop Kit)。 ...  閱讀全文

摘自：ChinaITLab

作者：

瀏覽率：70

JSF對通過關聯組件和事件來構建頁面而說是非常棒的，但是，與所有現有的技術一樣，它需要一個控制器來分離出頁面間的導航決策，并提供到業務層的鏈接。它擁有一個基本的導航處理程序，可以用功能完備的處理程序來替換它。Page Flow為創建可重用的封裝頁面流提供了基礎，并可以與視圖層并行工作。它是一個功能完備的導航處理程序，將JSF頁面作為最優先的處理對象。本文將討論如何集成這兩種技術來利用二者的優點。 　　構建Beehive/JSF應用程序 　　要構建Beehive/JSF應用程序，首先要啟動Page Flow，然后添加對JSF的支持。起點是從基本的支持NetUI（Beehive中包含Page Flow的組件）的項目開始。根據指導構建基本的支持NetUI的Web應用程序。在本文中，我們暫且稱之為“jsf-beehive”，可以在 http://localhost:8080/jsf-beehive 上獲得。 　　接下來，安裝并配置JSF。Page Flow可以使用任何與JavaServer Faces 1.1兼容的實現，并針對兩種主流實現進行了測試：Apache MyFaces和JSF Reference Implementation。根據下面的指導在新的Web應用程序中安裝JSF：MyFaces v1.0.9及更高版本，JSF Reference Implementation v1.1_01，或者其他實現。之后，可以使用WEB-INF/faces-config.xml中的一個簡單入口啟動Page Flow集成，入口在<application>標簽之下，<navigation-rule>標簽之上： <factory> <application-factory> org.apache.beehive.netui.pageflow.faces.PageFlowApplicationFactory </application-factory> </factory> 　　添加了這些就為頁面流提供了一個機會，使其可以提供自己的JSF框架對象版本來定制其行為。通常來說，只有在使用頁面流功能的時候，JSF行為才會被修改；JSF的基本行為不會改變。 　　基本集成 　　JSF中頁面流的最基本用處是引發（調用）來自JSF頁面的動作。JSF頁面可以處理頁面內事件，而頁面流動作則是從一個頁面導航到另一頁面的方法。首先，在Web應用程序中創建一個名為“example”的目錄，在其中創建一個頁面流控制器類： package example; import org.apache.beehive.netui.pageflow.Forward; import org.apache.beehive.netui.pageflow.PageFlowController; import org.apache.beehive.netui.pageflow.annotations.Jpf; @Jpf.Controller( simpleActions={ @Jpf.SimpleAction(name="begin", path="page1.faces") } ) public class ExampleController extends PageFlowController { @Jpf.Action( forwards={ @Jpf.Forward(name="success", path="page2.faces") } ) public Forward goPage2() { Forward fwd = new Forward("success"); return fwd; } } 　　在這個頁面流中有兩個動作：跳轉到page1.faces的begin動作和跳轉到page2.faces的goPage2動作。將goPage2作為一個方法動作（而不是簡單動作）的原因是稍后將會對其進行擴充。 　　在構造頁面的時候，應當以.jsp為擴展名創建page1和page2；JSF servlet處理每個.faces請求，并最終跳轉到相關的JSP。所以，跳轉到page1.faces最終將顯示page1.jsp，如下： <%@ taglib prefix="f" uri="http://java.sun.com/jsf/core" %> <%@ taglib prefix="h" uri="http://java.sun.com/jsf/html" %> ? <html> <body> <f:view> <h:form> <h:panelGrid> <h:outputText value="Page 1 of page flow #{pageFlow.URI}"/> <h:commandLink action="goPage2" value="Go to page 2"/> </h:panelGrid> </h:form> </f:view> </body> </html> 　　從JSF頁面引發一個動作很簡單：使用命令組件的action屬性中的動作名字就可以了。在上面的例子中，commandLink指向goPage2動作。使用頁面流集成，這意味著goPage2動作會在example.ExampleController中運行。 　　就是這樣。要試驗的話，構建應用程序，點擊 http://localhost:8080/jsf-beehive/example/ExampleController.jpf ，這將通過begin動作跳轉到page1.faces。單擊鏈接“Go to page 2”，會引發goPage2動作并跳轉到page2.faces。 　　后臺Bean 　　Page Flow框架可以管理與JSF頁面相關的后臺bean（backing bean）。該類是放置與頁面相關的事件處理程序和狀態的方便場所。可以把它看作是集中放置與頁面交互時所運行的所有代碼的單一場所。當點擊一個JSF頁面時，Page Flow會判斷是否有具有同樣名稱和包的類，例如，page /example/page1.faces的example.page1類。如果存在這樣的類，并且它用@Jpf.FacesBacking進行注釋并擴展了FacesBackingBean，它就會創建該類的一個實例。當離開JSF頁面而轉到一個動作或者其它任何頁面時，后臺bean會被銷毀。后臺bean與JSF頁面共存亡。 　　綁定到后臺bean中的屬性 　　下面是page1.faces的一個非常簡單的后臺bean，以及屬性someProperty。文件名是page1.java： package example; import org.apache.beehive.netui.pageflow.FacesBackingBean; import org.apache.beehive.netui.pageflow.annotations.Jpf; @Jpf.FacesBacking public class page1 extends FacesBackingBean { private String _someProperty = "This is a property value from" + getClass().getName() + "."; public String getSomeProperty() { return _someProperty; } public void setSomeProperty(String someProperty) { _someProperty = someProperty; } } 　　在JSF頁面(page1.jsp)中，可以利用backing綁定上下文來綁定到這個屬性： 　　<h:outputText value="#{backing.someProperty}"/> 　　上面的例子顯示了someProperty（最終在后臺bean上調用getSomeProperty()）的值。類似地，設置這個值： 　　<h:inputText value="#{backing.someProperty}"/> 　　注意，在這個例子中，后臺bean中沒有出現事件處理程序或組件引用。這就縮短了代碼；后臺bean是放置頁面所有的處理程序和組件引用的好地方。 　　從后臺bean引發頁面流動作 　　在上面的“基本集成”部分，我們直接從JSF組件引發頁面流動作。通常情況下，只需這樣即可；當單擊一個按鈕或者鏈接時，會運行一個動作并跳轉到另一個頁面上。如果想在調用控制器之前運行一些與頁面相關的代碼，或者如果希望頁面可以在幾個動作之間進行動態選擇的話，可以在命令處理程序（JSF頁面所運行的一個Java方法）中引發一個動作。下面是一個命令處理程序的例子，可以把它放到后臺bean page2.java中（或者其它任何可公開訪問的bean中）： public String chooseNextPage() { return "goPage3"; } 　　這是一個非常簡單的命令處理程序，它選擇了goPage3動作。可以用標準的JSF方式從一個JSF命令組件綁定到這個命令處理程序： <h:commandButton action="#{backing.chooseNextPage}" value="Submit"/> 　　當單擊鏈接時，會運行chooseNextPage命令處理程序，它會選擇引發goPage3動作。還可以對命令處理程序方法使用一個特殊的頁面流注釋——@Jpf.CommandHandler： @Jpf.CommandHandler( raiseActions={ @Jpf.RaiseAction(action="goPage3") } ) public String chooseNextPage() { return "goPage3"; } 　　該注釋使支持Beehive的工具可以知道命令處理程序引發了后臺bean中的哪個動作，并允許擴展JSF動作處理的能力（參見下面“從JSF頁面向頁面流發送數據”部分）。 　　從后臺bean訪問當前頁面流或共享流 　　在某些情況下，您或許想直接從后臺bean訪問當前頁面流或一個活動的共享流。為此，只需創建一個適當類型的字段，并使用@Jpf.PageFlowField或@Jpf.SharedFlowField對其進行適當注釋： @Jpf.CommandHandler( raiseActions={ @Jpf.RaiseAction(action="goPage3") } ) public String chooseNextPage() { return "goPage3"; } 　　這些字段將在創建后臺bean的時候被初始化。無需手動對其進行初始化。下面的例子使用了自動初始化的ExampleController字段。在這個例子中，“show hints”單選鈕的事件處理程序在頁面流中設置了一個普通優先級。 @Jpf.PageFlowField private ExampleController myController; @Jpf.SharedFlowField(name="sharedFlow2") // "sharedFlow2" is a // name defined in the // page flow controller private ExampleSharedFlow mySharedFlow; 　　在很多情況下，頁面不需要直接與頁面流或者共享流進行交互；使用其它方法從頁面流向JSF頁面傳遞數據就足夠了，反之亦然。下面我將給出一些例子。 　　從頁面流控制器訪問后臺bean 　　您不能從頁面流控制器訪問后臺bean！至少，這不容易做到，這是有意為之的。后臺bean與JSF頁面緊密相關，當您離開頁面的時候，后臺bean會被銷毀。正如頁面流控制器不應了解頁面細節一樣，它也不應了解后臺bean。當然了，可以從后臺bean向控制器傳遞數據（稍后將會介紹），甚至可以傳遞后臺bean實例本身，但是在大多數情況下，后臺bean的內容是不應當泄露給控制器的。 　　生命周期方法 　　通常，當后臺bean發生某些事情的時候，比如當它被創建或銷毀時，我們希望能運行代碼。在Page Flow框架的生命周期中，它會對后臺bean調用一些方法： onCreate()：創建bean時 onDestroy()：銷毀bean時（從用戶會話移除） onRestore()：這個需要詳細解釋一下。我說過，當您離開頁面的時候，后臺bean會被銷毀。在大多數情況下是這樣的，但是如果頁面流使用了navigateTo特性（它使您可以再次訪問先前顯示的頁面），在您離開頁面之后，Page Flow框架會保留后臺bean一小段時間，以防它需要還原。當通過@Jpf.Forward或@Jpf.SimpleAction使用navigateTo=Jpf.NavigateTo.currentPage或navigateTo=Jpf.NavigateTo.previousPage還原一個JSF頁面時，頁面的組件樹及其后臺bean都被Page Flow框架還原。當這種情況發生時，onRestore()就被調用。 　　不管要在哪個時期運行代碼，只需重寫適當的方法： protected void onCreate() { /*some create-time logic */ } 　　當重寫這些方法時，不需要調用空的super版本。 　　在JSF頁面和頁面流之間傳遞數據 　　現在我們該看看如何在JSF頁面和頁面流之間傳遞數據了。 　　從頁面流向JSF頁面發送數據 　　通常，您會想要利用頁面流的數據來初始化一個頁面。為此，可以向page2.faces的Forward添加“action outputs”： @Jpf.Action( forwards={ @Jpf.Forward( name="success", path="page2.faces", actionOutputs={ @Jpf.ActionOutput(name="message", type=String.class,required=true) } ) } ) public Forward goPage2() { Forward fwd = new Forward("success"); fwd.addActionOutput("message", "Got the message."); return fwd; } 　　做完這些之后，可以直接從JSF頁面或者后臺bean將該值作為頁面輸入來訪問。（如果您不喜歡鍵入冗長的注釋，可以省去斜體的。它們主要用于再次檢查添加的對象類型是否正確，確定不缺失類型。） 　　可以在頁面中利用JSF表示語言中的頁面流pageInput綁定上下文綁定到這個值： <h:outputText value="#{pageInput.message}"/> 　　注意，可以利用pageFlow和sharedFlow綁定上下文綁定到頁面流控制器自身或者任何可用的共享流的屬性： <h:outputText value="#{pageFlow.someProperty}"/> <h:outputText value="#{sharedFlow.mySharedFlow.someProperty}"/> 　　最后，要想從后臺bean訪問頁面輸入，只需在bean類代碼中的任意地方調用getPageInput： String message = (String) getPageInput("message"); 　　從JSF頁面向頁面流發送數據 　　還可以隨著頁面流所引發的動作發送數據。很多動作將要求表單bean作為輸入；通常，表單bean用于從頁面獲取數據送到控制器。首先，讓我們構建一個動作來接收表單bean并跳轉到頁面： @Jpf.Action( forwards={ @Jpf.Forward(name="success", path="page3.faces") } ) public Forward goPage3(NameBean nameBean) { _userName = nameBean.getFirstName() + ' ' + nameBean.getLastName(); return new Forward("success"); } 　　該動作包含一個NameBean，它是一個將getters/setters作為其firstName和lastName屬性的表單bean類。它設置一個成員變量保存完整名字，之后跳轉到page3.faces。我們知道，可以直接從JSF頁面或者它的后臺bean引發一個動作。在這兩種情況下，都可以向動作發送表單bean。下面讓我們依次看看每種情況。 　　從后臺bean發送表單bean 　　要從后臺bean中的命令處理程序發送表單bean，需要使用一個特定的注釋。下面給出了page2.java中的情況： private ExampleController.NameBean _nameBean; protected void onCreate() { _nameBean = new ExampleController.NameBean(); } public ExampleController.NameBean getName() { return _nameBean; } @Jpf.CommandHandler( raiseActions={ @Jpf.RaiseAction(action="goPage3", outputFormBean="_nameBean") } ) public String chooseNextPage() { return "goPage3"; } 　　在這個例子中，JSF頁面可以用它選擇的任何方式填充_nameBean的值（例如，通過將h:inputText值綁定到#{backing.name.firstName}和#{backing.name.lastName}）。之后它使用@Jpf.RaiseAction上的outputFormBean屬性來標記_nameBean應當被傳遞到動作goPage3。 　　從JSF頁面發送表單bean 　　從JSF頁面直接發送表單bean很容易，只要您可以通過數據綁定表達式得到bean值。這是通過在commandButton組件內部添加名為submitFormBean的h:attribute組件來實現的： <h:commandButton action="#{backing.chooseNextPage}" value="Submit directly from page"> <f:attribute name="submitFormBean" value="backing.name" /> </h:commandButton> 　　在這里，為了使表單bean發送到動作goPage3，按鈕綁定到后臺bean的“name”屬性(getName)。 　　結束語 　　本文展示了如何將JSF在構建頁面方面的豐富特性與Beehive Page Flow在控制頁面間導航方面的強大功能相結合。二者的集成非常容易，但是卻會對應用造成深遠的影響：它將JSF頁面與應用級邏輯相分離，并把頁面帶入Page Flow所提供的功能領域中。JSF頁面得到了清楚的任務：作為單個（如果有足夠能力的話）視圖元素參與到應用程序的流中。文中沒有展示JSF頁面中具有事件處理功能且控制器中具有復雜的導航邏輯的完備應用程序。但是隨著應用程序的復雜程度提高，它就會更加需要責任的劃分以及頁面流添加給JSF的高級流功能。您可以花幾分鐘嘗試一下——很快您就將意識到這樣做所帶來的好處。

[原創文章，轉載請保留或注明出處：http://www.regexlab.com/zh/regref.htm]

引言

??? 正則表達式（regular expression）描述了一種字符串匹配的模式，可以用來：（1）檢查一個串中是否含有符合某個規則的子串，并且可以得到這個子串；（2）根據匹配規則對字符串進行靈活的替換操作。

??? 正則表達式學習起來其實是很簡單的，不多的幾個較為抽象的概念也很容易理解。之所以很多人感覺正則表達式比較復雜，一方面是因為大多數的文檔沒有做到由淺 入深地講解，概念上沒有注意先后順序，給讀者的理解帶來困難；另一方面，各種引擎自帶的文檔一般都要介紹它特有的功能，然而這部分特有的功能并不是我們首 先要理解的。

??? 文章中的每一個舉例，都可以點擊進入到測試頁面進行測試。閑話少說，開始。

---

1. 正則表達式規則

1.1 普通字符

??? 字母、數字、漢字、下劃線、以及后邊章節中沒有特殊定義的標點符號，都是"普通字符"。表達式中的普通字符，在匹配一個字符串的時候，匹配與之相同的一個字符。

??? ，匹配結果是：成功；匹配到的內容是："c"；匹配到的位置是：開始于2，結束于3。（注：下標從0開始還是從1開始，因當前編程語言的不同而可能不同）

??? ，匹配結果是：成功；匹配到的內容是："bcd"；匹配到的位置是：開始于1，結束于4。

---

1.2 簡單的轉義字符

??? 一些不便書寫的字符，采用在前面加 "\" 的方法。這些字符其實我們都已經熟知了。

表達式	可匹配
\r, \n	代表回車和換行符
\t	制表符
\\	代表 "\" 本身

??? 還有其他一些在后邊章節中有特殊用處的標點符號，在前面加 "\" 后，就代表該符號本身。比如：^, $ 都有特殊意義，如果要想匹配字符串中 "^" 和 "$" 字符，則表達式就需要寫成 "\^" 和 "\$"。

表達式	可匹配
\^	匹配 ^ 符號本身
\$	匹配 $ 符號本身
\.	匹配小數點（.）本身

??? 這些轉義字符的匹配方法與 "普通字符" 是類似的。也是匹配與之相同的一個字符。

??? ，匹配結果是：成功；匹配到的內容是："$d"；匹配到的位置是：開始于3，結束于5。

---

1.3 能夠與 '多種字符' 匹配的表達式

??? 正則表達式中的一些表示方法，可以匹配 '多種字符' 其中的任意一個字符。比如，表達式 "\d" 可以匹配任意一個數字。雖然可以匹配其中任意字符，但是只能是一個，不是多個。這就好比玩撲克牌時候，大小王可以代替任意一張牌，但是只能代替一張牌。

表達式	可匹配
\d	任意一個數字，0~9 中的任意一個
\w	任意一個字母或數字或下劃線，也就是 A~Z,a~z,0~9,_ 中任意一個
\s	包括空格、制表符、換頁符等空白字符的其中任意一個
.	小數點可以匹配除了換行符（\n）以外的任意一個字符

??? ，匹配的結果是：成功；匹配到的內容是："12"；匹配到的位置是：開始于3，結束于5。

??? ，匹配的結果是：成功；匹配到的內容是："aa1"；匹配到的位置是：開始于1，結束于4。

---

1.4 自定義能夠匹配 '多種字符' 的表達式

??? 使用方括號 [ ] 包含一系列字符，能夠匹配其中任意一個字符。用 [^ ] 包含一系列字符，則能夠匹配其中字符之外的任意一個字符。同樣的道理，雖然可以匹配其中任意一個，但是只能是一個，不是多個。

表達式	可匹配
[ab5@]	匹配 "a" 或 "b" 或 "5" 或 "@"
[^abc]	匹配 "a","b","c" 之外的任意一個字符
[f-k]	匹配 "f"~"k" 之間的任意一個字母
[^A-F0-3]	匹配 "A"~"F","0"~"3" 之外的任意一個字符

??? ，匹配的結果是：成功；匹配到的內容是："bc"；匹配到的位置是：開始于1，結束于3。

??? ，匹配的結果是：成功；匹配到的內容是："1"；匹配到的位置是：開始于3，結束于4。

---

1.5 修飾匹配次數的特殊符號

??? 前面章節中講到的表達式，無論是只能匹配一種字符的表達式，還是可以匹配多種字符其中任意一個的表達式，都只能匹配一次。如果使用表達式再加上修飾匹配次數的特殊符號，那么不用重復書寫表達式就可以重復匹配。

??? 使用方法是："次數修飾"放在"被修飾的表達式"后邊。比如："[bcd][bcd]" 可以寫成 "[bcd]{2}"。

表達式	作用
{n}	表達式重復n次，比如：；
{m,n}	表達式至少重復m次，最多重復n次，比如：
{m,}	表達式至少重復m次，比如：
?	匹配表達式0次或者1次，相當于 {0,1}，比如：
+	表達式至少出現1次，相當于 {1,}，比如：
*	表達式不出現或出現任意次，相當于 {0,}，比如：

??? ，匹配的結果是：成功；匹配到的內容是："12.5"；匹配到的位置是：開始于10，結束于14。

??? ，匹配的結果是：成功；匹配到的內容是："goooooogle"；匹配到的位置是：開始于7，結束于17。

---

1.6 其他一些代表抽象意義的特殊符號

??? 一些符號在表達式中代表抽象的特殊意義：

表達式	作用
^	與字符串開始的地方匹配，不匹配任何字符
$	與字符串結束的地方匹配，不匹配任何字符
\b	匹配一個單詞邊界，也就是單詞和空格之間的位置，不匹配任何字符

??? 進一步的文字說明仍然比較抽象，因此，舉例幫助大家理解。

??? ，匹配結果是：失敗。因為 "^" 要求與字符串開始的地方匹配，因此，只有當 "aaa" 位于字符串的開頭的時候，"^aaa" 才能匹配，。

??? 舉例2：表達式 "aaa$" 在匹配 "xxx aaa xxx" 時，匹配結果是：失敗。因為 "$" 要求與字符串結束的地方匹配，因此，只有當 "aaa" 位于字符串的結尾的時候，"aaa$" 才能匹配，。

??? ，匹配結果是：成功；匹配到的內容是："@a"；匹配到的位置是：開始于2，結束于4。
??? 進一步說明："\b" 與 "^" 和 "$" 類似，本身不匹配任何字符，但是它要求它在匹配結果中所處位置的左右兩邊，其中一邊是 "\w" 范圍，另一邊是 非"\w" 的范圍。

??? ，匹配結果是：成功；匹配到的內容是："end"；匹配到的位置是：開始于15，結束于18。

??? 一些符號可以影響表達式內部的子表達式之間的關系：

表達式	作用
|	左右兩邊表達式之間 "或" 關系，匹配左邊或者右邊
( )	(1). 在被修飾匹配次數的時候，括號中的表達式可以作為整體被修飾 (2). 取匹配結果的時候，括號中的表達式匹配到的內容可以被單獨得到

??? ，匹配結果是：成功；匹配到的內容是："Tom"；匹配到的位置是：開始于4，結束于7。匹配下一個時，匹配結果是：成功；匹配到的內容是："Jack"；匹配到的位置時：開始于15，結束于19。

??? ，匹配結果是：成功；匹配到內容是："go go go"；匹配到的位置是：開始于6，結束于14。

??? ，匹配的結果是：成功；匹配到的內容是："￥20.5"；匹配到的位置是：開始于6，結束于10。單獨獲取括號范圍匹配到的內容是："20.5"。

---

2. 正則表達式中的一些高級規則

2.1 匹配次數中的貪婪與非貪婪

??? 在使用修飾匹配次數的特殊符號時，有幾種表示方法可以使同一個表達式能夠匹配不同的次數，比如："{m,n}", "{m,}", "?", "*", "+"，具體匹配的次數隨被匹配的字符串而定。這種重復匹配不定次數的表達式在匹配過程中，總是盡可能多的匹配。比如，針對文本 "dxxxdxxxd"，舉例如下：

表達式	匹配結果
(d)(\w+)	"\w+" 將匹配第一個 "d" 之后的所有字符 "xxxdxxxd"
(d)(\w+)(d)	"\w+" 將匹配第一個 "d" 和最后一個 "d" 之間的所有字符 "xxxdxxx"。雖然 "\w+" 也能夠匹配上最后一個 "d"，但是為了使整個表達式匹配成功，"\w+" 可以 "讓出" 它本來能夠匹配的最后一個 "d"

??? 由此可見，"\w+" 在匹配的時候，總是盡可能多的匹配符合它規則的字符。雖然第二個舉例中，它沒有匹配最后一個 "d"，但那也是為了讓整個表達式能夠匹配成功。同理，帶 "*" 和 "{m,n}" 的表達式都是盡可能地多匹配，帶 "?" 的表達式在可匹配可不匹配的時候，也是盡可能的 "要匹配"。這 種匹配原則就叫作 "貪婪" 模式 。

??? 非貪婪模式：

??? 在修飾匹配次數的特殊符號后再加上一個 "?" 號，則可以使匹配次數不定的表達式盡可能少的匹配，使可匹配可不匹配的表達式，盡可能的 "不匹配"。這種匹配原則叫作 "非貪婪" 模式，也叫作 "勉強" 模式。如果少匹配就會導致整個表達式匹配失敗的時候，與貪婪模式類似，非貪婪模式會最小限度的再匹配一些，以使整個表達式匹配成功。舉例如下，針對文本 "dxxxdxxxd" 舉例：

表達式	匹配結果
(d)(\w+?)	"\w+?" 將盡可能少的匹配第一個 "d" 之后的字符，結果是："\w+?" 只匹配了一個 "x"
(d)(\w+?)(d)	為了讓整個表達式匹配成功，"\w+?" 不得不匹配 "xxx" 才可以讓后邊的 "d" 匹配，從而使整個表達式匹配成功。因此，結果是："\w+?" 匹配 "xxx"

??? 更多的情況，舉例如下：

??? 舉 例1：表達式 "<td>(.*)</td>" 與字符串 "<td><p>aa</p></td> <td><p>bb</p></td>" 匹配時，匹配的結果是：成功；匹配到的內容是 "<td><p>aa</p></td> <td><p>bb</p></td>" 整個字符串， 表達式中的 "</td>" 將與字符串中最后一個 "</td>" 匹配。

??? ，將只得到 "<td><p>aa</p></td>"， 再次匹配下一個時，可以得到第二個 "<td><p>bb</p></td>"。

---

2.2 反向引用 \1, \2...

??? 表達式在匹配時，表達式引擎會將小括號 "( )" 包含的表達式所匹配到的字符串記錄下來。在獲取匹配結果的時候，小括號包含的表達式所匹配到的字符串可以單獨獲取。這一點，在前面的舉例中，已經多次展示 了。在實際應用場合中，當用某種邊界來查找，而所要獲取的內容又不包含邊界時，必須使用小括號來指定所要的范圍。比如前面的 "<td>(.*?)</td>"。

??? 其實，"小括號包含的表達式所匹配到的字符串" 不僅是在匹配結束后才可以使用，在匹配過程中也可以使用。表達式后邊的部分，可以引用前面 "括號內的子匹配已經匹配到的字符串"。引用方法是 "\" 加上一個數字。"\1" 引用第1對括號內匹配到的字符串，"\2" 引用第2對括號內匹配到的字符串……以此類推，如果一對括號內包含另一對括號，則外層的括號先排序號。換句話說，哪一對的左括號 "(" 在前，那這一對就先排序號。

??? 舉例如下：

??? ，匹配結果是：成功；匹配到的內容是：" 'Hello' "。再次匹配下一個時，可以匹配到 " "World" "。

??? ，匹配結果是：成功；匹配到的內容是 "ccccc"。再次匹配下一個時，將得到 999999999。這個表達式要求 "\w" 范圍的字符至少重復5次，。

??? 舉例3：表達式 "<(\w+)\s*(\w+(=('|").*?\4)?\s*)*>.*?</\1>" 在匹配 "<td id='td1' style="bgcolor:white"></td>" 時，匹配結果是成功。如果 "<td>" 與 "</td>" 不配對，則會匹配失敗；如果改成其他配對，也可以匹配成功。

---

2.3 預搜索，不匹配；反向預搜索，不匹配

??? 前面的章節中，我講到了幾個代表抽象意義的特殊符號："^"，"$"，"\b"。它們都有一個共同點，那就是：它們本身不匹配任何字符，只是對 "字符串的兩頭" 或者 "字符之間的縫隙" 附加了一個條件。理解到這個概念以后，本節將繼續介紹另外一種對 "兩頭" 或者 "縫隙" 附加條件的，更加靈活的表示方法。

??? 正向預搜索："(?=xxxxx)"，"(?!xxxxx)"

??? 格式："(?=xxxxx)"，在被匹配的字符串中，它對所處的 "縫隙" 或者 "兩頭" 附加的條件是：所在縫隙的右側，必須能夠匹配上 xxxxx 這部分的表達式。因為它只是在此作為這個縫隙上附加的條件，所以它并不影響后邊的表達式去真正匹配這個縫隙之后的字符。這就類似 "\b"，本身不匹配任何字符。"\b" 只是將所在縫隙之前、之后的字符取來進行了一下判斷，不會影響后邊的表達式來真正的匹配。

??? ，將只匹配 "Windows NT" 中的 "Windows "，其他的 "Windows " 字樣則不被匹配。

??? ，將可以匹配6個"f"的前4個，可以匹配9個"9"的前7個。這個表達式可以讀解成：重復4次以上的字母數字，則匹配其剩下最后2位之前的部分。當然，這個表達式可以不這樣寫，在此的目的是作為演示之用。

??? 格式："(?!xxxxx)"，所在縫隙的右側，必須不能匹配 xxxxx 這部分表達式。

??? ，將從頭一直匹配到 "stop" 之前的位置，如果字符串中沒有 "stop"，則匹配整個字符串。

??? ，只能匹配 "do"。在本條舉例中，"do" 后邊使用 "(?!\w)" 和使用 "\b" 效果是一樣的。

??? 反向預搜索："(?<=xxxxx)"，"(?<!xxxxx)"

??? 這兩種格式的概念和正向預搜索是類似的，反向預搜索要求的條件是：所在縫隙的 "左側"，兩種格式分別要求必須能夠匹配和必須不能夠匹配指定表達式，而不是去判斷右側。與 "正向預搜索" 一樣的是：它們都是對所在縫隙的一種附加條件，本身都不匹配任何字符。

??? 舉例5：表達式 "(?<=\d{4})\d+(?=\d{4})" 在匹配 "1234567890123456" 時，將匹配除了前4個數字和后4個數字之外的中間8個數字。由于 JScript.RegExp 不支持反向預搜索，因此，本條舉例不能夠進行演示。很多其他的引擎可以支持反向預搜索，比如：Java 1.4 以上的 java.util.regex 包，.NET 中System.Text.RegularExpressions 命名空間，boost::regex 以及 GRETA 正則表達式庫等。

---

3. 其他通用規則

??? 還有一些在各個正則表達式引擎之間比較通用的規則，在前面的講解過程中沒有提到。

3.1 表達式中，可以使用 "\xXX" 和 "\uXXXX" 表示一個字符（"X" 表示一個十六進制數）

形式	字符范圍
\xXX	編號在 0 ~ 255 范圍的字符，比如：
\uXXXX	任何字符可以使用 "\u" 再加上其編號的4位十六進制數表示，比如：

3.2 在表達式 "\s"，"\d"，"\w"，"\b" 表示特殊意義的同時，對應的大寫字母表示相反的意義

表達式	可匹配
\S
\D	匹配所有的非數字字符
\W	匹配所有的字母、數字、下劃線以外的字符
\B

3.3 在表達式中有特殊意義，需要添加 "\" 才能匹配該字符本身的字符匯總

字符	說明
^	匹配輸入字符串的開始位置。要匹配 "^" 字符本身，請使用 "\^"
$	匹配輸入字符串的結尾位置。要匹配 "$" 字符本身，請使用 "\$"
( )	標記一個子表達式的開始和結束位置。要匹配小括號，請使用 "\(" 和 "\)"
[ ]	用來自定義能夠匹配 '多種字符' 的表達式。要匹配中括號，請使用 "\[" 和 "\]"
{ }	修飾匹配次數的符號。要匹配大括號，請使用 "\{" 和 "\}"
.	匹配除了換行符（\n）以外的任意一個字符。要匹配小數點本身，請使用 "\."
?	修飾匹配次數為 0 次或 1 次。要匹配 "?" 字符本身，請使用 "\?"
+	修飾匹配次數為至少 1 次。要匹配 "+" 字符本身，請使用 "\+"
*	修飾匹配次數為 0 次或任意次。要匹配 "*" 字符本身，請使用 "\*"
|	左右兩邊表達式之間 "或" 關系。匹配 "|" 本身，請使用 "\|"

3.4 括號 "( )" 內的子表達式，如果希望匹配結果不進行記錄供以后使用，可以使用 "(?:xxxxx)" 格式

??? ，結果是 "bbccdd"。括號 "(?:)" 范圍的匹配結果不進行記錄，因此 "(\w)" 使用 "\1" 來引用。

3.5 常用的表達式屬性設置簡介：Ignorecase，Singleline，Multiline，Global

表達式屬性	說明
Ignorecase	默認情況下，表達式中的字母是要區分大小寫的。配置為 Ignorecase 可使匹配時不區分大小寫。有的表達式引擎，把 "大小寫" 概念延伸至 UNICODE 范圍的大小寫。
Singleline	默認情況下，小數點 "." 匹配除了換行符（\n）以外的字符。配置為 Singleline 可使小數點可匹配包括換行符在內的所有字符。
Multiline	默認情況下，表達式 "^" 和 "$" 只匹配字符串的開始 ① 和結尾 ④ 位置。如： ①xxxxxxxxx②\n ③xxxxxxxxx④ 配置為 Multiline 可以使 "^" 匹配 ① 外，還可以匹配換行符之后，下一行開始前 ③ 的位置，使 "$" 匹配 ④ 外，還可以匹配換行符之前，一行結束 ② 的位置。
Global	主要在將表達式用來替換時起作用，配置為 Global 表示替換所有的匹配。

---

4. 綜合提示

4.1 如果要要求表達式所匹配的內容是整個字符串，而不是從字符串中找一部分，那么可以在表達式的首尾使用 "^" 和 "$"，比如："^\d+$" 要求整個字符串只有數字。

4.2 如果要求匹配的內容是一個完整的單詞，而不會是單詞的一部分，那么在表達式首尾使用 "\b"，比如：。

4.3 表達式不要匹配空字符串。否則會一直得到匹配成功，而結果什么都沒有匹配到。比如：準備寫一個匹配 "123"、"123."、"123.5"、".5" 這幾種形式的表達式時，整數、小數點、小數數字都可以省略，但是不要將表達式寫成："\d*\.?\d*"，因為如果什么都沒有，這個表達式也可以匹配成 功。。

4.4 能匹配空字符串的子匹配不要循環無限次。如果括號內的子表達式中的每一部分都可以匹配 0 次，而這個括號整體又可以匹配無限次，那么情況可能比上一條所說的更嚴重，匹配過程中可能死循環。雖然現在有些正則表達式引擎已經通過辦法避免了這種情況 出現死循環了，比如 .NET 的正則表達式，但是我們仍然應該盡量避免出現這種情況。如果我們在寫表達式時遇到了死循環，也可以從這一點入手，查找一下是否是本條所說的原因。

4.5 合理選擇貪婪模式與非貪婪模式，參見話題討論。

4.6 或 "|" 的左右兩邊，對某個字符最好只有一邊可以匹配，這樣，不會因為 "|" 兩邊的表達式因為交換位置而有所不同。

http://www.choucou.com/article.asp?id=51

http://www-128.ibm.com/developerworks/cn/opensource/os-maven2/

http://www.tkk7.com/calvin/archive/2006/03/19/36098.html

http://www.tkk7.com/lucky/archive/2006/04/12/40746.html

http://affair.gzgo.gov.cn/blog/2006/02/24/1140713141496.html