過濾器與裝飾模式
裝飾（Decorator）模式是動態給一個對象添加一些額外的職責，或者說改變這個對象的一些行為。這就類似于使用油漆為某個東西刷上油漆，在原來的對象表面增加了一層外衣。

在裝飾模式中，有兩個主要角色：一個是被刷油漆的對象（decoratee）；另外一個是給decoratee刷油漆的對象（decorator）。這兩個對象都繼承同一個接口。
首先舉一個簡單例子來說明什么是裝飾模式。
先創建一個接口：

public interface Work
{ 
　　public void insert();
}
這是一種打樁工作的抽象接口，動作insert表示插入，那么插入什么？下面這個實現表示方形木樁的插入：
public class SquarePeg implements Work{ 
　   public void insert(){
　　　　System.out.println("方形樁插入");
　　} 
}


本來這樣也許就可以滿足打樁的工作需要，但是有可能土質很硬，在插入方形樁之前先要打一個洞，那么又將如何實現？可以編制一個Decorator類，同樣繼承Work接口，但是在實現insert方法時有些特別：
public class Decorator implements Work{
　　private Work work;
　　//額外增加的功能被打包在這個List中 
　　private ArrayList others = new ArrayList(); 
　　public Decorator(Work work)
　　{
　　　　this.work=work;
　　　　others.add("打洞");   //準備好額外的功能
　　}
　　public void insert(){
　　　　otherMethod();
　　　　work.insert();
　　} 
　　public void otherMethod()
　　{
　　　　ListIterator listIterator = others.listIterator();
　　　　while (listIterator.hasNext())
　　　　{
　　　　　　System.out.println(((String)(listIterator.next())) + " 正在進行");
　　　　}
} 
}


在Decorator的方法insert中先執行otherMethod()方法，然后才實現SquarePeg的insert方法。油漆工Decorator給被油漆者SquarePeg添加了新的行為——打洞。具體客戶端調用如下：

Work squarePeg ＝ new SquarePeg();

Work decorator = new Decorator(squarePeg);

decorator.insert();

本例中只添加了一個新的行為（打洞），如果還有很多類似的行為，那么使用裝飾模式的優點就體現出來了。因為可以通過另外一個角度（如組織新的油漆工實現子類）來對這些行為進行混合和匹配，這樣就不必為每個行為創建一個類，從而減少了系統的復雜性。

使用裝飾模式可以避免在被油漆對象decoratee中包裝很多動態的，可能需要也可能不需要的功能，只要在系統真正運行時，通過油漆工decorator來檢查那些需要加載的功能，實行動態加載。

Jive論壇實現了信息過濾功能。例如可以將帖子內容中的HTML語句過濾掉；可以將帖子內容中Java代碼以特別格式顯示等。這些過濾功能有很多，在實際使用時不一定都需要，是由實際情況選擇的。例如有的論壇就不需要將帖子內容的HTML語句過濾掉，選擇哪些過濾功能是由論壇管理者具體動態決定的。而且新的過濾功能可能隨時可以定制開發出來，如果試圖強行建立一種接口包含所有過濾行為，那么到時有新過濾功能加入時，還需要改變接口代碼，真是一種危險的行為。

裝飾模式可以解決這種運行時需要動態增加功能的問題，且看看Jive是如何實現的。


前面討論過，在Jive中，有主要幾個對象ForumFactory、Forum以及ForumThread和ForumMessage，它們之間的關系如圖3-2所示。因此帖子內容ForumMessage對象的獲得是從其上級FroumThread的方法getMessage中獲取，但是在實際代碼中，ForumThread的方法getMessage委托ForumFactory來獲取ForumMessage對象。看看ForumThread的子類DbForumThread的getMessage代碼：
public ForumMessage getMessage(long messageID)
         throws ForumMessageNotFoundException
{
     return factory.getMessage(messageID, this.id, forumID);
}

這是一種奇怪的委托，大概是因為需要考慮到過濾器功能有意為之吧。那就看看ForumFactory的具體實現子類DbForumFactory的getMessage功能，getMessage是將數據庫中的ForumMessage對象經由過濾器過濾一遍后輸出（注：因為原來的Jive的getMessage代碼考慮到可緩存或不可緩存的過濾，比較復雜，實際過濾功能都是可以緩存的，因此精簡如下）。

protected ForumMessage getMessage(long messageID, long threadID, long forumID)
            throws ForumMessageNotFoundException
{
       DbForumMessage message = cacheManager.messageCache.get(messageID);
        // Do a security check to make sure the message comes from the thread.
        if (message.threadID != threadID) {
         throw new ForumMessageNotFoundException();
         }
        ForumMessage filterMessage = null;
            try {
// 應用全局過濾器
     filterMessage = filterManager.applyFilters(message);
                Forum forum = getForum(forumID);                
                //應用本論壇過濾器
                filterMessage = forum.getFilterManager().applyFilters(filterMessage);
            }
            catch (Exception e) { }
        return filterMessage;
}


上面代碼實際是裝飾模式的客戶端調用代碼，DbForumMessage 的實例message是被油漆者decoratee。通過filterManager 或forum.getFilterManager()的applyFilter方法，將message實行了所有的過濾功能。這就類似前面示例的下列語句：

