Okhttp基本用法和流程分析

2016-08-03 本文已影响7200人小鱼爱记录

本文基于compile 'com.squareup.okhttp3:okhttp:3.0.1'

OkHttp的时序图

1.基本用法

这里我是将Okhttp和Retrofit一起使用的
Okhttp执行底层的网络请求，Retrofit负责网络调度，有关Retrofit的更多可参考我的另一篇博文：Retrofit基本用法和流程分析
1.初始化

    public static void init() {
        HttpLoggingInterceptor logging = new HttpLoggingInterceptor();
        logging.setLevel(HttpLoggingInterceptor.Level.BODY);

        sClient = new OkHttpClient.Builder()
                .retryOnConnectionFailure(true)
                .connectTimeout(15, TimeUnit.SECONDS)
                .readTimeout(300, TimeUnit.SECONDS)
                .writeTimeout(300, TimeUnit.SECONDS)
                .cache(new Cache(Constants.HTTP_CACHE_DIR, Constants.CACHE_SIZE))
                .addInterceptor(logging)//第三方的日志拦截器
                .addInterceptor(appIntercepter)//自定义的应用拦截器
                .addNetworkInterceptor(netIntercepter)//自定义的网络拦截器
                .build();
    }

2.添加应用拦截器

    //应用拦截器：主要用于设置公共参数，头信息，日志拦截等,有点类似Retrofit的Converter
    private static Interceptor appIntercepter = new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = processRequest(chain.request());
            Response response = processResponse(chain.proceed(request));
            return response;
        }
    };

    //访问网络之前，处理Request(这里统一添加了Cookie)
    private static Request processRequest(Request request) {
        String session = CacheManager.restoreLoginInfo(BaseApplication.getContext()).getSession();
        return request
                .newBuilder()
                .addHeader("Cookie", "JSESSIONID=" + session)
                .build();
    }

    //访问网络之后，处理Response(这里没有做特别处理)
    private static Response processResponse(Response response) {
        return response;
    }

这里再奉上一个缓存拦截器：离线读取本地缓存，在线获取最新数据(读取单个请求的请求头，亦可统一设置)。
这里用到了一个网络状态工具类

    //应用拦截器：设置缓存策略
    private static Interceptor cacheIntercepter = new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();

            //无网的时候强制使用缓存
            if (NetUtil.getNetState() == NetUtil.NetState.NET_NO) {
                request = request.newBuilder()
                        .cacheControl(CacheControl.FORCE_CACHE)
                        .build();
            }

            Response response = chain.proceed(request);

            //有网的时候读接口上的@Headers里的配置，你可以在这里进行统一的设置
            if (NetUtil.getNetState() != NetUtil.NetState.NET_NO) {
                String cacheControl = request.cacheControl().toString();
                return response.newBuilder()
                        .header("Cache-Control", cacheControl)
                        .removeHeader("Pragma")
                        .build();
            } else {
                int maxStale = 60 * 60 * 24 * 28; // tolerate 4-weeks stale
                return response.newBuilder()
                        .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
                        .removeHeader("Pragma")
                        .build();
            }
        }

    };

OkHttp3中有一个Cache类是用来定义缓存的，此类详细介绍了几种缓存策略,具体可看此类源码。

noCache ：不使用缓存，全部走网络

noStore ：不使用缓存，也不存储缓存
onlyIfCached ：只使用缓存
maxAge ：设置最大失效时间，失效则不使用
maxStale ：设置最大失效时间，失效则不使用
minFresh ：设置最小有效时间，失效则不使用
FORCE_NETWORK ：强制走网络
FORCE_CACHE ：强制走缓存

关于max-age和max-stale
max-stale在请求头设置有效，在响应头设置无效。
max-stale和max-age同时设置的时候，缓存失效的时间按最长的算。

我这里借用了别人的一个测试（太懒了，你有兴趣可以自己测试下）：

测试结果：
在请求头中设置了：Cache-Control: public, max-age=60,max-stale=120,响应头的Cache-Control和请求头一样。

在第一次请求数据到一分钟之内，响应头有：Cache-Control: public, max-age=60,max-stale=120
在1分钟到3分钟在之间，响应头有：Cache-Control: public, max-age=60,max-stale=120
Warning: 110 HttpURLConnection "Response is stale"
可以发现多了一个Warning。
三分钟的时候：重新请求了数据，如此循环，如果到了重新请求的节点此时没有网，则请求失败。
另外关于缓存有一个rxcache也可以试试。

3.添加网络拦截器

    //网络拦截器：主要用于重试或重写
    private static Interceptor netIntercepter = new Interceptor() {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Response response = chain.proceed(request);
            int tryCount = 0;
            while (!response.isSuccessful() && tryCount < sMaxTryCount) {
                tryCount++;
                response = chain.proceed(request);
            }
            return response;
        }
    };

关于OkHttp的拦截机制，我觉得这是OkHttp最牛逼的地方之一！
先给大家看个概览图，之后会在OkHttp的特性中详细介绍下。

OkHttp的拦截机制

4.简单的异步请求

    private static void testAsync() {
        Request request = new Request.Builder()
                .url("http://baidu.com")
                .build();
        sClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                LogUtil.print(e.getMessage());
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);
                Headers responseHeaders = response.headers();
                for (int i = 0, size = responseHeaders.size(); i < size; i++) {
                    LogUtil.print(responseHeaders.name(i) + ": " + responseHeaders.value(i));
                }
                LogUtil.print(response.body().string());
            }
        });
    }