设计模式第七讲-责任链模式

Posted 2021-04-25 呆呆熊的技术路

简介

责任链模式的定义：使多个对象都有机会处理请求，从而避免请求的发送者和接受者之间的耦合关系

将这个对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理他为止。

图例

责任链-根据事情大小来决定责任向上冒泡到谁身上

场景设置

如上图－DBA某人把线上数据库删了

不好的代码实现

package responsibility;

/**
 * 事故类
 */
public class Accident {

    //紧急程度
    private int fireLevel = 0;

    public Accident(int fireLevel) {
        this.fireLevel = fireLevel;
    }

    /**
     * 事件处理
     */
    public void fire() {

        if (this.fireLevel < 2) {
            System.out.println("运维组长处理了");
        } else if (this.fireLevel < 5) {
            System.out.println("CTO处理了");
        } else {
            System.out.println("BOSS处理了");
        }

    }

}

调用(传入事件等级):

Accident accident = new Accident(3);
accident.fire();

output:

CTO处理了

使用责任链模式

首先设置下请求对象(方便调用传参):

package responsibility;

public class Request {

    private String requestMsg;

    private Integer requestLevel;

    public Request(String requestMsg, int requestLevel) {
        this.requestMsg = requestMsg;
        this.requestLevel = requestLevel;
    }

    public String getRequestMsg() {
        return this.requestMsg;
    }

    public Integer getRequestLevel() {
        return this.requestLevel;
    }

}

设置基类handler

package responsibility;

public abstract class Handler {

    /**
     * 管理者名字
     */
    protected String name;

    /**
     * 管理者对象
     */
    protected Handler superior;


    public Handler(String name) {
        this.name = name;
    }

    //设置管理者上级
    public void SetHandler(Handler superior) {

        this.superior = superior;
    }

    //紧急请求
    abstract public void Fire(Request request);
}

运维组长职能类

package responsibility;

public class OperationLeader extends Handler {

    public OperationLeader(String name) {
        super(name);
    }

    /**
     * 运维组长处理
     *
     * @param request
     */
    public void Fire(Request request) {
        if (request.getRequestLevel() < 2) {
            System.out.println(this.name + "处理了" + request.getRequestMsg());
        } else {
            if (this.superior != null) {
                this.superior.Fire(request);
            }
        }

    }
}

CTO类

package responsibility;

public class CtoLeader extends Handler {

    public CtoLeader(String name) {
        super(name);
    }

    /**
     * CTO处理
     *
     * @param request
     */
    public void Fire(Request request) {
        if (request.getRequestLevel() < 5) {
            System.out.println(this.name + "处理了" + request.getRequestMsg());
        } else {
            if (this.superior != null) {
                this.superior.Fire(request);
            }
        }

    }
}

大boss类

package responsibility;

public class Boss extends Handler {

    public Boss(String name) {
        super(name);
    }

    /**
     * CTO处理
     *
     * @param request
     */
    public void Fire(Request request) {

        System.out.println(this.name + "处理了" + request.getRequestMsg());

    }
}

调用:

Request request = new Request("xx数据库被删了", 3);

        OperationLeader operationLeader = new OperationLeader("运维组长");
        CtoLeader ctoLeader = new CtoLeader("CTO");
        Boss boss = new Boss("野兽");

        //DBA上级
        operationLeader.SetHandler(ctoLeader);
        //运维组长上级
        ctoLeader.SetHandler(boss);
        //boss兜底

        //最先收到事故的为运维组长
        operationLeader.Fire(request);

output：

Request request = new Request("xx数据库被删了", 3);

OperationLeader operationLeader = new OperationLeader("运维组长");
CtoLeader ctoLeader = new CtoLeader("CTO");
Boss boss = new Boss("野兽");

//DBA上级
operationLeader.SetHandler(ctoLeader);
//运维组长上级
ctoLeader.SetHandler(boss);
//boss兜底

//DBA最先报警
operationLeader.Fire(request);

UML类图

总结

优点:

• 将请求的发送者和接受者解耦

• 可以简化你的对象,因为它不需要知道链的结构

• 通过改变链内的成员和次序,允许你动态的新增和删除责任

缺点:

• 对象变得多了,相应对象管理比较复杂

• 一个请求有可能末端都得不到处理,或者因为没有正确配置没有处理