过滤器与装饰模式
装饰(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);
   }

   }

   }
这样,一个简单的观察者模式就成功了