JAVA学习网首页 把生活查询网加入收藏 把JAVA学习网设为首页 联系方式
    Hi,JAVA学习
JAVA基础 设计模式 数据库 JavaBeans J2EE JavaDelphi 用户界面 综合文章  
[Behavioral Patterns] Chain of Responsibility
时间:22/04/2007
作者：网络
来源：网络
小提示→点这里把文章加入您的收藏夹,方便下次查看
设置文章字体大小：[大 中 小]

 Intent 


Avoid coupling the sender of a request to its receiver by giving more than one object a chance to handle the request. Chain the receiving objects and pass the request along the chain until an object handles it. 

 Problem 


There is a potentially variable number of "handler" objects and a stream of requests that must be handled. Need to efficiently process the requests without hard-wiring handler relationships and precedence, or request-to-handler mappings. 

 Structure 


Steps are as follow:

1. Base class maintains a "next" pointer
2. Each "link" does its part to handle (and/or pass on) the request
3. Client "launches and leaves" each request with the chain
4. The current bid and bidder are maintained in chain static members
5. The last link in the chain assigns the job to the low bidder

  2. /**
  3.  * This class is the abstract class from which all elements in the 
  4.  * chain inherit. 
  5.  */
  6. public abstract class Handler 
  7. { 
  8.     //HAS: 
  9.     //Each element in the chain has a title (such as secretary), a 
  10.     //superior (such as Governer), and a beurocratic response to use 
  11.     //in responding to a letter that it handles. 
  12.     Handler superior = null; 
  13.     String title; 
  14.     //note the irony of the static nature of the beurocratic response. 
  15.     static final String beurocraticResponse = "Thank you for your letter. It's not our fault. Send us more money.  Sincerely, Governer Taft."; 
  16.     
  17.     //There is no CONSTRUCTOR becuase the class is abstract. 
  18.     
  19.     //METHODS: 
  20.     //This method changes from chain element to chain element 
  21.     //because each element uses different criteria to evaluate 
  22.     //whether the letter is handleable and there is no method body 
  23.     //filled in in the abstract class. 
  24.     abstract boolean canHandle(Letter kvetch); 
  25.     
  26.     //This method remains constant for all chain elements, and so can 
  27.     //be written here once and for all. 
  28.     public Letter handleLetter(Letter kvetch) 
  29.     { 
  30.         //if the element in the chain can handle the letter, 
  31.         if(this.canHandle(kvetch)) 
  32.         { 
  33.         //Send a reply. 
  34.         return new Letter(kvetch.getSender(), "Governor Taft", beurocraticResponse, kvetch.getSubject());
  35.         } 
  36.         
  37.         //otherwise, it becomes my bosses problem. 
  38.         else if(superior != null) 
  39.         { 
  40.         return superior.handleLetter(kvetch);
  41.         } 
  42.         //The Governor doesn't have a boss whose problem it can 
  43.         //become, so just in case, we account for this exception. 
  44.         throw new java.lang.RuntimeException("Invalid Recipient -- No one can handle this problem.");
  45.     }
  46. } 
  47.   
  48. public class Letter extends Object 
  49. { 
  51.     //HAS: 
  52.     //The letter has four parts (four Strings): A string to represent 
  53.     //the recipient, sender, content of the letter (text), and subject 
  54.     //of the letter. Each object in the chain uses the subejct string 
  55.     //to determine whether it can handle the letter. 
  56.     String recipient = new String(""); 
  57.     String sender = new String(""); 
  58.     String text = new String(""); 
  59.     String subject = new String(""); 
  60.     
  61.     //CONSTRUCTOR 
  62.     public Letter(String isTo, String isFrom, String contents, String topic) 
  63.     { 
  64.         //Always a good idea to call the super's constructor. 
  65.         super(); 
  66.         //initializations for the letter happen in its constructor. 
  67.         setRecipient(isTo); 
  68.         setSender(isFrom); 
  69.         setText(contents); 
  70.         setSubject(topic);
  71.     } 
  72.     
  73.     //Accessor METHODS for each of the four strings. 
  74.     public String getRecipient() 
  75.     { 
  76.         return this.recipient;
  77.     } 
  79.     public String getSender() 
  80.     { 
  81.         return this.sender;
  82.     } 
  84.     public String getText() 
  85.     { 
  86.         return this.text;
  87.     } 
  89.     public String getSubject() 
  90.     { 
  91.         return this.subject;
  92.     } 
  94.     private void setRecipient(String isTo) 
  95.     { 
  96.         this.recipient = isTo;
  97.     } 
  98.     
  99.     private void setSender(String isFrom) 
  100.     { 
  101.         this.sender = isFrom;
  102.     } 
  104.     private void setText(String contents) 
  105.     { 
  106.         this.text = contents;
  107.     } 
  109.     private void setSubject(String topic) 
  110.     { 
  111.         this.subject = topic;
  112.     } 
  114.     //Overriden toString METHOD so that we can use letters as the selected items in the combobox. 
  115.     public String toString() 
  116.     { 
  117.         return this.getSubject();
  118.     }
  119. } 
  121. public class Governer extends Handler 
  122. { 
  123.     //CONSTRUCTOR  for Governor is different from all the other 
  124.     //handlers because it doesn't have a "boss" and thus its superior is 
  125.     //set to null. 
  126.     public Governer() 
  127.     { 
  128.         super(); 
  129.         this.superior= null; 
  130.         this.title = "Governer";
  131.     } 
  133.     //METHOD 
  134.     public boolean canHandle(Letter kvetch) 
  135.     { 
  136.         //The Governer only handles donations. 
  137.         if(kvetch.getSubject().equalsIgnoreCase("Donation")) return true; 
  138.         else return false;
  139.     }
  141. } 
  143. public class Secretary extends Handler 
  144. { 
  145.     //CONSTRUCTOR 
  146.     public Secretary(Handler boss) 
  147.     { 
  148.         super(); 
  149.         this.superior = boss; 
  150.         this.title = "Secretary";
  151.     } 
  153.     //METHOD 
  154.     public boolean canHandle(Letter kvetch) 
  155.     { 
  156.         //The Secretary only handles accusations. 
  157.         if(kvetch.getSubject().equalsIgnoreCase("Accusation")) return true; 
  158.         else return false;
  159.     }
  160. } 
  161.   
  164. //The concrete extender of HANDLER, the LACKEY class: 
  166. public class Lackie extends Handler 
  167. { 
  169.     //CONSTRUCTOR 
  170.     public Lackie(Handler boss) 
  171.     { 
  172.         super(); 
  173.         this.superior = boss; 
  174.         this.title = "Lackie";
  175.     } 
  177.     //METHOD 
  178.     public boolean canHandle(Letter kvetch) 
  179.     { 
  180.         //The Lackey only handles inquiries. 
  181.         if(kvetch.getSubject().equalsIgnoreCase("Inquiry")) return true; 
  182.         else return false;
  183.     }
  184. } 
  186. public class MailClerk extends Handler 
  187. { 
  189.     //CONSTRCUTOR 
  190.     public MailClerk(Handler boss) 
  191.     { 
  192.         super(); 
  193.         this.superior = boss; 
  194.         this.title = "Mail Clerk";
  195.     } 
  197.     //METHOD 
  198.     public boolean canHandle(Letter kvetch) 
  199.     { 
  200.         //The Mail Clerk only handles criticisms. 
  201.         if(kvetch.getSubject().equalsIgnoreCase("Criticism")) return true; 
  202.         else return false;
  203.     }
  205. } 
  207. public class ChainDemo2 {
  208.     public static void main(String[] args) {
  209.         //Instantiate the chain IN THIS ORDER!!! 
  210.         //Otherwise, they don't have bosses to use in their constructors. 
  211.         Governer taft = new Governer(); 
  212.         Secretary marcia = new Secretary(taft); 
  213.         Lackie joe = new Lackie(marcia); 
  214.         MailClerk annie = new MailClerk(joe);  
  215.     }
  216. }

 When to use 


