if-else结构嵌套多逻辑太复杂？来试试责任链模式 一个例子教会你责任链模式

 复杂的逻辑结构

小伙伴们在刚开始学习if—else结构是不是觉得也不过如此，但是有一天看到了下面一个关于汽车租赁服务的代码你又是什么感受呢

do {
    System.out.println("请选择租车类型:1、轿车2、客车 3、卡车");
    Scanner input = new Scanner(System.in);
    int choose = input.nextInt();
    if (choose > 3 || choose < 0) {
        System.out.println("输入有误请重新输入");
        System.out.println();
        continue;
    }
    switch (choose) {
        case 1:
            System.out.println("请选择品牌:1.红旗2、别克");
            int brandChoose = input.nextInt();
            if (brandChoose == 1) {
                brand = "红旗";
                System.out.println("请选择类型：1.奔腾B50 2.奔腾B70");
                int typeChoose = input.nextInt();
                if (typeChoose > 2 || typeChoose < 0) {
                    System.out.println("输入有误请重新输入");
                    continue;
                }
                type = (typeChoose == 1) ? "奔腾B50" : "奔腾B70";
                System.out.println("请选择颜色：1.白 2.黑");
                int colorChoose = input.nextInt();
                if (colorChoose > 2 || colorChoose < 0) {
                    System.out.println("输入有误请重新输入");
                    continue;
                }
                color = (colorChoose == 1) ? "白" : "黑";
            } else if (brandChoose == 2) {
                brand = "别克";
                System.out.println("请选择类型:1.英朗2.凯越");
                int typeChoose = input.nextInt();
                if (typeChoose > 2 || typeChoose < 0) {
                    System.out.println("输入有误请重新输入");
                    continue;
                }
                type = (typeChoose == 1) ? "英朗" : "凯越";
                System.out.println("请选择颜色：1.白 2.黑");
                int colorChoose = input.nextInt();
                if (colorChoose > 2 || colorChoose < 0) {
                    System.out.println("输入有误请重新输入");
                    continue;
                }
                color = (colorChoose == 1) ? "白" : "黑";
            } else {
                System.out.println("输入有误请重新输入");
                continue;
            }
            break;
        case 2:
            System.out.println("请选择品牌:1.金龙2、金杯");
            brand = (input.nextInt() == 1) ? "金龙" : "金杯";
            System.out.println("请选择座位数:1.16座2、34座");
            int typeChoose = input.nextInt();
            seatCount = (typeChoose == 1) ? 16 : 34;
            System.out.println("请选择颜色：1.白 2.黑");
            int colorChoose = input.nextInt();
            color = (colorChoose == 1) ? "白" : "黑";
            break;
        case 3:
            System.out.println("请选择吨位（输入数字）:1.6吨中型卡车 2、14吨重型卡车");
            weight = (input.nextInt() == 1) ? 6 : 14;
    }
    System.out.print("请输入要租赁的天数:");
    int days = input.nextInt();
    MotoOperation motoOpr = new MotoOperation();
    motoOpr.init();
    MotoVehicle moto = motoOpr.rentVehicle(brand, type, seatCount, color, weight);
    System.out.println("******租车结果*******");
    System.out.println("租车成功 !分配给您的车是:" + moto.getVehicleId());
    price += moto.calRent(days);
    System.out.println("请选择是否继续租车：扣1结束");
    i = input.nextInt();
} while (i != 1);

读完上面的代码感觉到恶心了吗，我却认为你读不下去，因为我也看不进去，太长太恶心了没有注释，阅读这种代码简直是在为难自己。那么有什么好办法去让这种逻辑比较复杂的代码更好阅读以及方便我们的后期维护呢？答案就是今天要介绍的责任链模式。

责任链模式

  在责任链模式里，很多对象由每一个对象对其下家的引用而连接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。发出请求的客户端并不知道链上的哪一个对象最终处理这个请求，这使得系统可以在不影响客户端的情况下动态地重新组织和分配责任。

  看完基础的定义是不是发觉每次请求的传递有点像函数之间的调用，是的这就是类似于递归这种方法，递归和责任链模式都涉及到一种层级或链式的方式来处理问题，即问题（或请求）在某种结构上逐层或逐个传递，直到被处理。如下图所示

