Okhttp 使用详解

阳光穿透心脏的1/2处 2022-03-16 15:22 1321阅读 0赞

# 一， OKHttp介绍 #

okhttp是一个第三方类库，用于android中请求网络。
    
    这是一个开源项目,是安卓端最火热的轻量级框架,由移动支付Square公司贡献(该公司还贡献了Picasso和LeakCanary) 。
    用于替代HttpUrlConnection和Apache HttpClient(android API23 里已移除HttpClient)。
    
    okhttp有自己的官网，官网网址：[OKHttp官网](http://square.github.io/okhttp/)
    
    如果想了解原码可以在github上下载，地址是：[https://github.com/square/okhttp](https://github.com/square/okhttp)
    
    在AndroidStudio中使用不需要下载jar包，直接添加依赖即可： 
    compile ‘com.squareup.okhttp3:okhttp:3.4.1’

> # 二、使用 #

OkHttp3开发三部曲：
    1、创建OkHttpClient，添加配置
    2、创建请求
    3、执行请求
    下面分别来说说这三个步骤：

### 1. 创建OkHttpClient ###

一个最简单的OkHttpClient

OkHttpClient okHttpClient=new OkHttpClient.Builder().build();

一个复杂点的OkHttpClient配置

File cacheDir = new File(getCacheDir(), "okhttp_cache");  
    //File cacheDir = new File(getExternalCacheDir(), "okhttp");  
    Cache cache = new Cache(cacheDir, 10 * 1024 * 1024);  
      
    okHttpClient = new OkHttpClient.Builder()  
                .connectTimeout(5*1000, TimeUnit.MILLISECONDS) //链接超时  
                .readTimeout(10*1000,TimeUnit.MILLISECONDS) //读取超时  
                .writeTimeout(10*1000,TimeUnit.MILLISECONDS) //写入超时  
                .addInterceptor(new HttpHeadInterceptor()) //应用拦截器：统一添加消息头  
                .addNetworkInterceptor(new NetworkspaceInterceptor())//网络拦截器  
                .addInterceptor(loggingInterceptor)//应用拦截器：打印日志  
                .cache(cache)  //设置缓存  
                .build();

具体可配置参数见OkHttpClient.Builder类,几点注意事项：

1.拦截器

两种拦截器：Interceptor(应用拦截器)、NetworkInterceptor(网络拦截器)

[两种拦截器的区别][Link 1]

1）Interceptor比NetworkInterceptor先执行

2）同一种Interceptor倒序返回
       A(start)----B(start)----B(end)----A(end)
    因此上面配置的Interceptor执行顺序如下
    HttpHeadInterceptor start----LoggingInterceptor start----LoggingInterceptor end---HttpHeadInterceptor end

3）日志拦截器
    自定义日志拦截器
    public class LoggingInterceptor implements Interceptor {  
      private static final String TAG="Okhttp";  
      @Override public Response intercept(Interceptor.Chain chain) throws IOException {  
        Request request = chain.request();  
      
        long t1 = System.nanoTime();  
        Log.d(TAG,String.format("Sending request %s on %s%n%s",  
            request.url(), chain.connection(), request.headers()));  
      
        Response response = chain.proceed(request);  
        long t2 = System.nanoTime();  
        Log.d(TAG,String.format("Received response for %s in %.1fms%n%s",  
            response.request().url(), (t2 - t1) / 1e6d, response.headers()));  
      
        MediaType mediaType = response.body().contentType();  
        String content = response.body().string();  
        Log.d(TAG,content);  
      
        response=response.newBuilder()  
                        .body(ResponseBody.create(mediaType,content))  
                        .build();  
        return response;  
      }  
    }

官方提供的Logging Interceptor

地址：[https://github.com/victorfan336/okhttp-logging-interceptor][https_github.com_victorfan336_okhttp-logging-interceptor]  
gradle.build中添加依赖：  
compile 'com.squareup.okhttp3:logging-interceptor:3.1.2'

使用方法
    HttpLoggingInterceptor logging = new HttpLoggingInterceptor();  
    logging.setLevel(Level.BODY);//日志级别，Body级别打印的信息最全面  
    OkHttpClient client = new OkHttpClient.Builder()  
      .addInterceptor(logging)  
      .build();

2、注意

开发中应该只维护一个OkHttpClient实例，这样可以复用连接池、线程池等，避免性能开销
    如果想修改参数，可通过
    okHttpClient.newBuilder()修改，这样可以复用okHttpClient之前的所有配置，
    比如想针对某个请求修改链接超时。
    
    OkHttpClient newClient=okHttpClient.newBuilder()  
           .connectTimeout(10*1000,TimeUnit.MILLISECONDS)  
           .build();  
    newClient.newCall(req);

### 二、创建请求 ###

> **GET请求**

通过Request.Builder创建请求，默认是Get请求

Request req = new Request.Builder().url(url).build();  
    Call call = okHttpClient.newCall(req);

> **POST请求**

主要是构建RequestBody，并设置Content-Type消息头。

**1.普通Post请求**

比如json请求

RequestBody requestBody = RequestBody.create(MediaType.parse("application/json"), jsonObject.toString());  
    Request req = new Request.Builder().url(url)  
            .post(requestBody)  
            .build();  
    Call call = okHttpClient.newCall(req);

**2. 使用FormBody传递键值对参数**  
Content-Type: application/x-www-form-urlencoded  
比如：

RequestBody requestBody =  
                new FormBody.Builder()  
                        .add("username", "zhangsan")  
                        .add("password", "1111111")  
                        .build();  
    Request req = new Request.Builder().url(url).post(uploadBody).build();  
    Call call = okHttpClient.newCall(req);

**3. 使用RequestBody传递Json或File对象**

RequestBody是抽象类，故不能直接使用，但是他有静态方法create，使用这个方法可以得到RequestBody对象。
    
    这种方式可以上传Json对象或File对象。

上传json对象使用示例如下：
    
    OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象。
    MediaType JSON = MediaType.parse("application/json; charset=utf-8");//数据类型为json格式，
    String jsonStr = "{\"username\":\"lisi\",\"nickname\":\"李四\"}";//json数据.
    RequestBody body = RequestBody.create(JSON, josnStr);
    Request request = new Request.Builder()
            .url("http://www.baidu.com")
            .post(body)
            .build();
    client.newCall(request).enqueue(new Callback() {
        ...
    });//此处省略回调方法。

上传File对象使用示例如下：
    
    OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象。
    MediaType fileType = MediaType.parse("File/*");//数据类型为json格式，
    File file = new File("path");//file对象.
    RequestBody body = RequestBody.create(fileType , file );
    Request request = new Request.Builder()
            .url("http://www.baidu.com")
            .post(body)
            .build();
    client.newCall(request).enqueue(new Callback() {。。。});//此处省略回调方法。

**4. 使用MultipartBody同时传递键值对参数和File对象**

这个字面意思是多重的body。我们知道FromBody传递的是字符串型的键值对，RequestBody传递的是多媒体，那么如果我们想二者都传递怎么办？
    此时就需要使用MultipartBody类。 
    使用示例如下：
    
    OkHttpClient client = new OkHttpClient();
    MultipartBody multipartBody =new MultipartBody.Builder()
            .setType(MultipartBody.FORM)
            .addFormDataPart("groupId",""+groupId)//添加键值对参数
            .addFormDataPart("title","title")
            .addFormDataPart("file",file.getName(),RequestBody.create(MediaType.parse("file/*"), file))//添加文件
            .build();
    final Request request = new Request.Builder()
            .url(URLContant.CHAT_ROOM_SUBJECT_IMAGE)
            .post(multipartBody)
            .build();
    client.newCall(request).enqueue(new Callback() {。。。});
    Request req = new Request.Builder().url(url).post(uploadBody).build();  
    okHttpClient.newCall(req);

**5. 使用MultipartBody提交分块请求**

MultipartBody 可以构建复杂的请求体，与HTML文件上传形式兼容。
    多块请求体中每块请求都是一个请求体，可以定义自己的请求头，这些请求头可以用来描述这块请求。
    例如他的Content-Disposition。如果Content-Length和Content-Type可用的话，他们会被自动添加到请求头中。
    
    private static final String IMGUR_CLIENT_ID = "...";
    private static final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");
    private void postMultipartBody() {
        OkHttpClient client = new OkHttpClient();
        // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image
        MultipartBody body = new MultipartBody.Builder("AaB03x")
                .setType(MultipartBody.FORM)
                .addPart(
                        Headers.of("Content-Disposition", "form-data; name=\"title\""),
                        RequestBody.create(null, "Square Logo"))
                .addPart(
                        Headers.of("Content-Disposition", "form-data; name=\"image\""),
                        RequestBody.create(MEDIA_TYPE_PNG, new File("website/static/logo-square.png")))
                .build();
    
        Request request = new Request.Builder()
                .header("Authorization", "Client-ID " + IMGUR_CLIENT_ID)
                .url("https://api.imgur.com/3/image")
                .post(body)
                .build();
    
        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
    
            }
    
            @Override
            public void onResponse(Call call, Response response) throws IOException {
                System.out.println(response.body().string());
    
            }
        });
    }

