转自：http://zddava.iteye.com/blog/375811
下面的一系列文章主要是描述设计模式中的行为模式，也是本系列文章的最后一个部分了。
按照在网络上搜到的定义：行为模式是对在不同对象之间划分算法和职责的抽象化，行为模式不仅描述对象或类本身，还描述了他们之间的交互。
行为模式是设计模式中最大的一类了，个人感觉行为模式来自于现实生活中的某些行为的抽象，也是在实际应用中使用的比较多的一类模式。
行为模式主要包括责任链模式(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);
}
}
这样，一个完整的责任链例子就写完了。
最后，给出责任链模式的类图：
分享到：
相关推荐
责任链模式是软件设计模式中的一种行为模式，它允许将请求沿着处理者对象的链进行传递，直到某个对象处理该请求。在Spring框架中，责任链模式被广泛应用于AOP（面向切面编程）和事件处理等场景。下面将详细阐述责任...
责任链模式是设计模式中的一种行为模式，它允许在对象之间建立一条处理请求的链条，每个对象都包含对请求的处理逻辑，以及将请求传递给下一个对象的能力。这种模式使得请求可以在链上的对象之间传递，直到被某个对象...
职责链模式（ChainOfResponsibilityPattern）是一种行为设计模式，主要目的是通过建立一个处理请求的对象链，使得请求可以在链上的各个对象间传递，直到被某个对象处理。这种模式可以有效地解耦请求发起者和处理者，...
责任链模式是一种设计模式，它允许我们把请求沿着处理者对象的链进行传递，直到某个对象处理这个请求。这种模式让请求的发送者和接收者解耦，因为发送者无需知道哪个对象会处理请求，而接收者也无需知道请求来自哪里...
职责链模式（Chain of Responsibility）是一种行为设计模式，它的核心思想是将一系列处理请求的对象组织成一条链，每个对象都包含对请求的处理或传递的责任。在C++中实现职责链模式，我们可以创建一个抽象处理器类，...
责任链模式是一种设计模式，它允许我们通过定义一系列处理请求的对象来形成一条链，每个对象都包含对请求的处理逻辑，以及将请求传递给链中下一个对象的能力。这种模式使得我们可以将请求的发送者和接收者解耦，使得...
责任链模式是一种行为设计模式，它允许我们把请求沿着处理者对象的链式结构进行传递，直到某个对象处理这个请求。这种模式使得我们能够将请求的发送者与接收者解耦，同时也允许在运行时动态地改变处理顺序或添加新的...
本篇将探讨两种重要的行为设计模式：责任链模式（Chain of Responsibility Pattern）和状态模式（State Pattern）。 **责任链模式**是一种使多个对象都有机会处理请求的模式，避免请求发送者与接收者之间的耦合。在...
职责链模式（Chain of Responsibility）是一种行为设计模式，它允许我们沿着对象链传递请求，让每个对象决定是否处理这个请求，或者将请求传递给链中的下一个对象。在C#中，我们可以利用类和接口来实现这种模式。让...
责任链模式是一种行为设计模式，它的核心思想是将请求的发送者和接收者解耦，通过将多个处理对象串联成一个处理链，使得请求沿着这个链进行传递，直到被某个对象处理。这种模式使得系统更加灵活，可以在运行时动态...
责任链模式是一种设计模式，它允许我们通过定义一系列处理请求的对象来解耦发送者和接收者。在责任链模式中，每个对象都是链上的一个节点，可以处理请求的一部分或者将请求传递给链上的下一个对象。这种模式使得系统...
【职责链模式】是行为型模式的一种，其主要动机是解耦请求的发送者和处理者。在职责链中，多个对象可以接收并处理同一个请求，这些对象形成一条链，请求沿着链传递，直到某个对象负责处理。这种方式减少了对象间的...
责任链模式是一种设计模式，它允许我们通过定义一系列处理对象（过滤器）形成一个链，这些对象依次处理请求，而发送者无需知道哪个对象具体处理请求。这种模式将请求的发送者与接收者解耦，增加了系统的灵活性和可...
责任链模式是一种行为设计模式，它允许将请求沿着处理者对象的链进行发送，而接收者可以在链中的任何位置处理该请求。这种模式的核心思想是将处理请求的对象组织成一个链条，每个对象（节点）都包含对下个处理者的...
责任链模式是一种行为设计模式，它允许我们定义一系列处理请求的对象，这些对象形成一个链，请求沿着这个链传递，直到某个对象能够处理它。这种方式使得我们可以将请求的发送者和接收者解耦，同时增加了系统扩展的...
一、责任链模式 现有 “战士”、“班长”、“排长”、“连长”，“营长”五种角色，当有人要请假时要进行以下处理 1.只能是下级象上级请假（如“排长”只能向“连长请假”） 2.班长可以批准1天内的假期，排长批5天，...
责任链模式（Chain of Responsibility）是一种行为设计模式，它允许将请求沿着处理者对象的链进行传递，直到某个对象能够处理这个请求为止。在Java中，我们可以通过接口和类的组合来实现这种模式。让我们深入探讨...
责任链模式（Chain of Responsibility Pattern）是设计模式中的一种行为模式，它的主要目的是将请求的发送者和接收者解耦，使得多个对象有机会处理这个请求，形成一条责任链。在这个链上，请求会沿着链传递，直到有...
责任链模式是一种设计模式，它允许我们通过定义一系列处理对象（每个对象称为一个节点），将请求在这些对象之间传递，直到被某个节点处理或者传递完整个链条。这种模式的主要优点在于解耦了发送者和接收者，使得系统...