1、概述
责任链模式是一种行为设计模式， 允许你将请求沿着处理者链进行发送。 收到请求后， 每个处理者均可对请求进行处理， 或将其传递给链上的下个处理者。
责任链
2、适用场景
1）当程序需要使用不同方式处理不同种类请求， 而且请求类型和顺序预先未知时， 可以使用责任链模式。
2）当必须按顺序执行多个处理者时， 可以使用该模式。
3）如果所需处理者及其顺序必须在运行时进行改变， 可以使用责任链模式。
3、实例
与以下场景：
有一条车场质检的流水线。车辆出厂需要经过以下的检查。
颜色color、尺寸size、引擎engine、轮胎tire
使用责任链模式。
创建车辆：
/**
* Car
* @date: 2021/1/12
* @author weirx
* @version 3.0
*/
public class Car {
private String color;
private String size;
private String engine;
private String tire;
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getSize() {
return size;
}
public void setSize(String size) {
this.size = size;
}
public String getEngine() {
return engine;
}
public void setEngine(String engine) {
this.engine = engine;
}
public String getTire() {
return tire;
}
public void setTire(String tire) {
this.tire = tire;
}
public Car(String color, String size, String engine, String tire) {
this.color = color;
this.size = size;
this.engine = engine;
this.tire = tire;
}
}
创建基础抽象：
/**
* 车辆质检
* @date: 2021/1/12
* @author weirx
* @version 3.0
*/
public abstract class CarQualityCheck {
/**
* 下一个
*/
public CarQualityCheck next;
public CarQualityCheck(CarQualityCheck next) {
this.next = next;
}
public CarQualityCheck() {
}
/**
* 校验自己
* @param car
* @return
*/
public abstract boolean checkSelf(Car car);
/**
* 校验下一个
* @param car
* @return
*/
public boolean checkNest(Car car){
if (ObjectUtils.isNotEmpty(next)){
return next.checkSelf(car);
}
System.out.println("当前没有下一个流程，检测完成");
return true;
}
}
创建车辆属性检测类：
/**
* 颜色检查
* @date: 2021/1/12
* @author weirx
* @version 3.0
*/
public class ColorQualityCheck extends CarQualityCheck{
public ColorQualityCheck(CarQualityCheck next) {
super(next);
}
@Override
public boolean checkSelf(Car car) {
if ("red".equals(car.getColor())){
System.out.println("车辆颜色校验通过");
return checkNest(car);
}
System.out.println("车辆颜色校验未通过");
return false;
}
}
/**
* 引擎检查
* @date: 2021/1/12
* @author weirx
* @version 3.0
*/
public class EngineQualityCheck extends CarQualityCheck{
public EngineQualityCheck(CarQualityCheck next) {
super(next);
}
@Override
public boolean checkSelf(Car car) {
if ("1.4".equals(car.getEngine())){
System.out.println("车辆引擎校验通过");
return checkNest(car);
}
System.out.println("车辆引擎校验未通过");
return false;
}
}
/**
* 大小检查
* @date: 2021/1/12
* @author weirx
* @version 3.0
*/
public class SizeQualityCheck extends CarQualityCheck{
public SizeQualityCheck(CarQualityCheck next) {
super(next);
}
@Override
public boolean checkSelf(Car car) {
if ("大".equals(car.getSize())){
System.out.println("车辆大小校验通过");
return checkNest(car);
}
System.out.println("车辆大小校验未通过");
return false;
}
}
/**
* 轮胎检查
* @date: 2021/1/12
* @author weirx
* @version 3.0
*/
public class TireQualityCheck extends CarQualityCheck{
public TireQualityCheck(CarQualityCheck next) {
super(next);
}
public TireQualityCheck() {
}
@Override
public boolean checkSelf(Car car) {
if ("4".equals(car.getTire())){
System.out.println("车辆轮胎校验通过");
return checkNest(car);
}
System.out.println("车辆轮胎未校验通过");
return false;
}
}
创建测试类：
/**
* 测试类
* @date: 2021/1/12
* @author weirx
* @version 3.0
*/
public class TestDemo {
public static void main(String[] args) {
Car car = new Car("red", "大", "1.4", "4");
CarQualityCheck qualityCheck =
new ColorQualityCheck(
new SizeQualityCheck(
new EngineQualityCheck(
new TireQualityCheck()
)
)
);
boolean result = qualityCheck.checkSelf(car);
if (result){
System.out.println("车辆质检通过，可以出场");
}else {
System.out.println("车辆质检未通过，禁止出厂");
}
}
}
结果：
车辆颜色校验通过
车辆大小校验通过
车辆引擎校验通过
车辆轮胎校验通过
当前没有下一个流程，检测完成
车辆质检通过，可以出场
4、分析
从以上例子中看出，客户端可以按照自己的需求组建自己的链，每个链负责自己的业务逻辑，相互之间没有关联。链上的各个节点没有任何业务相关的耦合。
5、总结
优点:
1）你可以控制请求处理的顺序。
2）单一职责原则。 你可对发起操作和执行操作的类进行解耦。
3）开闭原则。 你可以在不更改现有代码的情况下在程序中新增处理者。
缺点：
1）在组装链时，需要注意当前链节点的情况，是否要向下一节点执行，否则会导致请求未被后续责任链处理。
网友评论