Work decorator = new Decorator(squarePeg);

forum.getFilterManager()是從數據庫中獲取當前配置的所有過濾器類。每個Forum都有一套自己的過濾器類，這是通過下列語句實現的：

FilterManager filterManager = new DbFilterManager();
在DbFilterManager 的類變量ForumMessageFilter [] filters中保存著所有的過濾器，applyFilters方法實行過濾如下：

public ForumMessage applyFilters(ForumMessage message) {
    for (int i=0; i < filters.length; i++) {
        if (filters[i] != null) {
            message = filters[i].clone(message);
         }
      }
    return message;
}


而ForumMessageFilter是ForumMessage的另外一個子類，被油漆者DbForumMessage通過油漆工ForumMessageFilter增加了一些新的行為和功能（過濾）

這就組成了一個稍微復雜一點的裝飾模式。HTMLFilter實現了HTML代碼過濾功能，而JavaCodeHighLighter實現了Java代碼過濾功能，HTMLFilter代碼如下：
public class HTMLFilter extends ForumMessageFilter {
    public ForumMessageFilter clone(ForumMessage message){
        HTMLFilter filter = new HTMLFilter();
        filter.message = message;
        return filter;
    }
    public boolean isCacheable() {
        return true;
    }
    public String getSubject() {
       return StringUtils.escapeHTMLTags(message.getSubject());

}}

主題監測與觀察者模式
      觀察者（Observer）模式是定義對象之間一對多的依賴關系，當一個被觀察的對象發生改變時，所有依賴于它的對象都會得到通知并采取相應行為。
    使用觀察者模式的優點是將被觀察者和觀察者解耦，從而可以不影響被觀察者繼續自己的行為動作。觀察者模式適合應用于一些“事件觸發”場合。
    在Jive中，用戶也許會對某個主題感興趣，希望關于此主題發生的任何新的討論能通過電子郵件通知他，因此他訂閱監視了這個主題。因為這個功能的實現會引入電子郵件的發送。在前面章節已經討論了電子郵件發送有可能因為網絡原因延遲，如果在有人回復這個主題時，立即進行電子郵件發送，通知所有訂閱該主題的用戶。那么該用戶可能等待很長時間得不到正常回應。
    使用觀察者模式，可以通過觸發一個觀察者，由觀察者通過另外線程來實施郵件發送，而被觀察者發出觸發通知后，可以繼續自己原來的邏輯行為。
  看看Jive的WatchManager類：
public interface WatchManager {
   //正常監察類型，用戶在這個主題更新后再次訪問時，會明顯地發現
   public static final int NORMAL_WATCH = 0;
   // 當主題變化時，通過電子郵件通知用戶
   public static final int EMAIL_NOTIFY_WATCH = 1;
   //設置一個主題被觀察的時間，默認為30天
   public void setDeleteDays(int deleteDays) throws UnauthorizedException;
   public int getDeleteDays();
   //是否激活了E-mail提醒
   public boolean isEmailNotifyEnabled() throws UnauthorizedException;
   public void setEmailNotifyEnabled(boolean enabled) throws UnauthorizedException;
   //保存E-mail的內容
   public String getEmailBody() throws UnauthorizedException;
   public void setEmailBody(String body) throws UnauthorizedException;
   //保存E-mail的主題
   public String getEmailSubject() throws UnauthorizedException;
   public void setEmailSubject(String subject) throws UnauthorizedException;
   …
   //為某個主題創建一個觀察者
   public void createWatch(User user, ForumThread thread, int watchType)
   throws UnauthorizedException;
   //刪除某個主題的觀察者
   public void deleteWatch(User user, ForumThread thread, int watchType)
   //得到一個主題的所有觀察者
   public Iterator getWatchedForumThreads(User user, int watchType)
    throws UnauthorizedException;
   //判斷一個用戶是否在觀察監視該主題
   public boolean isWatchedThread(User user, ForumThread thread, int watchType)
   throws UnauthorizedException;
   …
   }

 DbWatchManager是WatchManager的一個子類，通過數據庫保存著有關某個主題被哪些用戶監視等數據資料。WatchManager對象是隨同  DbForumFactory()一起生成的。

   在DbWatchManager中有一個WatchManager沒有的很重要的方法——通知方法：

 protected void notifyWatches(ForumThread thread) {
   //If watches are turned on.
    if (!emailNotifyEnabled) {
     return;
    }
   //通知所有觀察這個主題的用戶
   EmailWatchUpdateTask task = new EmailWatchUpdateTask(this, factory, thread);
   TaskEngine.addTask(task);
   }
   
       這個方法用來觸發所有有關這個主題的監視或訂閱用戶，以E-mail發送提醒他們。那么這個通知方法本身又是如何被觸發的？從功能上分析，應該是在發表新帖子時觸發。

 在DbForumThread的addMessage的最后一行有一句：
  
   factory.watchManager.notifyWatches(this);

   這其實是調用了DbWatchManager的notifyWatches方法，因此確實是在增加新帖子時觸發了該帖子的所有觀察者。
   notifyWatches方法中在執行E-mail通知用戶時，使用了TaskEngine來執行E-mail發送。E-mailWatchUpdateTask是一個線程類，而TaskEngine是線程任務管理器，專門按要求啟動如E-mailWatchUpdateTask這樣的任務線程。其實TaskEngine是一個簡單的線程池，它不斷通過查詢Queue是否有可運行的線程，如果有就直接運行線程。
   在DbForumThread的addMessage的最后一行有一句：

   factory.watchManager.notifyWatches(this);

   這其實是調用了DbWatchManager的notifyWatches方法，因此確實是在增加新帖子時觸發了該帖子的所有觀察者。
   notifyWatches方法中在執行E-mail通知用戶時，使用了TaskEngine來執行E-mail發送。E-mailWatchUpdateTask是一個線程類，而TaskEngine是線程任務管理器，專門按要求啟動如E-mailWatchUpdateTask這樣的任務線程。其實TaskEngine是一個簡單的線程池，它不斷通過查詢Queue是否有可運行的線程，如果有就直接運行線程。

 

