关键点

• 判断请求是否相同: request转key,根据key判断
• 请求进行中: 等待
• 请求已完成: 返回缓存的response
• 过去这段时间后,清除缓存的response

代码实现:

public class SameRequestFilterInterceptor implements Interceptor {

    static WeakHashMap<String, ResonseForClone> responseWeakHashMap = new WeakHashMap<>();
    static WeakHashMap<String, WeakReference<Call>> calls = new WeakHashMap<>();

    static Charset UTF_8 = Charset.forName("UTF-8");
    static IConfig config;
    static boolean enableFilter;
    static boolean debug;
    static Handler handler;

    /**
     * @param enableFilter 全局开关
     * @param config       配置信息
     */
    public static void config(boolean debug, boolean enableFilter, IConfig config) {
        SameRequestFilterInterceptor.enableFilter = enableFilter;
        SameRequestFilterInterceptor.config = config;
        SameRequestFilterInterceptor.debug = debug;
    }


    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        if (!enableFilter) {
            return chain.proceed(request);
        }

        if (config == null) {
            return chain.proceed(request);
        }
        if (!config.shouldFilter(request.url().toString())) {
            return chain.proceed(request);
        }

        String key = generateKey(request);

        return check(chain, request, key);
    }

    private Response check(Chain chain, Request request, String key) throws IOException {
        try {
            //从缓存的call和response中判断要不要等待
            boolean needwait = needwait(key);

            if (!needwait) {
                if (responseWeakHashMap.containsKey(key)) {
                    return responseWeakHashMap.get(key).getClonedResonse();
                } else {
                    //直接执行请求:
                    //将response缓存起来
                    return realExceute(chain, request, key);
                }
            } else {
                Thread.sleep(2000);
                return check(chain, request, key);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
            if (responseWeakHashMap.containsKey(key)) {
                return responseWeakHashMap.get(key).getClonedResonse();
            } else {
                //直接执行请求:
                //将response缓存起来
                return realExceute(chain, request, key);
            }
        }
    }

    @NonNull
    private Response realExceute(Chain chain, Request request, String key) throws IOException {
        calls.put(key, new WeakReference<>(chain.call()));
        Response response = chain.proceed(request);


        if (response.isSuccessful() && response.body() != null) {
            ResponseBody responseBody = response.body();
            BufferedSource source = responseBody.source();
            source.request(responseBody.contentLength() > 0 ? responseBody.contentLength() : Integer.MAX_VALUE);
            //吓人?
            Buffer buffer = source.buffer();
            Charset charset = UTF_8;
            MediaType contentType = responseBody.contentType();
            if (contentType != null) {
                charset = contentType.charset(UTF_8);
            }
            String bodyString = buffer.clone().readString(charset);

            ResponseBody cloneBody = ResponseBody.create(response.body().contentType(), bodyString);

            Response responseClone = new Response.Builder()
                    .code(response.code())
                    .protocol(response.protocol())
                    .message(response.message())
                    .body(cloneBody)
                    .headers(response.headers())
                    .header("cachedResonse", "yes")
                    .request(request)
                    .build();
            responseWeakHashMap.put(key, new ResonseForClone(bodyString, responseClone));
            calls.remove(key);
            getMainHandler().postDelayed(new Runnable() {
                @Override
                public void run() {
                    //1min后移除缓存的response:
                    responseWeakHashMap.remove(key);
                    logw(config.responseCacheTimeInMills() + "时间到了,清除缓存的response");
                }
            }, config.responseCacheTimeInMills());

        }

        return response;
    }

    private static Handler getMainHandler() {
        if (handler == null) {
            handler = new Handler(Looper.getMainLooper());
        }
        return handler;
    }

    private boolean needwait(String key) {
        if (responseWeakHashMap.containsKey(key)) {
            logw("有缓存的response,直接去读缓存,并组装新的response");
            return false;
        }
        if (calls.containsKey(key)) {
            WeakReference<Call> callWeakReference = calls.get(key);
            if (callWeakReference == null) {
                logw("不需要等待,直接发请求 call WeakReference not exist:");
                return false;
            }
            Call call = callWeakReference.get();
            if (call == null || call.isCanceled()) {
                logw("不需要等待,直接发请求 call not exist or is canceld:" + call);
                return false;
            }
            logw("请求可能正在等待或正在执行-needwait call is running:" + call);
            //请求可能正在等待或正在执行
            return true;
        }
        logw("任何地方都没有,不需要等,直接执行请求");
        //任何地方都没有,不需要等,直接执行请求
        return false;
    }

    private static void logw(String str) {
        if (debug) {
            Log.w("requestFilter", str);
        }
    }

    /**
     * @param request
     * @return
     */
    private String generateKey(Request request) {

        return config.generateCacheKey(request);
    }

    class ResonseForClone {
        String body;
        Response response;

        public ResonseForClone(String body, Response response) {
            this.body = body;
            this.response = response;
        }

        public Response getClonedResonse() {
            ResponseBody cloneBody = ResponseBody.create(response.body().contentType(), body);
            Response responseClone = new Response.Builder()
                    .code(response.code())
                    .protocol(response.protocol())
                    .message(response.message())
                    .body(cloneBody)
                    .headers(response.headers())
                    .header("cachedResonse", "yes")
                    .request(response.request())
                    .build();
            return responseClone;
        }
    }

    public interface IConfig {
        boolean shouldFilter(String url);

        String generateCacheKey(Request request);

        long responseCacheTimeInMills();
    }
}

使用:

SameRequestFilterInterceptor.config(Config.enableLog(), true, new SameRequestFilterInterceptor.IConfig() {
            @Override
            public boolean shouldFilter(String url) {
                return true;
            }

            @Override
            public String generateCacheKey(Request request) {
                return request.url().toString();
            }

            @Override
            public long responseCacheTimeInMills() {
                return 60000;
            }
        });

commonInterceptors.add(new SameRequestFilterInterceptor());

demo:

for (int i = 0; i < 20; i++) {
            request();
        }

日志:

image.png