This pattern deals with the relationship between a set of objects and a request. You apply this pattern when more than one object can handle a request. The first object in the chain gets the request and either resolves it or moves it along to the next object in the chain, until one can handle it. The original requesting object doesn't know which object will handle its request. The object that ultimately handles the request it said to be and implicit receiver. Restaurants are set up this way; a customer typically doesn't send a request directly to a chef and isn't usually acquainted with the chef the request is going to do. Instead, the customer gives and order to a server, the server gets it to the chef, who might fulfils the order or pass it along to an assistant chef. 
上一篇：pet store 的设计目标

下一篇：Take Command of Your Software (1)

  • Javamail操作指南(二)
  • 告别System.out.print()—J2SDK1.4新增Java日志框架(一）
  • 用SQLJ开发数据库
  • 使用org.apache.commons.beanutils个人感受
  • 一个Jsp初学者的学习过程（三）
  • JDK Observer设计模式之研究
  • 一个判断session是否过期的小技巧
  • 《Effective Java》学习笔记(3)
  • 我对构架MVC的理解
  • 使用多线程技术让你的Swing及时响应各类事件
  • Portal开源实现-Liferay的Portlet Session处理(1)
  • JAVA的学习体会
  • 无进度条刷新获得服务器端数据并相应处理
  • 屏蔽鼠标右键，F1帮助和常用快捷键
  • Adapter模式在J2SE事件处理中的应用
  • 对synchronized(this)的一些理解
  • JAVA专业术语集
  • java程序如何穿透带有密码验证的代理
    		•
    【返回】 【顶部】 【关闭】
    Copyright © 2005-2010 www.594k.com All Rights Reserved.
    版权所有:JAVA学习网 备案序号:皖ICP备06004238号