OkHttp缓存使用

最新推荐文章于 2024-05-06 04:06:32 发布

折翅鵬

最新推荐文章于 2024-05-06 04:06:32 发布

阅读量692

点赞数

分类专栏： Android 文章标签： android

本文链接：https://blog.csdn.net/szhupeng/article/details/112444286

版权

Android 专栏收录该内容

37 篇文章 2 订阅

订阅专栏

缓存可以不用每次请求时都去服务器拉取数据，可以快速响应数据，提升用户体验，并且还能节省流量。

缓存实现

如果服务器支持缓存，则请求返回的响应头会有Cache-Control响应指令。直接给OkHttpClient设置缓存即可。

Cache cache = new Cache(context.getCacheDir(), 10 * 1024 * 1024);
OkHttpClient client = new OkHttpClient.Builder()
        .cache(cache)
        .connectTimeout(20, TimeUnit.SECONDS)
        .readTimeout(20, TimeUnit.SECONDS)
        .build();

如果服务器不支持缓存，则需要使用Interceptor来重写Respose的头部信息，从而让OkHttp支持缓存。

public class CacheInterceptor implements Interceptor {

    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        Response response = chain.proceed(request);

        CacheControl cacheControl = new CacheControl.Builder()
                .maxAge(15, TimeUnit.MINUTES)
                .build();
                
        Response cacheResponse = response.newBuilder()
                .removeHeader("Pragma")
                .removeHeader("Cache-Control")
                .header("Cache-Control", cacheControl.toString())
                .build();
        return cacheResponse;
    }
}

然后将该拦截器添加到OkHttpClient的网络拦截器中。

Cache cache = new Cache(getCacheDir(), 10 * 1024 * 1024);
OkHttpClient client = new OkHttpClient.Builder()
        .addNetworkInterceptor(new CacheInterceptor())
        .cache(cache)
        .connectTimeout(20, TimeUnit.SECONDS)
        .readTimeout(20, TimeUnit.SECONDS)
        .build();

这样就能让OkHttp支持缓存啦！

自定义缓存实现

上面的实现方式只是基础实现方式，这种实现方式是以URL生成Key来进行DiskLruCache的，而且只限定于Get请求。如果请求URL的参数中有时间戳或者与时间戳有关的参数的化，就会导致缓存失效。对于这种请求，需要自定义缓存实现。

final class CustomCache implements java.io.Closeable, java.io.Flushable {

    private static final int VERSION = 666888;
    private static final int ENTRY_BODY = 0;
    private static final int ENTRY_COUNT = 1;

    private DiskLruCache cache;