public class TaskEngine {
   //任務列表
   private static LinkedList taskList = null;
   //工作數組
   private static Thread[] workers = null;
   private static Timer taskTimer = null;
   private static Object lock = new Object();
   static {
   //根據配置文件初始化任務啟動時間
   taskTimer = new Timer(true);
   // 默認使用7個線程來裝載啟動任務
   workers = new Thread[7];
   taskList = new LinkedList();
   for (int i=0; i<workers.length; i++) {
   // TaskEngineWorker是個簡單的線程類
   TaskEngineWorker worker = new TaskEngineWorker();
   workers[i] = new Thread(worker);
   workers[i].setDaemon(true);
   workers[i].start(); //啟動TaskEngineWorker這個線程
   }
   }

   //TaskEngineWorker內部類

   private static class TaskEngineWorker implements Runnable {
     private boolean done = false;
     public void run() {
     while (!done) {
     //運行nextTask方法
     nextTask().run();
   }
   } }

   // nextTask()返回的是一個可運行線程，是任務列表Queue的一個讀取者

   private static Runnable nextTask() {
   synchronized(lock) {
    // 如果沒有任務，就鎖定在這里
   while (taskList.isEmpty()) {
   try {
      lock.wait(); //等待解鎖
   } catch (InterruptedException ie) { }
    }

   //從任務列表中取出第一個任務線程
   return (Runnable)taskList.removeLast();
   }
   }

   public static void addTask(Runnable r) {

   addTask(r, Thread.NORM_PRIORITY);

   }

   //這是任務列表Queue的生產者

   public static void addTask(Runnable task, int priority) {

   synchronized(lock) {

   taskList.addFirst(task);

   //提醒所有鎖在lock這里的線程可以運行了

   //這是線程的互相通知機制，可參考線程參考資料

   lock.notifyAll();

   }
   }
   …
   }

  在TaskEngine中啟動設置了一個消息管道Queue和兩個線程。一個線程是負責向Queue里放入Object，可謂是消息的生產者；而另外一個線程負責從Queue中取出Object，如果Queue中沒有Object，那它就鎖定（Block）在那里，直到Queue中有Object，因為這些Object本身也是線程，因此它取出后就直接運行它們。

這個TaskEngine建立的模型非常類似JMS（Java消息系統），雖然它們功能類似，但不同的是：JMS是一個分布式消息發布機制，可以在多臺服務器上運行，處理能力要強大得多。而TaskEngine由于基于線程基礎，因此不能跨JVM實現。可以說TaskEngine是一個微觀組件，而JMS則是一個宏觀架構系統。JMS相關討論將在后面章節進行

以上討論了Jive系統中觀察者模式的實現，Jive使用線程比較基礎的概念實現了觀察者模式，當然有助于了解J2EE很多底層的基礎知識，整個Web容器的技術實現就是基于線程池原理建立的。

Java的JDK則提供了比較方便的觀察者模式API——java.util.Observable和java.util.Observer，它們的用戶非常簡單，只要被觀察者繼承Observable，然后使用下列語句設置觀察點：
 setChanged();
 notifyObservers(name); //一旦執行本代碼，就觸發觀察者了


而觀察者只要實現Observer接口，并實現update方法，在update方法中將被觀察者觸發后傳來的object進行處理。舉例如下：

   網上商店中商品價格可能發生變化，如果需要在價格變化時，首頁能夠自動顯示這些降價產品，那么使用觀察者模式將方便得多。首先，商品是一個被觀察者：

public class product extends Observable{
   private float price;
   public float getPrice(){ return price;}
   public void setPrice(){
   this.price=price;
   //商品價格發生變化，觸發觀察者
   setChanged();
   notifyObservers(new Float(price));
   }
   
   }
 價格觀察者實現observer接口：
   public class PriceObserver implements Observer{
   private float price=0;
   public void update(Observable obj,Object arg){
   if (arg instanceof Float){
   price=((Float)arg).floatValue();
   System.out.println("PriceObserver :price changet to "+price);
   }
   }
   }
這樣，一個簡單的觀察者模式就成功了