目录
前言
一、责任链模式的简介
二、责任链模式的概念
三、责任链模式的作用
四、责任链模式的优、缺点
1.责任链模式的优点
2.责任链模式的缺点
五、责任链模式的应用场景
六、代码案例
UML类图
1.定义一个请求枚举类
2.定义一个请求类
3.定义一个抽象处理接口
4、定义具体处理类
5.Main代码测试
总结
前言
使用责任链模式,它可以动态地添加或删除处理器,从而改变处理请求的顺序和方式。同时,责任链模式也可以减少对象之间的耦合度,提高代码的可扩展性和可维护性。
一、责任链模式的简介
责任链模式(Chin of Responsibility)是一种行为型设计模式,它通过将请求的发送者和接收者解耦来实现请求的处理。
二、责任链模式的概念
责任链模式(Chin of Responsibility):使多个对象都有机会处理请求,从而避免请求的发送者和接受者之间的耦合关系。将这个对象连成一条链子,并沿着这条链传递该请求,直到有一对象处理到它为止。
三、责任链模式的作用
责任链模式(Chin of Responsibility)的作用是将请求的发送者和接收者解耦,使多个对象都有机会处理该请求。它将这些对象连接成一条链,并沿着链传递请求,直到有一个对象处理它为止。
责任链模式的主要作用包括以下:
- 降低系统的耦合度
- 增强系统的灵活性
- 提高代码的可扩展性
- 提高代码的可维护性
四、责任链模式的优、缺点
1.责任链模式的优点
- 降低系统的耦合度:请求发送者和接收者之间不直接交互,而是通过责任链上的多个对象进行交互,从而降低了它们之间的耦合度。
- 增强系统的灵活性:可以动态地增加或删除处理器,从而改变请求的处理顺序和方式。
- 提高代码的可扩展性:因为每个处理器都只负责处理自己能够处理的请求,所以可以方便地添加新的处理器来处理新的请求类型。
- 提高代码的可维护性:因为每个处理器都只负责处理自己能够处理的请求,所以可以方便地添加新的处理器来处理新的请求类型。
2.责任链模式的缺点
- 请求可能没有被处理:如果没有任何一个处理器能够处理该请求,则该请求将被忽略。
- 系统性能可能受影响:由于责任链中可能包含大量的处理器,因此可能会影响系统的性能。
五、责任链模式的应用场景
责任链的使用场景有以下几点:
- 处理请求需要多个对象协作,且不确定哪个对象能够处理请求。
- 需要动态指定能够处理请求的对象集合。
- 需要在不明确接收者的情况下,向多个对象中的一个或多个发送请求。
- 可以通过在运行时添加或删除处理器来改变请求处理的顺序。
- 当一个请求需要被多个对象进行处理时,可以使用责任链模式避免产生复杂的嵌套调用。
- 可以将责任链模式与其他设计模式结合使用,如装饰器模式、工厂模式等,以实现更加灵活的功能。
六、代码案例
UML类图
1.定义一个请求枚举类
RequestType请求枚举
/***
* 定义请求枚举
*/
public enum RequestType {
TYPE_A, TYPE_B, TYPE_C
}
2.定义一个请求类
Request请求类
/***
* 定义请求类
*/
public class Request {
private String name;
private RequestType type;
public Request(String name, RequestType type) {
this.name = name;
this.type = type;
}
public String getName() {
return name;
}
public RequestType getType() {
return type;
}
}
3.定义一个抽象处理接口
定义一个抽象处理器(Handler)类,其中包含一个指向下一个处理器的引用,并定义一个处理请求的方法。
Handler抽象类
/***
* 定义一个抽象处理器(Handler)类,其中包含一个指向下一个处理器的引用,并定义一个处理请求的方法。
*/
public abstract class Handler {
protected Handler successor;
public void setSuccessor(Handler successor) {
this.successor = successor;
}
public abstract void handleRequest(Request request);
}
4、定义具体处理类
ConcreteHandlerA类
/***
* 定义具体处理类
*/
public class ConcreteHandlerA extends Handler {
@Override
public void handleRequest(Request request) {
if (request.getType().equals(RequestType.TYPE_A)) {
System.out.println("ConcreteHandlerA处理请求" +request.getName());
} else if (successor != null) {
successor.handleRequest(request);
}
}
}
ConcreteHandlerB类
/***
* 定义具体处理类
*/
public class ConcreteHandlerB extends Handler {
@Override
public void handleRequest(Request request) {
if (request.getType().equals(RequestType.TYPE_B)) {
System.out.println("ConcreteHandlerB处理请求" + request.getName());
} else if (successor != null) {
successor.handleRequest(request);
}
}
ConcreteHandlerC类
/***
* 定义具体处理类
*/
public class ConcreteHandlerC extends Handler {
@Override
public void handleRequest(Request request) {
if (request.getType().equals(RequestType.TYPE_C)) {
System.out.println("ConcreteHandlerC处理请求" + request.getName());
} else if (successor != null) {
successor.handleRequest(request);
}
}
}
5.Main代码测试
public static void main(String[] args) {
Handler handlerA = new ConcreteHandlerA();
Handler handlerB = new ConcreteHandlerB();
Handler handlerC = new ConcreteHandlerC();
handlerA.setSuccessor(handlerB);
handlerB.setSuccessor(handlerC);
Request request1 = new Request("已处理 1", RequestType.TYPE_A);
Request request2 = new Request("已处理 2", RequestType.TYPE_B);
Request request3 = new Request("已处理 3", RequestType.TYPE_C);
handlerA.handleRequest(request1);
handlerA.handleRequest(request2);
handlerA.handleRequest(request3);
}
输出结果:
总结
这个示例中,具体处理器类实现了抽象处理器接口,并根据自己的能力来判断是否能够处理请求。如果不能处理,则将请求传递给下一个处理器。客户端创建责任链并将请求发送给第一个处理器,处理器依次处理请求,直到有一个处理器能够处理它为止。