了解设计模式 之 行为模式(一) -- 责任链模式

 下面的一系列文章主要是描述设计模式中的行为模式，也是本系列文章的最后一个部分了。

按照在网络上搜到的定义：行为模式是对在不同对象之间划分算法和职责的抽象化，行为模式不仅描述对象或类本身，还描述了他们之间的交互。

行为模式是设计模式中最大的一类了，个人感觉行为模式来自于现实生活中的某些行为的抽象，也是在实际应用中使用的比较多的一类模式。

行为模式主要包括责任链模式(Chain of Responsibility)，命令模式(Command)，解释器模式(Interpreter)，迭代器模式(Iterator)，中介者模式(Mediator)，备忘录模式(Memento)，观察者模式(Observer)，状态模式(State)，策略模式(Strategy)，模版方法模式(Template Method)，访问者模式(Visitor)。

在后面的文章中将会一一的叙述，首先来看一下责任链模式。

1. 责任链模式(Chain of Responsibility Pattern)

如果您看过Tomcat的源代码，一定对里边的管道模式(Pipeline)记忆犹新；如果您了解Servlet规范的话，一定会知道Filter；如果您使用过Struts2的话，一定清楚无处不在的interceptor。上边的这些概念可以说都是责任链模式的抽象，或者说变种，下面我们就来看一下"原生态"的责任链模式。

责任链模式顾名思义，对一个请求设计出一个链状的处理流程，处于链条上的每个类都可以处理这个请求，或者放弃对请求的处理然后交给链条上的下一个类。

一个"纯粹"的责任链模式应该是请求只能交给责任链上的一个类去处理，而不是每个类处理一部分，后者应该叫变种的责任链。还是举个简单的例子来说明吧，就举一个产品的客户打电话寻求帮助的例子吧。

假如客户买了某公司的一个产品，可是发现产品出了问题，于是打电话到部门A询问，部门A告诉他去问一下部门B，部门B再让他问一下部门C...... 以此类推，最后部门Z终于给他解决了问题。

下面贴一下实现的代码，首先要有一系列的部门，这些部门就是责任链上的一系列类。

第一个是部门的基类：

Java代码  

1. /**  
2.  * 部门基类<br>  
3.  *   
4.  */  
5. public abstract class Department {   
6.   
7.     protected Department successor;   
8.   
9.     /**  
10.      * 处理方法，调用此方法处理请求  
11.      */  
12.     public abstract void handleRequest();   
13.   
14.     /**  
15.      * 赋值方法，调用此方法设置下家  
16.      *   
17.      * @param successor  
18.      */  
19.     public void setSuccessor(Department successor) {   
20.         this.successor = successor;   
21.     }   
22.   
23.     /**  
24.      * 取值方法，得到下家对象  
25.      *   
26.      * @return  
27.      */  
28.     public Department getSuccessor() {   
29.         return successor;   
30.     }   
31. }  

/**
 * 部门基类<br>
 * 
 */
public abstract class Department {

	protected Department successor;

	/**
	 * 处理方法，调用此方法处理请求
	 */
	public abstract void handleRequest();

	/**
	 * 赋值方法，调用此方法设置下家
	 * 
	 * @param successor
	 */
	public void setSuccessor(Department successor) {
		this.successor = successor;
	}

	/**
	 * 取值方法，得到下家对象
	 * 
	 * @return
	 */
	public Department getSuccessor() {
		return successor;
	}
}

后边的部门子类都要继承这个类，然后覆盖handleRequest方法去处理用户请求，另外，successor是指如果这个部门不能处理的话，将请求转接给的下一个部门。

然后来看一个用户请求的抽象，部门的具体实现会用到，这里先列出来。这个类本质上不是cor的一个组成部分。

Java代码  

1. /**  
2.  * 客户发出的请求类型<br>  
3.  *   
4.  */  
5. public class Request {   
6.     public enum RequestType {   
7.         /** 产品错误 */  
8.         ProductError,   
9.         /** 功能使用 */  
10.         FunctionUsage,   
11.         /** 其他请求 */  
12.         Others   
13.     }   
14.   
15.     private RequestType type;   
16.   
17.     public Request(RequestType type) {   
18.         this.type = type;   
19.     }   
20.   
21.     public RequestType getType() {   
22.         return type;   
23.     }   
24.   
25. }  

