begin 2021年12月11日20:47:41 。

责任链模式

定义

                      
                        Avoid coupling the sender of a request to its receiver by giving more than one
object a chance to handle the request. Chain the receiving objects and pass the
request along the chain until an object handles it. ——《Design Patterns: Elements of Reusable Object-Oriented Software》

                      
                    

使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将接收对象连城一条链，并沿着链传递该请求，直到有一个对象处理它为止。 ——《设计模式：可复用面向对象软件的基础》 。

责任链模式是一种行为型设计模式.

使用场景

在以下场景下使用责任链模式:

• 有多个对象处理一个请求时，且处理者不知道处理优先级。
• 你想让多个处理者处理一个请求，不需要知道具体处理者。
• 处理请求的对象集合应该是自动确定的。

总的来说，就是处理请求的处理者有多个，但是客户端只知道其中一个，其他都是主动排好队，等着处理请求的.

图示

责任链结构图:

角色

客户端(Client):

• 初始化请求给责任链上的一个具体处理者

抽象处理者(Handler):

• 定义一个处理请求的接口
• 设置下一位处理者的引用

具体处理者(Handler):

• 处理它负责的请求
• 如果具体处理者可以处理请求，就处理；否则，将请求交给它的继承者

请求(Request):

• 封装了需要处理的信息，传递给处理者进行处理。

代码示例

                      
                        // 抽象处理者类
abstract class Handler {
    protected Handler successor;

    public void setSuccessor(Handler successor) {
        this.successor = successor;
    }

    public abstract void handleRequest(Request request);
}

