设计模式学习笔记——责任链模式

原文：http://blog.csdn.net/hackerain/article/details/7565777

定义：

使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系，将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。

在这里举一个用户注册的例子，这个例子源于《设计模式之禅》上关于本模式的讲解，说是作者在实际项目中用到的这个责任链模式，我这里进行了简化操作，该例子描述如下：用户分为两类，VIP用户户和普通用户，VIP用户是在他们公司办理过业务的用户，注册时只要提供VIP序列号和其他一些必要信息就可以了，激活是通过发送邮件激活的，而普通用户注册，则需要填写电话号码，并且激活账号是通过发送手机短信来激活的。

在这里处理两种注册的类就成了责任链，用户的注册信息从责任链一端传入，若是自己的处理级别则处理，否则往责任链的下一级传送，直到该注册信息被处理。这里责任链只是由两个类构成的，比较简单，其类图如下：

实现代码如下：

[java]  view plain copy

1. public abstract class User {  
2.       
3.     public static final int VIP=1;//VIP用户  
4.     public static final int COMMON=2;//普通用户  
5.       
6.     private int type;//用户的类型  
7.     private String name;//用户名  
8.     private String password;//密码  
9.       
10.     public User(int type, String name, String password) {  
11.         this.type = type;  
12.         this.name = name;  
13.         this.password = password;  
14.     }  
15.       
16.     public int getType() {  
17.         return type;  
18.     }  
19.     public void setType(int type) {  
20.         this.type = type;  
21.     }  
22.     public String getName() {  
23.         return name;  
24.     }  
25.     public void setName(String name) {  
26.         this.name = name;  
27.     }  
28.     public String getPassword() {  
29.         return password;  
30.     }  
31.     public void setPassword(String password) {  
32.         this.password = password;  
33.     }  
34. }  

[java]  view plain copy

1. /* 
2.  * VIP用户是在公司已经有过业务的，注册时只需要提供VIP序列号就可以了 
3.  */  
4. public class VIPUser extends User {  
5.       
6.     private String VIPNum;//VIP序列号  
7.       
8.     public VIPUser(int type, String name, String password) {  
9.         super(type, name, password);  
10.     }  
11.       
12.     public String getVIPNum() {  
13.         return VIPNum;  
14.     }  
15.   
16.     public void setVIPNum(String vIPNum) {  
17.         VIPNum = vIPNum;  
18.     }  
19.       
20.     public String toString(){  
21.         return this.getName()+" "+this.getPassword()+" "+this.getType()+" "+this.getVIPNum();  
22.     }  
23. }  

[java]  view plain copy

1. /* 
2.  * 普通用户，没有在公司办理过业务，则需要提供电话号码 
3.  */  
4. public class CommonUser extends User {  
5.   
6.     private String mobileNum;//电话号码  
7.   
8.     public CommonUser(int type, String name, String password) {  
9.         super(type, name, password);  
10.     }  
11.       
12.     public String getMobileNum() {  
13.         return mobileNum;  
14.     }  
15.   
16.     public void setMobileNum(String mobileNum) {  
17.         this.mobileNum = mobileNum;  
18.     }  
19.       
20.     public String toString(){  
21.         return this.getName()+" "+this.getPassword()+" "+this.getType()+" "+this.getMobileNum();  
22.     }  
23. }  

[java]  view plain copy

1. public abstract class Handler {  
2.     public final static int VIP_LEVEL_REQUEST=1;  
3.     public final static int COMMON_LEVEL_REQUEST=2;  
4.       
5.     private int level=0;//能处理的级别  
6.     private Handler nextHandler;//责任链传递，下一个责任链是谁  
7.       
8.     public Handler(int level,Handler nextHandler){  
9.         this.level=level;  
10.         this.nextHandler=nextHandler;  
11.     }  
12.       
13.     //设置下一个处理类  
14.     public void setNext(Handler handler){  
15.         this.nextHandler=handler;  
16.     }  
17.       
18.     //注册，由子类去多态的实现  
19.     public abstract void register(User user);  
20.       
21.         //此处也体现了模板方法模式  
22.     public final void HandleRequest(User user){  
23.         if(user.getType()==this.level){//如果用户类型本类能处理的级别，在在本类中进行处理  
24.             this.register(user);  
25.         }  
26.         else{//否则在下一个负责人不为空的情况下，移交给下一个负责人处理  
27.             if(this.nextHandler!=null){  
28.                 this.nextHandler.HandleRequest(user);  
29.             }  
30.             else{  
31.                 System.out.println("can not handle");  
32.             }  
33.         }  
34.     }  
35. }  

[java]  view plain copy

1. public class CommonHandler extends Handler {  
2.   
3.     public CommonHandler(int level, Handler nextHandler) {  
4.         super(level, nextHandler);  
5.     }  
6.   
7.     @Override  
8.     public void register(User user) {  
9.         CommonUser commonUser=(CommonUser)user;  
10.         System.out.println("您的注册信息为："+commonUser.toString());  
11.         System.out.println("已向您的手机："+commonUser.getMobileNum()+"发送激活码...\n");  
12.     }  
13. }  

[java]  view plain copy

1. public class VIPHandler extends Handler {  
2.   
3.     public VIPHandler(int level, Handler nextHandler) {  
4.         super(level, nextHandler);  
5.     }  
6.   
7.     @Override  
8.     public void register(User user) {  
9.         VIPUser vipUser=(VIPUser)user;  
10.         System.out.println("您的注册信息为："+vipUser.toString());  
11.         System.out.println("已向您的邮箱中发送了一封确认邮件，请注意查收...\n");  
12.     }  
13. }  

[java]  view plain copy

1. public class Client {  
2.     public static void main(String[] args) {  
3.           
4.         VIPUser vipUser=new VIPUser(User.VIP,"suo","123456h");  
5.         vipUser.setVIPNum("88888888");  
6.           
7.         CommonUser commonUser=new CommonUser(User.COMMON,"piao","654321h");  
8.         commonUser.setMobileNum("15200852293");  
9.           
10.         Handler commonHandler=new CommonHandler(Handler.COMMON_LEVEL_REQUEST,null);  
11.         Handler vipHandler=new VIPHandler(Handler.VIP_LEVEL_REQUEST,null);  
12.           
13.         commonHandler.setNext(vipHandler);//指定下一个处理类  
14.           
15.         commonHandler.HandleRequest(vipUser);  
16.         commonHandler.HandleRequest(commonUser);  
17.     }  
18. }  

责任链模式的优点：

将请求和处理分开，特别是当请求和处理相对较复杂的时候，将两者解耦，提高系统的灵活性。责任链模式屏蔽了请求的处理过程，你发起一个请求到底是谁处理的，这个不用关心，只要把请求抛给责任链的第一个处理者，最终会返回一个结果。

责任链模式的缺点：

缺点很明显，即当责任链过长，则会影响性能，所以一般的做法是在Handler中设置一个最大的结点数量，在setNext()方法中判断是否已经超过阀值。