**6. 自定义RequestBody实现流的上传**

在上面的分析中我们知道，只要是RequestBody类以及子类都可以作为post方法的参数，下面我们就自定义一个类，继承RequestBody，实现流的上传。 
    使用示例如下： 
    首先创建一个RequestBody类的子类对象：
    
    RequestBody body = new RequestBody() {
        @Override
        public MediaType contentType() {
            return null;
        }
    
        @Override
        public void writeTo(BufferedSink sink) throws IOException {//重写writeTo方法
            FileInputStream fio= new FileInputStream(new File("fileName"));
            byte[] buffer = new byte[1024*8];
            if(fio.read(buffer) != -1){
                 sink.write(buffer);
            }
        }
    };
    然后使用body对象：
    
    OkHttpClient client = new OkHttpClient();//创建OkHttpClient对象。
    Request request = new Request.Builder()
            .url("http://www.baidu.com")
            .post(body)
            .build();
    client.newCall(request).enqueue(new Callback() {。。。});
    
    以上代码的与众不同就是body对象，这个body对象重写了write方法，里面有个sink对象。这个是OKio包中的输出流，有write方法。使用这个方法我们可以实现上传流的功能。
    
    使用RequestBody上传文件时，并没有实现断点续传的功能。我可以使用这种方法结合RandomAccessFile类实现断点续传的功能。