// 具体处理者类A
class HandlerA extends Handler {
    public void handleRequest(Request request) {
        if (request.getType() == RequestType.TYPE_A) {
            // 处理请求
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 具体处理者类B
class HandlerB extends Handler {
    public void handleRequest(Request request) {
        if (request.getType() == RequestType.TYPE_B) {
            // 处理请求
        } else if (successor != null) {
            successor.handleRequest(request);
        }
    }
}

// 请求类
class Request {
    private RequestType type;

    public Request(RequestType type) {
        this.type = type;
    }

    public RequestType getType() {
        return type;
    }
}

// 请求类型枚举类
enum RequestType {
    TYPE_A, TYPE_B
}

// 使用示例
public class Client {
    public static void main(String[] args) {
        Handler handlerA = new HandlerA();
        Handler handlerB = new HandlerB();
        handlerA.setSuccessor(handlerB);

        Request request1 = new Request(RequestType.TYPE_A);
        handlerA.handleRequest(request1);

        Request request2 = new Request(RequestType.TYPE_B);
        handlerA.handleRequest(request2);
    }
}

                      
                    

故事版代码示例

产房内哇的一声啼哭，你已经降临这个世界.

你慢慢长大，学习，工作，结婚生子.

爸妈永远是你的支持.

                      
                        public interface Support {
    void setSuccessor(Support successor);
    void handle(You you);
}

public class MaMa implements Support {
    private String name = "妈妈";
    private Support successor;
    @Override
    public void setSuccessor(Support successor) {
        this.successor = successor;
    }

    @Override
    public void handle(You you) {
        if (you.getObtainType() == ObtainType.NAME) {
            System.out.println(name + ":怀孕了，起个好听的名字");
            successor.handle(you);
        } else if (you.getObtainType() == ObtainType.BORN) {
            System.out.println(name + ":十月怀胎，你出生了");
            successor.handle(you);
        } else if (you.getObtainType() == ObtainType.EDUCATION) {
            System.out.println(name + ":十六年努力工作，提供给你最好的教育");
            successor.handle(you);
        } else if (you.getObtainType() == ObtainType.WORK) {
            System.out.println(name + ":给你鼓励");
            successor.handle(you);
        } else if (you.getObtainType() == ObtainType.MARRIAGE) {
            System.out.println(name + ":倾尽所有买房买车");
            successor.handle(you);
        }
    }
}

public class BaBa implements Support{
    private String name = "爸爸";
    private Support successor;
    @Override
    public void setSuccessor(Support successor) {
        this.successor = successor;
    }

    @Override
    public void handle(You you) {
        if (you.getObtainType() == ObtainType.NAME) {
            System.out.println(name + ":让岳父起个好听的名字");
            successor.handle(you);
        } else if (you.getObtainType() == ObtainType.BORN) {
            System.out.println(name + ":高兴");
            successor.handle(you);
        } else if (you.getObtainType() == ObtainType.EDUCATION) {
            System.out.println(name + ":十六年和妈妈一起努力工作，提供给你最好的教育");
            successor.handle(you);
        } else if (you.getObtainType() == ObtainType.WORK) {
            System.out.println(name + ":给你指导");
            successor.handle(you);
        } else if (you.getObtainType() == ObtainType.MARRIAGE) {
            System.out.println(name + ":和妈妈一起倾尽所有买房买车");
            successor.handle(you);
        }
    }
}

public class WaiGong implements Support {
    private String name = "外公";
    private Support successor;
    @Override
    public void setSuccessor(Support successor) {
        this.successor = successor;
    }

    @Override
    public void handle(You you) {
        if (you.getObtainType() == ObtainType.NAME) {
            System.out.println(name + ":名叫晓月");
        } else if (you.getObtainType() == ObtainType.BORN) {
            System.out.println(name + ":你们多了一份责任");
        } else if (you.getObtainType() == ObtainType.EDUCATION) {
            System.out.println(name + ":暑假的大热天的扇子，冬天热乎的番薯");
        } else if (you.getObtainType() == ObtainType.WORK) {
            System.out.println(name + ":你很努力，也很棒");
        } else if (you.getObtainType() == ObtainType.MARRIAGE) {
            System.out.println(name + ":开心看到你结婚");
        }
    }
}

public class Family {
    public static void main(String[] args) {
        // 爸爸
        BaBa baBa = new BaBa();
        // 妈妈
        MaMa maMa = new MaMa();
        // 外公
        WaiGong waiGong = new WaiGong();

        // 结婚，爸爸成了妈妈的支持
        maMa.setSuccessor(baBa);
        // 外公对爸爸说，我们是一家人，我可以成为你的支持
        baBa.setSuccessor(waiGong);
        // 妈妈怀孕了
        You you = new You();
        you.setAge(-1);
        // 你一生的支持，103岁die
        while(you.getAge() < 103) {
            // 你主观或者客观提出了请求
            produceRequest(you);
            // 家人支持处理你的请求
            handleRequest(you, maMa);
            // 下一重要阶段
            setNextAge(you);
        }

    }

    private static void setNextAge(You you) {
        if (you.getAge() == -1) {
            you.setAge(0);
        } else if (you.getAge() == 0) {
            you.setAge(3);
        } else if (you.getAge() >= 3 && you.getAge() < 22) {
            you.setAge(22);
        } else if (you.getAge() >= 22 && you.getAge() < 24) {
            you.setAge(24);
        } else if (you.getAge() == 24) {
            you.setAge(103);
        }
    }

    private static void handleRequest(You you, MaMa maMa) {
        maMa.handle(you);
    }

    private static void produceRequest(You you) {
        if (you.getAge() == -1) {
            you.setObtainType(ObtainType.NAME);
        } else if (you.getAge() == 0) {
            you.setObtainType(ObtainType.BORN);
        } else if (you.getAge() >= 3 && you.getAge() < 22) {
            you.setObtainType(ObtainType.EDUCATION);
        } else if (you.getAge() >= 22 && you.getAge() < 24) {
            you.setObtainType(ObtainType.WORK);
        } else if (you.getAge() == 24) {
            you.setObtainType(ObtainType.MARRIAGE);
        }
    }
}

                      
                    

代码示例结果:

优点

责任链模式的优点在于它可以将请求的处理分散到多个对象中，降低了对象之间的耦合度。同时，责任链模式也比较灵活，可以动态地组织处理者链，以满足不同的需求.

缺点

但是责任链模式也有一些缺点。首先，由于每个处理者都要处理请求，因此处理者链过长或者处理者数量过多可能会影响性能。其次，如果处理者链没有被正确组织，可能会导致请求无法得到处理或者处理不当的情况发生.

总结

当你需要多个处理者处理一个请求，并想任意组合处理者时，可以使用责任链模式。该模式具有降低耦合，以及灵活组织处理者的优点.

2023年03月19日17:36:53 。

最后此篇关于责任链模式的文章就讲到这里了,如果你想了解更多关于责任链模式的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。