设计模式原来这么简单-责任链模式

责任链模式

1.什么是责任链模式

WIKI：在面向对象设计中，责任链模式是一种由源命令对象和一系列处理对象组成的设计模式。每个处理对象包含了其定义的可处理的命令对象类型的逻辑。剩下的会传递给链条中的下一个处理对象。

2.案例

假如要处理一个请求并且要根据请求的级别来决定如何处理。

3.具体实现

@Data
public class RequestEntity {

    public enum RequestType{
        /**
         * 一级请求
         */
        FIRST,
        /**
         * 二级请求
         */
        SECOND,
        /**
         * 三级请求
         */
        THIRD
    }

    private String msg;

    private RequestType requestType;

    public boolean isEmpty(){
        return msg.isEmpty() || requestType == null;
    }
}

public abstract class AbstractRequestHandler {
    protected final AbstractRequestHandler nextHandler;

    protected AbstractRequestHandler(AbstractRequestHandler nextHandler) {
        this.nextHandler = nextHandler;
    }

    protected void doHandlerRequest(RequestEntity requestEntity){
        if(nextHandler != null){
            nextHandler.doHandlerRequest(requestEntity);
        }
    }
}

// 一级请求处理器
public class FirstRequestHandler extends AbstractRequestHandler{

    protected FirstRequestHandler(AbstractRequestHandler nextHandler) {
        super(nextHandler);
    }

    @Override
    protected void doHandlerRequest(RequestEntity requestEntity) {
        if(requestEntity.isEmpty()){
            throw new IllegalArgumentException("不合法的参数");
        }
        if(requestEntity.getRequestType().compareTo(RequestEntity.RequestType.FIRST) == 0){
            // 业务操作
            // ...
            System.out.println(String.format("%s:%s", this, requestEntity.getMsg()));
        }else{
            super.doHandlerRequest(requestEntity);
        }
    }
}
// 二级请求处理器
public class SecondRequestHandler extends AbstractRequestHandler{
    protected SecondRequestHandler(AbstractRequestHandler nextHandler) {
        super(nextHandler);
    }

    @Override
    protected void doHandlerRequest(RequestEntity requestEntity) {
        if(requestEntity.isEmpty()){
            throw new IllegalArgumentException("不合法的参数");
        }
        if(requestEntity.getRequestType().compareTo(RequestEntity.RequestType.SECOND) == 0){
            System.out.println(String.format("%s:%s", this, requestEntity.getMsg()));
        }else{
            super.doHandlerRequest(requestEntity);
        }

    }
}

// 构建责任链
public class ChainOrderBuilder {

    private FirstRequestHandler requestHandler;

    public ChainOrderBuilder(){
        doBuild();
    }

    private void doBuild() {
        requestHandler = new FirstRequestHandler(new SecondRequestHandler(null));
    }

    public void startHandlerRequest(RequestEntity requestEntity){
        requestHandler.doHandlerRequest(requestEntity);
    }
}

@Test
public void test(){
    RequestEntity requestEntity2 = new RequestEntity();
    requestEntity2.setMsg("二级请求Msg");
    requestEntity2.setRequestType(RequestEntity.RequestType.SECOND);

    ChainOrderBuilder chainOrderBuilder = new ChainOrderBuilder();
    chainOrderBuilder.startHandlerRequest(requestEntity2);
}

//输出
com.zyy.chain.SecondRequestHandler@73a8dfcc:二级请求Msg

4.总结

该模式将本可以在一个类中用多个if-else可以实现的需求解耦成多个类实现，使系统的扩展更加灵活。