请求依次经过Handler1，Handler2…… 这样就能简单的实现if-else结构之间的嵌套的一些功能了那么让我们看看具体的实例是如何通过责任链模式来修改我们原来的代码的呢

例题修改 

 首先我们定义一个接口去规范Handler

public interface RentHandler {
    MotoVehicle handleRequest(int choice);
}

接着来看看每个处理具体的Handler类是如何修改的，在责任链模式中，每个处理器都应该有一个方法来处理请求，并且应该有一个机制来决定是否将请求传递给链中的下一个处理器。这通常是通过在处理器中定义一个指向下一个处理器的引用（通常是一个字段）和一个处理请求的方法来实现的。

public class CarHandler implements RentHandler {
    private RentHandler nextHandler;


    public CarHandler(RentHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public MotoVehicle handleRequest(int choice) {
        if (choice == 1) {
            return rentCar();
        } else if (nextHandler != null) {
            return nextHandler.handleRequest(choice);
        }
        return null;
    }

    private MotoVehicle rentCar() {
        Scanner input = new Scanner(System.in);
        System.out.println("请选择品牌: 1、红旗 2、别克");
        int brandChoose = input.nextInt();
        String brand = (brandChoose == 1) ? "红旗" : "别克";

        String type;
        if (brand.equals("红旗")) {
            System.out.println("请选择类型: 1.奔腾B50 2.奔腾B70");
            int typeChoose = input.nextInt();
            type = (typeChoose == 1) ? "奔腾B50" : "奔腾B70";
        } else {
            System.out.println("请选择类型: 1.英朗 2.凯越");
            int typeChoose = input.nextInt();
            type = (typeChoose == 1) ? "英朗" : "凯越";
        }

        System.out.println("请选择颜色: 1.白 2.黑");
        int colorChoose = input.nextInt();
        String color = (colorChoose == 1) ? "白" : "黑";
        return new Car(brand, type,  color);
    }

}

类似的我们把刚才的案例代码中的所有汽车类型都分别加入类中，最后我们通过这样的代码来传递请求

RentHandler handlerChain = new CarHandler(new BusHandler( new TruckHandler(null)));

看完是不是彻底懵逼了，根本看不懂下面就让我来带着你看看是如何具体实现的

修改分析 

1、责任链的构建 

从CarHandler开始，然后是BusHandler，最后是TruckHandler。这意味着当请求首先到达CarHandler时，它将有机会处理该请求；如果它决定不处理，则请求将传递给BusHandler；依此类推，直到请求被处理或到达链的末尾。

2、处理器的实现

在责任链模式中，每个处理器都应该有一个方法来处理请求，并且应该有一个机制来决定是否将请求传递给链中的下一个处理器。这通常是通过在处理器中定义一个指向下一个处理器的引用（通常是一个字段）和一个处理请求的方法来实现的。例如，每个处理器类可能都会有一个setNextHandler(Handler next)方法来设置下一个处理器，以及一个handleRequest(Request request)方法来处理请求或将其传递给下一个处理器。 

3、请求的传递 

在handleRequest方法中，每个处理器都会检查它是否应该处理当前请求。如果应该处理，则它会执行相应的操作；如果不应该处理，则它会将请求传递给链中的下一个处理器。这通常是通过调用nextHandler.handleRequest(request)（如果nextHandler不为null）来实现的。 

4、链的结束 

TruckHandler是链中的最后一个处理器，并且它被初始化为null。这是责任链的常见做法，以表示链的末尾。然而，在实际实现中，您可能需要确保在TruckHandler（或链中任何其他可能作为最后一个处理器的类）的handleRequest方法中处理null的nextHandler情况，以避免NullPointerException。 

看完上面的解析是不是有点感觉了，原来这就是责任链模式，很快你也就发现了特点，这不就是把刚才的switch—case结构改成了这样的一个一个条件传递判断吗？是的也正是这样这个例子中我们也只是展示一点用处。在下一篇文章我将详细讲清楚优缺点。