设计模式-责任链模式

定义

• 当发出一个请求，可以由多个对象来进行处理，我们把这些能处理请求的对象链接程一条链，沿着这条链来处理这个请求，直到拿到处理请求的结果为止（这个结果可能是明确的也可能是一个异常的）
• 责任链模式的核心重点在于这个“链”上，这个链是由处理请求对象组成，如果某一个对象不能处理就传递到下一个处理对象上，这样直到拿到结果为止。

UML图

• 责任链模式UML图.png

模版代码

抽象处理类

public abstract class ChainHandler {

    ChainHandler nextChainHandler;
    
    public final HandleResponse handleMessage(HandleRequest handleRequest) {

        HandleResponse handleResponse = null;

        /**
         * 当前请求的等级与自己的等级是相符合的，就进行处理
         * 如果不是自己等级范围内的，就传递给下一个对象来处理
         */
        if (this.getHandleLevel() == handleRequest.getHandleLevel()) {
            handleResponse = handleMethod();
        } else {
            /**
             * 当没有下一个对象来处理这个请求，就返回一个自定义的Response
             */
            if (nextChainHandler != null) {
                handleResponse = this.nextChainHandler.handleMessage(handleRequest);

            } else {
                handleResponse = new HandleResponse();
                handleResponse.setResponseMessage("没有对象来处理，拒绝你的请求");
            }
        }

        return handleResponse;

    }

    /**
     * 获取到每个对象能处理的级别
     *
     * @return
     */
    public abstract int getHandleLevel();

    /**
     * 每个处理对象的处理方法
     */
    public abstract HandleResponse handleMethod();

    /**
     * 设置处理下一个处理请求的对象
     *
     * @param handler
     */
    public void setNextChainHandler(ChainHandler handler) {
        nextChainHandler = handler;
    }
}

• 在抽象处理类中，有三个核心的地方
  • handleMessage()--> 提供通用处理请求的方法，也是唯一对外调用的。
  • 为每一个处理对象设置能处理的范围和自己处理的具体实现细节的抽象方法。
  • 为每一个处理对象设置下一个处理对象的方法 setNextChainHandler()

处理的实现类

public class ChainHandlerOne extends ChainHandler {
    @Override
    public int getHandleLevel() {
        return ConstantLevel.LEVEL_ONE;
    }

    @Override
    public HandleResponse handleMethod() {
        HandleResponse handleResponse = new HandleResponse();
        handleResponse.setResponseMessage("身为大总管，我的考虑一下......,没问题，同意吧！");
        return handleResponse;
    }
}


public class ChainHandlerTwo extends ChainHandler {
    @Override
    public int getHandleLevel() {
        return ConstantLevel.LEVEL_TWO;
    }

    @Override
    public HandleResponse handleMethod() {
        HandleResponse handleResponse = new HandleResponse();
        handleResponse.setResponseMessage("同意，同意，必须得同意");
        return handleResponse;
    }
}


public class ChainHandlerThree extends ChainHandler {
    @Override
    public int getHandleLevel() {
        return ConstantLevel.LEVEL_THREE;
    }

    @Override
    public HandleResponse handleMethod() {
        HandleResponse handleResponse  = new HandleResponse();
        handleResponse.setResponseMessage("既然大家都不处理请求，到我这肯定得同意啊！");
        return handleResponse;
    }
}

客户端类

public class MainActivity extends AppCompatActivity {

    private static final String TAG = "MainActivity";

    private List<HandleRequest> requestList;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        /**
         * 创建三个处理请求的对象
         */
        final ChainHandler chainHandlerOne = new ChainHandlerOne();
        ChainHandler chainHandlerTwo = new ChainHandlerTwo();
        ChainHandler chainHandlerThree = new ChainHandlerThree();

        /**
         * 形成请求处理链
         */
        chainHandlerOne.setNextChainHandler(chainHandlerTwo);
        chainHandlerTwo.setNextChainHandler(chainHandlerThree);

        /**
         * 创建三个请求
         */
        requestList = new ArrayList<>();
        Random random = new Random();
        for (int i = 0; i < 4; i++) {
            HandleRequest handleRequest = new HandleRequest();
            handleRequest.setHandleLevel(random.nextInt(4));
            requestList.add(handleRequest);
        }


        findViewById(R.id.btnStartRequest).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                for (int i = 0; i < requestList.size(); i++) {
                   HandleResponse handleResponse =  chainHandlerOne.handleMessage(requestList.get(i));
                    Log.d(TAG,handleResponse.getResponseMessage());
                }
            }
        });

    }
}

优缺点

优点

• 责任链模式将请求和处理完全分开，请求者可以不用知道谁处理的，处理者也不用知道请求的全部，仅仅关系符合自己的条件的的属性。

缺点

• 责任链，链本身是一个有长度的定义，在我们进行处理的过程中我们需要遍历拿到每一个处理者，类似于递归，如果链比较长的话，那么就需要一定时间，这样它的时间复杂度就升高了，会影响到系统的性能。

注意事项

• 要有效的控制链上处理对象的个数，最好在抽象类中设置设置喜爱一个节点的时候就进行判断是否超过的阈值，有效的控制链上节点数量，可提高运行效率。