责任链模式（Chain of Responsibility Pattern）

责任链模式（Chain of Responsibility Pattern）

使多个对象都有机会处理请求，从而避免了请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止

两个角色

• 抽象处理者（Handler）角色：该角色对请求进行抽象，并定义一个方法以设定和返回对下一个处理者的引用。

• 具体处理者（Concrete Handler）角色：该角色接到请求后，可以选择将请求处理掉，或者将请求传给下一个处理者。由于具体处理者持有对下一个处理者的引用，因此，如果需要，具体处理者可以访问下一个处理者。

例：击鼓传花式责任链模式

• 抽象处理者（Handler）角色

/**
 * @author Jenson
 */
@Data
public abstract class Player {
    private Player successor;

    /**
     * 处理请求
     *
     * @param i
     */
    public abstract void handle(int i);

    /**
     * 传给下一个
     *
     * @param index
     */
    public void next(int index) {
        if (successor != null) {
            successor.handle(index);
        } else {
            System.out.println("游戏结束");
        }
    }
}

• 具体处理者（Concrete Handler）角色

public class PlayerA extends Player {

    public PlayerA(Player successor) {
        this.setSuccessor(successor);
    }

    @Override
    public void handle(int i) {
        if (i == 1) {
            System.out.println("Player A 喝酒！");
        } else {
            System.out.println("Player A 把花往下传！");
            next(i);
        }
    }
}

public class PlayerB extends Player {
    public PlayerB(Player successor) {
        this.setSuccessor(successor);
    }

    @Override
    public void handle(int i) {
        if (i == 2) {
            System.out.println("Player B 喝酒！");
        } else {
            System.out.println("Player B 把花往下传！");
            next(i);
        }
    }
}

public class PlayerC extends Player {

    public PlayerC(Player successor) {
        this.setSuccessor(successor);
    }

    @Override
    public void handle(int i) {
        if (i == 3) {
            System.out.println("Player C 喝酒！");
        } else {
            System.out.println("Player C 把花往下传！");
            next(i);
        }
    }
}

public class PlayerD extends Player {
    public PlayerD(Player successor) {
        this.setSuccessor(successor);
    }

    @Override
    public void handle(int i) {
        if (i == 4) {
            System.out.println("Player D 喝酒！");
        } else {
            System.out.println("Player D 把花往下传！");
            next(i);
        }
    }
}

• 调用者

public class DrumBeater {
    public static void main(String[] args) {
    // 此处构建责任链
    // 责任链是责任模式的重点
    // 在springBoot中可以使用@Bean去构建责任链，通过Bean名称的不同，可以构建多种责任链，在使用时注入即可
        Player player = new PlayerA(new PlayerB(new PlayerC(new PlayerD(null))));

        player.handle(3);
    }
}

想法

其本质也是一种利用多态解决switch的方式

在switch或多重if...else判断的代码中可以使用该模式优化代码结构

em...............

所以说我在上一个命令模式优化switch的实践中使用责任链模式或许会更好一些