文章目录
GOF 定义
责任链模式:
使多个对象都有机会处理请求, 从而避免请求的发送者和接收者之间的耦合关系.
将这些对象连成一条链, 并沿着这条链传递该请求, 直到有一个对象处理他为止.
概述
责任链模式是使用多个对象处理用户请求的成熟模式, 责任链模式的关键是将用户的请求分派给许多对象, 这些对象被组织成一个责任链, 即每个对象含有后继对象的引用, 并且要求责任链上的每个对象, 如果能处理用户的请求, 就做出处理, 不用将用户的请求传递给责任链上的下一个对象; 如果不能处理用户的请求,就必须将用户的请求传递给责任链上的下一个对象.
责任链模式的优点和适合使用责任链模式的情景
优点
- 责任链中的对象只和自己的后继是低耦合关系, 和其他对象毫无关联, 这使得编写处理者对象以及创建责任链变得非常容易.
- 当在处理者中分配职责时, 责任链给应用程序更多的灵活性
- 应用程序可以动态的添加, 删除处理者或者重新指派处理者的职责.
- 应用程序可以动态的改变处理者之间的先后顺序
- 使用责任链的用户不需要知道处理者的信息, 用户不会知道到底是哪个对象处理了它的请求
使用责任链模式的情景
- 有许多对象可以处理用户的请求, 希望程序在运行期间自动处理用户的那个对象
- 希望用户不必明确指定接受者的情况下, 向多个接受者的一个提交请求.
- 程序希望动态指定可处理用户请求的对象集合
模式的结果与使用
两种角色
处理者 (Handler): 处理者是一个接口,负责规定具体处理者处理用户请求的方法以及具体处理者设置后继对象的方法.
具体处理者 (ConcreteHandler): 具体处理者是实现处理者接口的类的实例.
具体处理者通过调用处理者接口规定的方法处理用户的请求, 即在接到用户的请求后, 处理者将调用接口规定的方法, 在执行该方法的过程中, 如果发现能处理用户的请求, 就处理有关数据, 否则就反馈无法处理的信息给用户, 然后将用户的请求传递自己的后继对象.
注意:
由于 java 不支持多重继承, 因此在 java 中, 处理者最好不是一个抽象类, 否则创建具体抽象者的类无法继承其他类, 限制了具体处理者的能力.
案例一: 简单责任链模式(判断身份证号所属区域)
package com.atdhl.responsibilitychain;
import java.util.ArrayList;
/**
* 处理者 Handler
*
* @author DHL
*/
interface Handler {
public void handleRequest(String number);
public void setNextHandler(Handler handler);
}
class Beijing implements Handler {
private Handler handler; // 存放当前处理者后继的Handler 接口变量
private ArrayList<String> numberList; // 存放身份证号码的数组线性表
public Beijing() {
numberList = new ArrayList<String>();
numberList.add("11129812340930034"); // 这里使用模拟身份证号码
numberList.add("10120810340930632");
numberList.add("22029812340930034");
numberList.add("32620810340930632");
}
@Override
public void handleRequest(String number) {
if (numberList.contains(number)) {
System.out.println("他是北京人");
}else {
System.out.println("他不是北京人");
if (null != number) {
handler.handleRequest(number); // 将请求传递给下一个处理者
}
}
}
@Override
public void setNextHandler(Handler handler) {
this.handler = handler;
}
}
class Shanghai implements Handler {
private Handler handler; // 存放当前处理者后继的Handler 接口变量
private ArrayList<String> numberList; // 存放身份证号码的数组线性表
public Shanghai() {
numberList = new ArrayList<String>();
numberList.add("34529812340930034"); // 这里使用模拟身份证号码
numberList.add("98720810340430632");
numberList.add("36529812340930034");
numberList.add("77720810340930632");
}
@Override
public void handleRequest(String number) {
if (numberList.contains(number)) {
System.out.println("他是上海人");
}else {
System.out.println("他不是上海人");
if (null != number) {
handler.handleRequest(number); // 将请求传递给下一个处理者
}
}
}
@Override
public void setNextHandler(Handler handler) {
this.handler = handler;
}
}
class TianJin implements Handler {
private Handler handler; // 存放当前处理者后继的Handler 接口变量
private ArrayList<String> numberList; // 存放身份证号码的数组线性表
public TianJin() {
numberList = new ArrayList<String>();
numberList.add("10029812340930034"); // 这里使用模拟身份证号码
numberList.add("20020810340430632");
numberList.add("30029812340930034");
numberList.add("50020810340930632");
}
@Override
public void handleRequest(String number) {
if (numberList.contains(number)) {
System.out.println("他是天津人");
}else {
System.out.println("他不是天津人");
if (null != number) {
handler.handleRequest(number); // 将请求传递给下一个处理者
}
}
}
@Override
public void setNextHandler(Handler handler) {
this.handler = handler;
}
}
public class DemoOne {
private Handler beijing,shanghai,tianjin;
public void createChain() {
beijing = new Beijing();
shanghai = new Shanghai();
tianjin = new TianJin();
beijing.setNextHandler(shanghai);
shanghai.setNextHandler(tianjin);
}
public void reponseClient(String number) {
beijing.handleRequest(number);
}
public static void main(String[] args) {
DemoOne demo = new DemoOne();
demo.createChain();
demo.reponseClient("50020810340930632");
}
}
案例二: 计算阶乘
package com.atdhl.responsibilitychain;
import java.math.BigInteger;
/**
* 处理者 Handler
*
* @author DHL
*/
interface Handler {
public void compuerMultiply(String number);
public void setNextHandler(Handler handler);
}
class UseInt implements Handler {
private Handler handler;
private int result = 1;
@Override
public void compuerMultiply(String number) {
try {
int n = Integer.parseInt(number);
int i = 1;
while (i <= n) {
result = result * i;
if (result <= 0) {
System.out.println("UseInt :超出我的能力范围, 我计算不了");
handler.compuerMultiply(number);
return;
}
i++ ;
}
System.out.println(number + "的阶层 : " + result);
} catch (Exception e) {
System.out.println(e.toString());
}
}
@Override
public void setNextHandler(Handler handler) {
this.handler = handler;
}
}
class UseLong implements Handler {
private Handler handler;
private long result = 1;
@Override
public void compuerMultiply(String number) {
try {
long n = Long.parseLong(number);
long i = 1;
while (i <= n) {
result = result * i;
if (result <= 0) {
System.out.println("UseLong: 超出我的能力范围, 我计算不了");
handler.compuerMultiply(number);
return;
}
i++ ;
}
System.out.println(number + "的阶层 : " + result);
} catch (Exception e) {
System.out.println(e.toString());
}
}
@Override
public void setNextHandler(Handler handler) {
this.handler = handler;
}
}
class UseBigInteger implements Handler {
private Handler handler;
private BigInteger result = new BigInteger("1");
@Override
public void compuerMultiply(String number) {
try {
BigInteger n = new BigInteger(number);
BigInteger ONE = new BigInteger("1");
BigInteger i = ONE;
while (i.compareTo(n) <= 0) {
result = result.multiply(i);
i = i.add(ONE);
}
System.out.println(number + "的阶层 : " + result);
} catch (Exception e) {
System.out.println(e.toString());
}
}
@Override
public void setNextHandler(Handler handler) {
this.handler = handler;
}
}
public class DemoTwo {
private Handler useInt,useLong,useBig;
public void createChain() {
useInt = new UseInt();
useLong = new UseLong();
useBig = new UseBigInteger();
useInt.setNextHandler(useLong);
useLong.setNextHandler(useBig);
}
public void reponseClient(String number) {
useInt.compuerMultiply(number);
}
public static void main(String[] args) {
DemoTwo demo = new DemoTwo();
demo.createChain();
demo.reponseClient("32");
}
}