/**
 * 客户发出的请求类型<br>
 * 
 */
public class Request {
	public enum RequestType {
		/** 产品错误 */
		ProductError,
		/** 功能使用 */
		FunctionUsage,
		/** 其他请求 */
		Others
	}

	private RequestType type;

	public Request(RequestType type) {
		this.type = type;
	}

	public RequestType getType() {
		return type;
	}

}

下面来看几个部门的具体实现：

Java代码  

1. /**  
2.  * 销售部门<br>  
3.  *   
4.  */  
5. public class SalesDepartment extends Department {   
6.   
7.     @Override  
8.     public void handleRequest(Request request) {   
9.         /* 判断请求的类型来决定哪种请求来自己处理，哪种抛给Successor */  
10.         if (request.getType() == Request.RequestType.FunctionUsage) {   
11.             System.out.println("SalesDepartment: The request is handled here.");   
12.         } else if (getSuccessor() != null) {   
13.             getSuccessor().handleRequest(request);   
14.         } else {   
15.             System.out.println("The request cannot be handled");   
16.         }   
17.     }   
18. }   
19.   
20.   
21. /**  
22.  * 开发部门<br>  
23.  *   
24.  */  
25. public class DevelopDepartment extends Department {   
26.   
27.     @Override  
28.     public void handleRequest(Request request) {   
29.         /* 判断请求的类型来决定哪种请求来自己处理，哪种抛给Successor */  
30.         if (request.getType() == Request.RequestType.ProductError) {   
31.             System.out.println("DevelopDepartment: The request is handled here.");   
32.         } else if (getSuccessor() != null) {   
33.             getSuccessor().handleRequest(request);   
34.         } else {   
35.             System.out.println("The request cannot be handled");   
36.         }   
37.     }   
38.   
39. }  

/**
 * 销售部门<br>
 * 
 */
public class SalesDepartment extends Department {

	@Override
	public void handleRequest(Request request) {
		/* 判断请求的类型来决定哪种请求来自己处理，哪种抛给Successor */
		if (request.getType() == Request.RequestType.FunctionUsage) {
			System.out.println("SalesDepartment: The request is handled here.");
		} else if (getSuccessor() != null) {
			getSuccessor().handleRequest(request);
		} else {
			System.out.println("The request cannot be handled");
		}
	}
}


/**
 * 开发部门<br>
 * 
 */
public class DevelopDepartment extends Department {

	@Override
	public void handleRequest(Request request) {
		/* 判断请求的类型来决定哪种请求来自己处理，哪种抛给Successor */
		if (request.getType() == Request.RequestType.ProductError) {
			System.out.println("DevelopDepartment: The request is handled here.");
		} else if (getSuccessor() != null) {
			getSuccessor().handleRequest(request);
		} else {
			System.out.println("The request cannot be handled");
		}
	}

}

最后是调用它的客户端代码：

Java代码  

1. public class Client {   
2.   
3.     /**  
4.      * @param args  
5.      */  
6.     public static void main(String[] args) {   
7.         Department sales = new SalesDepartment();   
8.         Department develop = new DevelopDepartment();   
9.            
10.         sales.setSuccessor(develop);   
11.            
12.         Request funcReq = new Request(Request.RequestType.FunctionUsage);   
13.         Request errorReq = new Request(Request.RequestType.ProductError);   
14.         Request otherReq = new Request(Request.RequestType.Others);   
15.            
16.         sales.handleRequest(funcReq);   
17.         sales.handleRequest(errorReq);   
18.         sales.handleRequest(otherReq);   
19.     }   
20.   
21. }  

public class Client {

	/**
	 * @param args
	 */
	public static void main(String[] args) {
		Department sales = new SalesDepartment();
		Department develop = new DevelopDepartment();
		
		sales.setSuccessor(develop);
		
		Request funcReq = new Request(Request.RequestType.FunctionUsage);
		Request errorReq = new Request(Request.RequestType.ProductError);
		Request otherReq = new Request(Request.RequestType.Others);
		
		sales.handleRequest(funcReq);
		sales.handleRequest(errorReq);
		sales.handleRequest(otherReq);
	}

}

这样，一个完整的责任链例子就写完了。

最后，给出责任链模式的类图：