    public CustomCache(File file, long maxSize) {
        try {
            cache = DiskLruCache.open(file, VERSION, ENTRY_COUNT, maxSize);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void put(Response response) {
        String requestMethod = response.request().method();
        if (!requestMethod.equals("GET")) {
            return;
        }

        DiskLruCache.Editor editor;
        try {
            String key = key(response.request().url());
            if (TextUtils.isEmpty(key)) {
                return;
            }

            editor = cache.edit(key);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        Buffer copyBuffer = null;
        try {
            BufferedSource source = response.body().source();
            source.request(Long.MAX_VALUE);
            Buffer buffer = source.getBuffer();
            copyBuffer = buffer.clone();
            String body = copyBuffer.readUtf8();
            if (!TextUtils.isEmpty(body)) {
                editor.set(ENTRY_BODY, body);
                editor.commit();
            }
        } catch (IOException e) {
            abortQuietly(editor);
            e.printStackTrace();
        } finally {
            if (copyBuffer != null) {
                copyBuffer.close();
            }
        }
    }

    public String get(Request request) {
        try {
            String key = key(request.url());
            if (TextUtils.isEmpty(key)) {
                return null;
            }
            DiskLruCache.Value snapshot = cache.get(key);
            String body = null;
            if (snapshot != null) {
                body = snapshot.getString(ENTRY_BODY);
            }
            return body;
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

    public void remove(Request request) {
        try {
            String key = key(request.url());
            if (!TextUtils.isEmpty(key)) {
                cache.remove(key);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void remove(String url) {
        try {
            String key = key(url);
            if (!TextUtils.isEmpty(key)) {
                cache.remove(key);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public void update(Response response) {
        String requestMethod = response.request().method();
        if (!requestMethod.equals("GET")) {
            return;
        }

        String key = key(response.request().url());
        if (TextUtils.isEmpty(key)) {
            return;
        }

        try {
            cache.remove(key);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        DiskLruCache.Editor editor;
        try {
            editor = cache.edit(key);
        } catch (IOException e) {
            e.printStackTrace();
            return;
        }

        Buffer copyBuffer = null;
        try {
            BufferedSource source = response.body().source();
            source.request(Long.MAX_VALUE);
            Buffer buffer = source.getBuffer();
            copyBuffer = buffer.clone();
            String body = copyBuffer.readUtf8();
            if (!TextUtils.isEmpty(body)) {
                editor.set(ENTRY_BODY, body);
                editor.commit();
            }
        } catch (IOException e) {
            abortQuietly(editor);
            e.printStackTrace();
        } finally {
            if (copyBuffer != null) {
                copyBuffer.close();
            }
        }
    }

    private void abortQuietly(@Nullable DiskLruCache.Editor editor) {
        try {
            if (editor != null) {
                editor.abort();
            }
        } catch (IOException ignored) {
            ignored.printStackTrace();
        }
    }

    public String key(HttpUrl httpUrl) {
        if (httpUrl == null) {
            return null;
        }

        HttpUrl.Builder builder = new HttpUrl.Builder();
        builder.scheme(httpUrl.scheme()).host(httpUrl.host());
        List<String> segments = httpUrl.pathSegments();
        if (segments != null) {
            for (String segment : segments) {
                builder.addPathSegment(segment);
            }
        }
        Set<String> names = httpUrl.queryParameterNames();
        List<String> nameList = new ArrayList<>(names);
        if (nameList.contains("app_version")) {
            nameList.remove("app_version");
        }
        if (nameList.contains("timestamp")) {
            nameList.remove("timestamp");
        }
        for (String name : nameList) {
            builder.addQueryParameter(name, httpUrl.queryParameter(name));
        }
        return ByteString.encodeUtf8(builder.build().toString()).md5().hex();
    }

    @Override
    public void close() throws IOException {
        cache.close();
    }

    @Override
    public void flush() throws IOException {
        cache.flush();
    }
}

上面是通过处理URL去掉可变参数以后剩下的链接部分作为键进行缓存的实现方式。那么该怎样应用到OKhttp中呢？

class CustomCacheInterceptor implements Interceptor {

    private static final String CONTENT_TYPE = "application/json; charset=utf-8";

    private Context context;
    private CustomCache cache;

    public CustomCacheInterceptor(Context context, CustomCache cache) {
        this.context = context;
        this.cache = cache;
    }

    @NotNull
    @Override
    public Response intercept(@NotNull Chain chain) throws IOException {
        Request request = chain.request();
        if (!NetworkUtils.checkNetwork(context)) {
            String cacheBody = cache.get(request);
            ResponseBody responseBody = !TextUtils.isEmpty(cacheBody) ? ResponseBody.create(cacheBody, MediaType.parse(CONTENT_TYPE)) : Util.EMPTY_RESPONSE;
            return new Response.Builder()
                    .request(chain.request())
                    .protocol(Protocol.HTTP_1_1)
                    .code(200)
                    .message("Return from cache")
                    .body(responseBody)
                    .sentRequestAtMillis(System.currentTimeMillis())
                    .receivedResponseAtMillis(System.currentTimeMillis())
                    .build();
        }

        Response networkResponse = null;
        try {
            networkResponse = chain.proceed(request);
        } finally {
        }

        long sentRequestAtMillis, receivedResponseAtMillis;
        if (networkResponse != null) {
            sentRequestAtMillis = networkResponse.sentRequestAtMillis();
            receivedResponseAtMillis = networkResponse.receivedResponseAtMillis();
            if (networkResponse.isSuccessful()) {
                cache.update(networkResponse);
                return networkResponse;
            }
        } else {
            sentRequestAtMillis = System.currentTimeMillis();
            receivedResponseAtMillis = sentRequestAtMillis;
        }

        String cacheBody = cache.get(request);
        ResponseBody responseBody = !TextUtils.isEmpty(cacheBody) ? ResponseBody.create(cacheBody, MediaType.parse(CONTENT_TYPE)) : Util.EMPTY_RESPONSE;
        return new Response.Builder()
                .request(chain.request())
                .protocol(Protocol.HTTP_1_1)
                .code(200)
                .message("Return from cache")
                .body(responseBody)
                .sentRequestAtMillis(sentRequestAtMillis)
                .receivedResponseAtMillis(receivedResponseAtMillis)
                .build();
    }
}

上面的拦截器只是简单的实现了断网或者网络请求失败的时候使用缓存的情况，可以根据需要自行修改。

最后在构建OkhttpClient的时候加入拦截器就可以实现自定义缓存啦。

CustomCache cache = new CustomCache(new File(getCacheDir(), "cache"), 10 * 1024 * 1024);  //最大缓存10MB
OkHttpClient client = new OkHttpClient.Builder()
        .addInterceptor(new CustomCacheInterceptor(getApplicationContext(), cache))
        .connectTimeout(30, TimeUnit.SECONDS)
        .readTimeout(30, TimeUnit.SECONDS)
        .writeTimeout(50, TimeUnit.SECONDS)
        .build();