责任链模式

责任链模式

定义：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.（使多个对象都有机会处理请求，从而避免了请求的发送者和接受者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有对象处理它为止。）

 

优点：

1. 降低了对象之间的耦合度。该模式使得一个对象无须知道到底是哪一个对象处理其请求以及链的结构，发送者和接收者也无须拥有对方的明确信息。
2. 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则。
3. 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动它们的次序，也可动态地新增或者删除责任。
4. 责任链简化了对象之间的连接。每个对象只需保持一个指向其后继者的引用，不需保持其他所有处理者的引用，这避免了使用众多的 if 或者 if···else 语句。
5. 责任分担。每个类只需要处理自己该处理的工作，不该处理的传递给下一个对象完成，明确各类的责任范围，符合类的单一职责原则。

缺点：

1. 不能保证每个请求一定被处理。由于一个请求没有明确的接收者，所以不能保证它一定会被处理，该请求可能一直传到链的末端都得不到处理。
2. 对比较长的职责链，请求的处理可能涉及多个处理对象，系统性能将受到一定影响。
3. 职责链建立的合理性要靠客户端来保证，增加了客户端的复杂性，可能会由于职责链的错误设置而导致系统出错，如可能会造成循环调用

注意事项：

链中节点数量需要控制，避免出现超长链的情况，一般的做法是在Handler中设置一个最大节点数量，在setNext方法中判断是否已经是超过其阈值，超过则不允许该链建立，避免无意识地破坏系统性能。

实现

步骤 1

//实体类
public class ComputerParameters {

    public String ComputerName;
    public String CPU;
    public String Memory;

    public String getComputerName() {
        return ComputerName;
    }

    public void setComputerName(String computerName) {
        ComputerName = computerName;
    }

    public String getCPU() {
        return CPU;
    }

    public void setCPU(String CPU) {
        this.CPU = CPU;
    }

    public String getMemory() {
        return Memory;
    }

    public void setMemory(String memory) {
        Memory = memory;
    }
}

步骤 2

/*
创建抽象类
 */
public  abstract class AbstractHandler {

    private AbstractHandler abstractHandler;

    public void setAbstractHandler(AbstractHandler abstractHandler)
    {

        this.abstractHandler = abstractHandler;
    }

    public AbstractHandler getAbstractHandler()
    {
       return abstractHandler;
    }

    //处理请求的方法 //抽象处理
    abstract  void hadlerRequest(ComputerParameters computer);
}

步骤 3

//具体处理2
public class ConcreteAbstractHandler1 extends AbstractHandler {


    public void hadlerRequest(ComputerParameters computer) {
        //处理
        if(computer.getComputerName()=="Lenovo") {
            System.out.println("ComputerName:" + computer.getComputerName() + "CPU:" + computer.getCPU() + "Memory" + computer.getMemory());

        }
        else
        {
            //责任链
            if(getAbstractHandler()!=null) {
                getAbstractHandler().hadlerRequest(computer);
            }
        }

    }
}

步骤 4

//具体处理2
public class ConcreteAbstractHandler2 extends AbstractHandler {

    public void hadlerRequest(ComputerParameters computer) {

       //处理
        if(computer.getComputerName()=="DEL")
        {
            System.out.println("ComputerName:" + computer.getComputerName() + "CPU:" + computer.getCPU() + "Memory" + computer.getMemory());

        }
        else
        {
           //责任链
            if(getAbstractHandler()!=null)
            {

                getAbstractHandler().hadlerRequest(computer);
            }
        }

    }
}

步骤 5

/*
责任链模式
 */
public class ChainofResponsibilityPatternDescription {
    public static void main(String[] args) {



        ComputerParameters computerParameters1=new ComputerParameters();
        computerParameters1.setComputerName("Lenovo");
        computerParameters1.setCPU("I5");
        computerParameters1.setMemory("4G");


        ComputerParameters computerParameters2=new ComputerParameters();
        computerParameters2.setComputerName("DEL");
        computerParameters2.setCPU("I7");
        computerParameters2.setMemory("8G");


        ConcreteAbstractHandler1 concreteHandler1 = new ConcreteAbstractHandler1();
        ConcreteAbstractHandler2 concreteHandler2 = new ConcreteAbstractHandler2();


        //组装责任链
        concreteHandler1.setAbstractHandler(concreteHandler2);

       // concreteHandler1.hadlerRequest(computerParameters1);
        concreteHandler1.hadlerRequest(computerParameters2);

    }

}

测试结果：

ComputerName:DELCPU:I7Memory8G