设计模式之《责任链模式》

责任链模式的概念

责任链模式是一种行为型设计模式，它允许你将请求沿着处理链传递，直到有一个处理者能够处理该请求为止。

在责任链模式中，每个处理者都有自己的逻辑处理方式，当该处理者无法处理该请求时，它会将请求传递给下一个处理者，直到请求被处理为止。这种模式可以有效地避免项目中出现大量 if else 语句的情况，同时也方便代码的维护。

为什么用责任链模式

使用责任链模式的好处在于，它可以有效地处理复杂的业务场景。在实际项目中，往往存在多种业务逻辑需要进行处理，同时这些业务的处理顺序也可能会有所不同。使用责任链模式可以将这些业务逻辑进行灵活组合，并且能够随时调整处理顺序，提高代码的可维护性和扩展性。

工作中用在哪里

在Android开发中，使用责任链模式的场景比较多。比如，我们在进行网络请求时，可能需要对请求进行拦截和处理，比如判断网络是否可用、是否需要进行重试、是否需要缓存等等。这些处理逻辑可能是有先后顺序的，这时就可以采用责任链模式来组合这些处理逻辑。

设计思路

在设计责任链模式时，需要定义一个抽象处理者的接口，该接口定义了处理请求的方法和设置下一个处理者的方法。然后定义具体的处理者类，它们分别实现抽象处理者接口，并在处理请求时进行逻辑处理。最后将这些处理者组合成一条链，每个处理者都设置它的下一个处理者。

代码实现

我们以Android的网络请求为例，实现一个简单的责任链模式。

首先定义一个抽象的请求处理者接口：

public interface RequestHandler {

    void handleRequest(Request request, Chain chain);

    interface Chain {

        Request request();

        void proceed(Request request);
    }
}

上述接口定义了处理请求的方法 handleRequest 和设置下一个处理者的方法 proceed。其中，Chain接口定义了获取请求对象的方法 request()，每个处理者可以通过该方法获取请求的信息，并通过调用 proceed()方法将请求传递给下一个处理者。

然后定义具体的请求处理者：

public class NetworkAvailableHandler implements RequestHandler {

    @Override
    public void handleRequest(Request request, Chain chain) {
        if (isNetworkAvailable()) {
            chain.proceed(request);
        } else {
            // 网络不可用，直接返回错误信息
            request.setError(new Error("Network is not available"));
            // 处理完成，回调请求结果
            onRequestFinished(request);
        }
    }

    private boolean isNetworkAvailable() {
        // 判断当前网络是否可用
        return true;
    }
}

public class RetryHandler implements RequestHandler {

    private static final int MAX_RETRY_COUNT = 3;

    @Override
    public void handleRequest(Request request, Chain chain) {
        int retryCount = 0;
        while (retryCount < MAX_RETRY_COUNT) {
            try {
                chain.proceed(request);
                break;
            } catch (IOException e) {
                retryCount++;
            }
        }
    }
}

public class CacheHandler implements RequestHandler {

    @Override
    public void handleRequest(Request request, Chain chain) {
        if (request.isCacheEnabled() && isCached(request.getUrl())) {
            // 如果缓存可用，直接从缓存中获取数据
            request.setResult(getCache(request.getUrl()));
            // 处理完成，回调请求结果
            onRequestFinished(request);
        } else {
            // 如果缓存不可用，继续往下处理
            chain.proceed(request);
        }
    }

    private boolean isCached(String url) {
        // 判断当前请求是否已经缓存
        return false;
    }

    private String getCache(String url) {
        // 从缓存中获取数据
        return null;
    }
}

其中，NetworkAvailableHandler 类判断网络是否可用；RetryHandler 类实现了请求的重试逻辑；CacheHandler 类实现了请求的缓存逻辑。

最后将这些处理者对象组成一条处理链：

RequestHandler cacheHandler = new CacheHandler();
RequestHandler retryHandler = new RetryHandler();
RequestHandler networkHandler = new NetworkAvailableHandler();

cacheHandler.setNextHandler(retryHandler);
retryHandler.setNextHandler(networkHandler);

其中，setNextHandler() 方法用于设置当前处理者的下一个处理者对象。

最终，将请求对象传入处理链的第一个处理者中，经过一系列处理后，请求的结果将通过 onRequestFinished() 方法进行回调。

Android OkHttp中的责任链

在Android OkHttp中，拦截器使用责任链模式来处理网络请求和响应。每个拦截器都有机会在发送请求之前和处理响应之后进行拦截和修改。

责任链模式的使用使得每个拦截器都能够自由地处理请求和响应，并在需要时将控制权传递给下一个拦截器。这种设计模式使得拦截器的添加和删除非常方便，并且每个拦截器都可以独立于其他拦截器进行修改和重用。

下面是一个简单的例子来演示Android OkHttp中拦截器的责任链模式使用：

// 创建一个自定义的拦截器
class CustomInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        // 在发送请求之前进行拦截和修改
        Request request = chain.request();
        // 修改请求头
        request = request.newBuilder()
                .addHeader("Authorization", "Bearer token")
                .build();

        // 继续执行下一个拦截器或者请求
        Response response = chain.proceed(request);

        // 在处理响应之后进行拦截和修改
        // 修改响应内容
        Response modifiedResponse = response.newBuilder()
                .addHeader("Cache-Control", "no-cache")
                .build();

        return modifiedResponse;
    }
}

// 创建OkHttpClient并添加拦截器
OkHttpClient client = new OkHttpClient.Builder()
        .addInterceptor(new CustomInterceptor())
        .build();

// 创建请求
Request request = new Request.Builder()
        .url("https://api.example.com/data")
        .build();

// 发送请求
Response response = client.newCall(request).execute();

在这个例子中，CustomInterceptor是一个自定义的拦截器，它在发送请求之前添加了一个请求头，并在处理响应之后添加了一个响应头。

当执行client.newCall(request).execute()时，OkHttp会按照添加的顺序依次调用每个拦截器的intercept()方法。每个拦截器可以对请求和响应进行自由地修改或者拦截，并通过chain.proceed()方法将控制权传递给下一个拦截器。最后，返回最终的响应。

拦截器的责任链模式使得我们可以灵活地处理网络请求和响应，可以根据自己的需求添加、删除和修改拦截器，从而满足不同的业务需求。

总结

责任链模式可以灵活地处理多重业务逻辑，同时也能够随时调整处理顺序，提高代码的可维护性和扩展性。在Android开发中，使用责任链模式可以方便地处理网络请求、事件分发等复杂业务场景。