### 三、执行请求 ###

1、同步执行

Response response = call.execute();

由于android强制要求网络请求在线程中执行，所以无法使用execute

2、异步执行

call.enqueue(new Callback() {  
        @Override  
        public void onFailure(Call call, IOException e) {  
            //失败回调  
        }  
      
        @Override  
        public void onResponse(Call call, Response response) throws IOException {  
             //成功回调，当前线程为子线程，如果需要更新UI，需要post到主线程中  
           
            boolean successful = response.isSuccessful();  
            //响应消息头  
            Headers headers = response.headers();  
            //响应消息体  
            ResponseBody body = response.body();  
            String content=response.body().string());  
            //缓存控制  
            CacheControl cacheControl = response.cacheControl();  
              
        }  
    });  
    
    1）Response:封装了网络响应消息，比如响应消息头、缓存控制、响应消息体等。
        String content=response.body().string(); //获取字符串
        InputStream inputStream = response.body().byteStream();//获取字节流(比如下载文件)
    
    2）Callback回调是在子线程中执行的，如果要更新UI，请post到主线程中。

# 三、其他设置 #

**1. 设置请求头**

OKHttp中设置请求头特别简单，在创建request对象时调用一个方法即可。 
    使用示例如下：
    
    Request request = new Request.Builder()
                    .url("http://www.baidu.com")
                    .header("User-Agent", "OkHttp Headers.java")
                    .addHeader("token", "myToken")
                    .build();

**2. 设置超时**

没有响应时使用超时结束call。没有响应的原因可能是客户点链接问题、服务器可用性问题或者这之间的其他东西。OkHttp支持连接，读取和写入超时。
    
    Request request = new Request.Builder()
                    .url("http://www.baidu.com")
                    .connectTimeout(10, TimeUnit.SECONDS);//连接超时
                    .readTimeout(10,TimeUnit.SECONDS);//读取超时
                    .writeTimeout(10,TimeUnit.SECONDS);//写入超时
                    .build();

**3. 设置缓存**

为了缓存响应，你需要一个你可以读写的缓存目录，和缓存大小的限制。这个缓存目录应该是私有的，不信任的程序应不能读取缓存内容。 
    一个缓存目录同时拥有多个缓存访问是错误的。大多数程序只需要调用一次new OkHttpClient()，在第一次调用时配置好缓存，然后其他地方只需要调用这个实例就可以了。否则两个缓存示例互相干扰，破坏响应缓存，而且有可能会导致程序崩溃。 
    响应缓存使用HTTP头作为配置。你可以在请求头中添加Cache-Control: max-stale=3600 ,OkHttp缓存会支持。你的服务通过响应头确定响应缓存多长时间，例如使用Cache-Control: max-age=9600。
    
    int cacheSize = 10 * 1024 * 1024; // 10 MiB
    Cache cache = new Cache(cacheDirectory, cacheSize);
    
    OkHttpClient.Builder builder = new OkHttpClient.Builder();
    builder.cache(cache);
    OkHttpClient client = builder.build();
    
    Request request = new Request.Builder()
            .url("http://publicobject.com/helloworld.txt")
            .build();
    
    Call call = client.newCall(request);
    call.enqueue(new Callback() {
            ...
    });

> **Okhttp使用上的一些缺点**

1、对于Get请求，如果请求参数较多，自己拼接Url较为麻烦

比如

HttpUrl httpUrl = new HttpUrl.Builder()  
                   .scheme("http")  
                   .host("www.baidu.com")  
                   .addPathSegment("user")  
                   .addPathSegment("login")  
                   .addQueryParameter("username", "zhangsan")  
                   .addQueryParameter("password","123456")  
                   .build();

拼接结果：[http://www.baidu.com/user/login/username=zhangsan&password=123456][http_www.baidu.com_user_login_username_zhangsan_password_123456]

如果能做一些封装，直接addParam(key,value)的形式则会简单很多。

2、Callback在子线程中回调，大部分时候，我们都是需要更新UI的，还需自己post到主线程中处理。  
3、构建请求步骤比较多  
因此，Square提供了针对OkHttp的封装库Retrofit，另外Github上也有很多第三方的封装库,比如OkGo。

[Link 1]: https://www.jianshu.com/p/2710ed1e6b48
[https_github.com_victorfan336_okhttp-logging-interceptor]: https://link.jianshu.com/?t=https%3A%2F%2Fgithub.com%2Fvictorfan336%2Fokhttp-logging-interceptor
[http_www.baidu.com_user_login_username_zhangsan_password_123456]: https://link.jianshu.com/?t=http%3A%2F%2Fwww.baidu.com%2Fuser%2Flogin%2Fusername%3Dzhangsan%26password%3D123456