设计模式之职责链

参考博文： https://www.cnblogs.com/kym/archive/2009/04/06/1430078.html  侵权删除

职责链    所有具体处理者对象形成一种单链表的结构。

2019-06-27  10:53:13

什么是职责链：一个请求可能有多个接受者，但是最后真正的接受者只有一个。如果请求发送者内部持有所有接受者，这个时候请求发送者和接受者的耦合过高。　　　　

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

适用性：一个请求多个接受者的情况，但最后接受者只有一个。

职责链基本成员：

　　抽象处理者：将具体处理者抽象，使得具体处理类中可以多态地指向下一个处理者。

　　具体处理者：成员变量中持有下一个具体处理类，实现抽象处理者中的方法（判断是否能够处理，不能则将请求传给下一个具体处理者）。

　　客户端：发出请求。

职责链的基本代码：

/**
 * @InterfaceName Handler
 * @Author wangyudi
 * @Date 2019/6/27 10:40
 * @Version 1.0
 */
public interface Handler {
    boolean canHandle(Request req);
    void handle(Request req);
}

/**
 * @ClassName ConcreteHandler1
 * @Author wangyudi
 * @Date 2019/6/27 10:41
 * @Version 1.0
 */
public class ConcreteHandler1 implements Handler{
    private Handler nextHandler;

    public Handler getNextHandler() {
        return nextHandler;
    }

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public boolean canHandle(Request req) {
        if(req.getType()==RequestType.RequestType1) return true;
        return false;
    }

    @Override
    public void handle(Request req) {
        if(canHandle(req)) {
            System.out.println("handler 1");
        }
        if(nextHandler!=null)
            nextHandler.handle(req);
    }
}


/**
 * @ClassName ConcreteHandler1
 * @Author wangyudi
 * @Date 2019/6/27 10:41
 * @Version 1.0
 */
public class ConcreteHandler2 implements Handler{
    private Handler nextHandler;

    public Handler getNextHandler() {
        return nextHandler;
    }

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public boolean canHandle(Request req) {
        if(req.getType()==RequestType.RequestType2) return true;
        return false;
    }

    @Override
    public void handle(Request req) {
        if(canHandle(req)) {
            System.out.println("handler 2");
        }
        if(nextHandler!=null)
            nextHandler.handle(req);
    }
}


/**
 * @ClassName ConcreteHandler1
 * @Author wangyudi
 * @Date 2019/6/27 10:41
 * @Version 1.0
 */
public class ConcreteHandler3 implements Handler{
    private Handler nextHandler;

    public Handler getNextHandler() {
        return nextHandler;
    }

    public void setNextHandler(Handler nextHandler) {
        this.nextHandler = nextHandler;
    }

    @Override
    public boolean canHandle(Request req) {
        if(req.getType()==RequestType.RequestType3) return true;
        return false;
    }

    @Override
    public void handle(Request req) {
        if(canHandle(req)) {
            System.out.println("handler 3");
        }
        if(nextHandler!=null)        nextHandler.handle(req);
    }
}

/**
 * @ClassName TestCase
 * @Author wangyudi
 * @Date 2019/6/27 10:47
 * @Version 1.0
 */
public class TestCase {
    public static void main(String[] args) {、
    //请求
        Request request = new Request(RequestType.RequestType3);
    //具体处理者
        ConcreteHandler1 concreteHandler1 = new ConcreteHandler1();
        ConcreteHandler2 concreteHandler2 = new ConcreteHandler2();
        ConcreteHandler3 concreteHandler3 = new ConcreteHandler3();
        //连接
        concreteHandler1.setNextHandler(concreteHandler2);
        concreteHandler2.setNextHandler(concreteHandler3);
       // 将请求传给头处理者
        concreteHandler1.handle(request);
    }
}



//结果
handler 3