OkHttp 使用

发表于 2019-12-30 更新于 2020-09-18 分类于 Android 知识点 Waline：阅读次数：本文字数： 20k 阅读时长 ≈ 18 分钟

OkHttp

OkHttp 是由鼎鼎大名的 Square 公司的一款非常出色的网络通信库。

准备工作

这里使用的 OkHttp 的版本为 3.14.x 的最后一个版本，OkHttp 的 4.0.x 版本已经全部由 Java 替换到了 Kotlin。

同时还需要再添加 Okio 的依赖库，而 Okio 在 1.x 版本是基于 Java 实现的，2.x 则是 Kotlin 实现的。

dependencies {
    implementation "com.squareup.okhttp3:okhttp:3.14.2"
    implementation 'com.squareup.okio:okio:1.17.4'
      
    // Kotlin 
    // 添加此依赖会自动下载两个库：一个库是 OkHttp 库，一个是 Okio 库，后者是前者的通信基础。
    // implementation "com.squareup.okhttp3:okhttp:4.8.0"  
}

OkHttp 在 3.13.x 以上的版本需要在 Android 5.0+ (API level 21+) 和 Java 1.8 的环境开发。3.12.x 以及以下的版本支持 Android 2.3+ (API level 9+) 和 Java 1.7 的开发环境。

//  为了解决这个错误：java.lang.BootstrapMethodError: Exception from call site #4 bootstrap method
    compileOptions{
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }

网络权限：

1	<uses-permission android:name="android.permission.INTERNET" />

同步 GET 请求

// 总体流程：
// 通过 OKHttpClient 将构建的 Request 转化为 Call，
// 然后在 RealCall 中进行同步或异步任务，
// 最后通过一些拦截器 interceptor 发出网络请求和得到返回的 response。

// 建造者模式，不设置的话会在 Builder 中使用默认设置。
OkHttpClient client = new OkHttpClient();
// 建造者模式创建 Request。
Request request = new Request.Builder()
  .url(STR)  // 访问链接
  .build();

// 同步请求需要在子线程中处理
    new Thread(new Runnable() {
        @Override
        public void run() {
            Response response = null;
            try {
                // RealCall,真正的请求执行者。
                response = client
                  .newCall(request)  // 创建 Call 对象
                  .execute();  // 通过 execute() 获得请求响应的 Response 对象

                if (response.isSuccessful()){
                  // 处理网络请求的相应，处理 UI 需要在 UI 线程中处理。
                    Log.e(TAG,response.body()!=null?response.body().string():"response.body == null");
                }else {
                    Log.e(TAG,String.valueOf(response));
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }).start();

异步 GET 请求

// 异步 GET 请求
// 创建 OKHttpClient,Request,Call，最后调用 Call 的 enqueue()。
Request.Builder requestBuilder = new Request.Builder().url(STR);
requestBuilder.method("GET",null);
Request request = requestBuilder.build();
OkHttpClient okHttpClient = new OkHttpClient();
Call call = okHttpClient.newCall(request);
call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {

    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
      // 此回调不在 UI 线程
        String str = response.body().string();
        Log.e(TAG,str);
    }
});

异步 POST 请求

RequestBody是一个抽象类，分别有FormBody和MultipartBody两个子类，前者用于传输表单类型的参数，后者则支持多类型的参数传递，例如：在传输表单类型的参数的同时，还可以传输文件。

// 异步 POST 请求
// 与异步 GET 相比，只是多了用 FormBody 来封装请求的参数，并传递给 Request。
// OkHttp 2.x 使用 FormEncodingBuilder 类。OkHttp 3 则使用 FormBody 类。
RequestBody formBody = new FormBody.Builder()
  .add("","")
  .build();

Request request = new Request.Builder()
  .url(STR)
  .post(formBody)
  .build();

OkHttpClient okHttpClient = new OkHttpClient();
Call call = okHttpClient.newCall(request);
call.enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {

    }

    @Override
    public void onResponse(Call call, Response response) throws IOException {
        // 此回调不在 UI 线程
        String str = response.body().string();
        Log.e(TAG,str);
    }
});

异步上传 Multipart 文件

Content-Type的类型使用对照表

public class MainActivity extends AppCompatActivity {

    private static final String STR = "https://jianghouren.com";
    private static final String TAG = "TAGMainActivity";
    /**
     * 定义上传文件类型
     */
    public static final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 异步上传 Multipart 文件
        // 有时上传文件，同时还需要传其他类型的字段。
        OkHttpClient okHttpClient = new OkHttpClient();
        RequestBody requestBody = new MultipartBody.Builder()
                .setType(MultipartBody.FORM)
                .addFormDataPart("title","a")  // 参数上传
                .addFormDataPart("image","a.png"
                        ,RequestBody.create(MEDIA_TYPE_PNG,new File("/sdcard/a.png")))
                .build();

        Request request = new Request.Builder()
                .header("Authorization","Client-ID "+"...")
                .url(STR)
                .post(requestBody)
                .build();

        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.e(TAG,"onFailure");
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                Log.e(TAG,response.body().string());
            }
        });
    }
}

异步上传文件

1 2	<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" /> <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

public class MainActivity extends AppCompatActivity {

    private static final String STR = "https://jianghouren.com";
    private static final String TAG = "TAGMainActivity";
    public static final MediaType MEDIA_TYPE_MARKDOWN = MediaType.parse("text/x-markdown; charset=utf-8");

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 运行时权限
        if (ContextCompat.checkSelfPermission(this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)
                != PackageManager.PERMISSION_GRANTED) {

            // Should we show an explanation?
            if (ActivityCompat.shouldShowRequestPermissionRationale(this,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE)) {

                // Show an expanation to the user *asynchronously* -- don't block
                // this thread waiting for the user's response! After the user
                // sees the explanation, try again to request the permission.
                initData();
            } else {

                // No explanation needed, we can request the permission.

                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},
                        11);

                // MY_PERMISSIONS_REQUEST_READ_CONTACTS is an
                // app-defined int constant. The callback method gets the
                // result of the request.
            }
        }else {
            initData();
        }
    }
  
    /**
     *  运行时权限回调
     */
    @Override
    public void onRequestPermissionsResult(int requestCode,
                                           String permissions[], int[] grantResults) {
        switch (requestCode) {
            case 11: {
                // If request is cancelled, the result arrays are empty.
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                    // permission was granted, yay! Do the
                    // contacts-related task you need to do.
                    initData();
                } else {
                    // permission denied, boo! Disable the
                    // functionality that depends on this permission.
                }
                return;
            }

            // other 'case' lines to check for other
            // permissions this app might request
        }
    }


    private void initData(){
        // 异步上传文件
        String filepath = "";
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
            // sd card 可用
            // 写入测试文件
            String inPath = Environment.getExternalStorageDirectory()+"/a.txt";
            boolean isSave=saveFile(inPath);
            if (isSave){
                Toast.makeText(this,"写入完成",Toast.LENGTH_LONG).show();
            }

            filepath = Environment.getExternalStorageDirectory().getAbsolutePath();
        }else {
            return;
        }
        
        Log.e(TAG,"开始上传文件");
        File file = new File(filepath,"a.txt");
        Request request = new Request.Builder()
                .url("https://api.github.com/markdown/raw")
                .post(RequestBody.create(MEDIA_TYPE_MARKDOWN,file))
                .build();
        OkHttpClient okHttpClient = new OkHttpClient();
        okHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.e(TAG,"onFailure");
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                // 返回的结果就是 txt 文件的内容
                Log.e(TAG,response.body().string());
                Log.e(TAG,String.valueOf(response));
            }
        });
    }

    /**
     *  写入文件
     */
    public  boolean saveFile(String inPath){
        File file = new File(inPath);
        try {
            //文件输出流
            FileOutputStream fos = new FileOutputStream(file);
            //写数据
            fos.write(("OkHttp").getBytes());
            fos.flush();
            //关闭文件流
            fos.close();
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

异步下载文件

Android P(API 28)全面禁止了非https链接，并严格审查网站的CA证书请参考

解决办法：

1、在 res/xml 下建立 network_security_config文件，名字可以任意。

2、对文件进行配置

<network-security-config>
<!--    &lt;!&ndash;  方式一：相对一些网站使用非安全连接：  &ndash;&gt;-->
<!--    <domain-config cleartextTrafficPermitted="true">-->
<!--        &lt;!&ndash;允许以下网址使用非安全的连接&ndash;&gt;-->
<!--        <domain includeSubdomains="true">insecure.example.com</domain>-->
<!--        <domain includeSubdomains="true">insecure.cdn.example.com</domain>-->
<!--    </domain-config>-->

    <!--  方式二：允许所有非安全连接  -->
    <domain-config cleartextTrafficPermitted="false">
        <!--不允许以下网址使用非安全连接-->
        <domain includeSubdomains="true">example.com</domain>
        <domain includeSubdomains="true">cdn.example2.com</domain>
    </domain-config>
    　<!--默认允许所有网址使用非安全连接-->
    <base-config cleartextTrafficPermitted="true" />
</network-security-config>

3、在 AndroidManifest 的 application 标签中增加如下属性
android:networkSecurityConfig="@xml/network_security_config"

// 异步下载文件，下载一张图片
String url = "http://imgsw.cn/static/images/mingyunzhiye.webp";
Request request = new Request.Builder().url(url).build();
OkHttpClient okHttpClient = new OkHttpClient();
okHttpClient.newCall(request).enqueue(new Callback() {
    @Override
    public void onFailure(Call call, IOException e) {
        Log.e(TAG,"onFailure");
    }

    @Override
    public void onResponse(Call call, Response response) {
        Log.e(TAG,String.valueOf(response));

        InputStream inputStream = response.body().byteStream();
        FileOutputStream fileOutputStream = null;
        String filepath = "";
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){
            // sd card 可用
            filepath = Environment.getExternalStorageDirectory().getAbsolutePath();
        }else {
            filepath = getFilesDir().getAbsolutePath();
        }
        File file = new File(filepath,"a.webp");
        if (null != file){
            try {
                fileOutputStream  = new FileOutputStream(file);
                byte[] buffer = new byte[2048];
                int len = 0;
                while ((len = inputStream.read(buffer)) != -1){
                    fileOutputStream.write(buffer,0,len);
                }
                fileOutputStream.flush();
            } catch (FileNotFoundException e) {
                Log.e(TAG,"FileNotFoundException");
                e.printStackTrace();
            } catch (IOException e) {
                Log.e(TAG,"IOException");
                e.printStackTrace();
            }

        }
    }
});

设置超时时间和缓存

File sdcache = getExternalCacheDir();
int cacheSize = 10 * 1024 * 1024;
OkHttpClient.Builder builder = new OkHttpClient.Builder()
        .connectTimeout(15, TimeUnit.SECONDS)
        .writeTimeout(20,TimeUnit.SECONDS)
        .readTimeout(20, TimeUnit.SECONDS)
        .cache(new Cache(sdcache.getAbsoluteFile(),cacheSize));
OkHttpClient okHttpClient = builder.build();

Request request = new Request.Builder()
        .header("Accept","image/webp")  // 重新设置指定 name 的 header 信息
        .addHeader("Charset","UTF-8")   // 添加 header 信息
        .removeHeader("Charset")    // 移除 header 信息
        .url(URL)
        .build();

取消请求

public class MainActivity extends AppCompatActivity {

    private static final String STR = "https://jianghouren.com";
    private static final String TAG = "TAGMainActivity";

    /**
     * 线程池
     */
    private ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 适当时机取消请求，节约网络资源。
        // 可通过 tag 同时取消多个请求，
        final Request request = new Request.Builder()
                .url(STR)
                .cacheControl(CacheControl.FORCE_NETWORK)   // 每次请求都要请求网络
                .build();

        Call call = null;
        OkHttpClient okHttpClient = new OkHttpClient();
        call = okHttpClient.newCall(request);
        final Call finalCall = call;
        // 100ms 后取消 call
        executorService.schedule(new Runnable() {
            @Override
            public void run() {
                finalCall.cancel();
            }
        },100,TimeUnit.MILLISECONDS);

        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.e(TAG,"onFailure");
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                if (null != response.cacheResponse()){
                    String str = response.cacheResponse().toString();
                    Log.e(TAG,"cache---"+str);
                }else {
                    String str = response.networkResponse().toString();
                    Log.e(TAG,"network---"+str);
                }
            }
        });
    }
}

拦截器 Interceptors

拦截器可以监视、重写和重试调用请求。它可以设置多个，并且调用是有顺序的。
拦截器还分为应用拦截器（Application Interceptors）和网络拦截器（Network Interceptors）。

/**
 * 自定义拦截器
 */
public class LoggingInterceptor implements Interceptor {
    @Override
    public Response intercept(Chain chain) throws IOException {
        Request request = chain.request();
        String host = request.url().host();

        Log.e("TAG","intercept host: "+ host);
        long t1 = System.nanoTime();
        Log.e("TAG", String.format("Sending request %s on %s%n%s",
                request.url(), chain.connection(), request.headers()));

        if (host.equals("www.baidu.com")){
            // 替换接口地址
            Request newRequest = request.newBuilder().url("https://jianghouren.com").build();
            Response response = chain.proceed(newRequest);

            long t2 = System.nanoTime();
            Log.e("TAG", String.format("Received response for %s in %.1fms%n%s",
                    response.request().url(), (t2 - t1) / 1e6d, response.headers()));

            return response;
        } else {
            return chain.proceed(request);
        }
    }
}

        OkHttpClient client = new OkHttpClient.Builder()
                .addInterceptor(new LoggingInterceptor())  // 应用拦截器
                .build();

        Request request = new Request.Builder()
                .url("https://www.baidu.com")
                .header("User-Agent", "OkHttp Example")
                .build();

        Call call = client.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                Log.e(TAG,"onFailure");
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                Log.e(TAG,String.valueOf(response));
//                Log.e(TAG,response.body().string());
            }
        });

OkHttp 封装

/**
 * 抽象类用于请求回调
 */
public abstract class ResultCallback {

    public abstract void onError(Request request,Exception e);

    public abstract void onResponse(String str) throws IOException;

}

/**
 * 封装 OkHttp
 */
public class OkHttpEngine {

    private static volatile OkHttpEngine mInstance;
    private OkHttpClient mOkHttpClient;
    private Handler mHandler;

    /**
     * 双重检查模式的单例
     * @param context
     * @return
     */
    public static OkHttpEngine getInstance(Context context){
        if (mInstance == null){
            synchronized (OkHttpEngine.class){
                if (mInstance == null){
                    mInstance = new OkHttpEngine(context);
                }
            }
        }
        return mInstance;
    }

    private OkHttpEngine(Context context){
        // 设置超时时间和缓存
        File sdcache = context.getExternalCacheDir();
        int cacheSize = 10 * 1024 * 1024;
        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                .connectTimeout(15, TimeUnit.SECONDS)
                .writeTimeout(20,TimeUnit.SECONDS)
                .readTimeout(20, TimeUnit.SECONDS)
                .cache(new Cache(sdcache.getAbsoluteFile(),cacheSize));

        mOkHttpClient = builder.build();
        // 通过 Handler 将请求的结果回调给 UI 线程。
        mHandler = new Handler();
    }

    /**
     * 异步 GET 请求
     * @param url
     * @param callback
     */
    public void getAsynHttp(String url,ResultCallback callback){
        final Request request = new Request.Builder()
                .url(url)
                .build();

        Call call = mOkHttpClient.newCall(request);
        dealResult(call,callback);
    }

    private void dealResult(Call call,final ResultCallback callback) {
       call.enqueue(new Callback() {
           @Override
           public void onFailure(Call call, IOException e) {
               sendFailedCallback(call.request(),e,callback);
           }

           private void sendFailedCallback(final Request request,final Exception e,final ResultCallback callback) {
               mHandler.post(new Runnable() {
                   @Override
                   public void run() {
                       if (callback != null){
                           callback.onError(request,e);
                       }
                   }
               });
           }

           @Override
           public void onResponse(Call call, Response response) throws IOException {
                sendSuccessCallback(response.body().string(),callback);
           }

           private void sendSuccessCallback(final String string,final ResultCallback callback) {
               mHandler.post(new Runnable() {
                   @Override
                   public void run() {
                       if (callback != null){
                           try {
                               callback.onResponse(string);
                           } catch (IOException e) {
                               e.printStackTrace();
                           }
                       }
                   }
               });
           }
       });
    }
}

public class MainActivity extends AppCompatActivity {

    private static final String STR = "https://jianghouren.com";
    private static final String TAG = "TAGMainActivity";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // OkHttp 封装
        // 注意两点：
        // 避免重复代码调用
        // 将请求结果回调改为 UI 线程
        OkHttpEngine.getInstance(MainActivity.this).getAsynHttp(STR, new ResultCallback() {
            @Override
            public void onError(Request request, Exception e) {
                e.printStackTrace();
                Log.e(TAG,"onError");
            }

            @Override
            public void onResponse(String str) throws IOException {
                Log.e(TAG,str);
                Toast.makeText(getApplicationContext(),"请求成功",Toast.LENGTH_SHORT).show();
            }
        });
    }
}

Kotlin 写法

1、创建一个 OkHttpClient 的实例

1	val client = OkHttpClient()

2、创建一个 Request 对象来发送一条 HTTP 请求

1	val request = Request.Builder().build()

3、在 build() 之前连缀其它方法来丰富 Request 对象

// 比如通过 url() 来设置目标的网络地址
val request = Request.Builder()
         .url("https://www.baidu.com")
         .build()

4、调用 OkHttpClient 的 newCall() 来创建一个 Call 对象，并调用它的 execute() 来发送请求并获取服务器返回的数据。

1	val response = client.newCall(request).execute()

5、Response 对象就是服务器返回的数据了，可通过如下写法来得到返回的具体内容。

1	val responseData = response.body?.string()

6、发起一条 POST 请求

// 先构建一个 Request Body 对象来存放待提交的参数
val requestBody = FormBody.Builder()
       .add("username","admin")
       .add("password",123456)
       .build()

// 然后在 Request.Builder 中调用一下 post()，并将 RequestBody 对象传入
val request = Request.Builder()
         .url("https://www.baidu.com")
         .post(requestBody)
         .build()
// 接下来的操作就和 GET 请求一样了，调用 execute() 来发送请求并获取服务器返回的数据即可。

示例（Kotlin）：

class  NetworkActivity : BaseActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_network)

        initView()
    }

    private fun showResponse(response: String) {
        // runOnUiThread() 其实就是对异步消息处理机制进行了一层封装，内部通过 Handler 实现。
        runOnUiThread{
            // 在这里进行 UI 操作，将结果显示到界面上。
            tvRequest.text = response
            // 从结果看，相比较 HttpUrlConnection，OkHttp 的请求结果显示有排版。
        }
    }

    private fun initView() {
        btnOkHttp.setOnClickListener{
            sendRequestWithOkHttp()
        }
    }

    private fun sendRequestWithOkHttp() {
        thread {
            try {
                val client = OkHttpClient()
                val request = Request.Builder()
                    .url("https://jianghouren.com/")
                    .build()
                val response = client.newCall(request).execute()
                val responseData = response.body?.string()
                if (responseData != null){
                    showResponse(responseData)
                }
            }catch (e:Exception){
                e.printStackTrace()
            }
        }
    }
}

示例（Kotlin）：网络请求工具类

object HttpUtil{

    /**
     * @param callback OkHttp 库中自带的回调接口
     */
    fun sendOkHttpRequest(address: String,callback:okhttp3.Callback){
        val client = OkHttpClient()
        val request = Request.Builder()
            .url(address)
            .build()
        // enqueue() 异步执行
        client.newCall(request).enqueue(callback)
    }
}

btnOkHttp.setOnClickListener{
    val address = "https://jianghouren.com/"
    // 回调接口在子线程中运行，不可以执行 UI 操作，除非借助 runOnUiThread()。
    HttpUtil.sendOkHttpRequest(address,object : Callback{
        override fun onResponse(call: Call, response: Response) {
            // 得到服务器返回的具体内容
            val responseData = response.body?.string()
            if (responseData!=null){
                showResponse(responseData)
            }
        }

        override fun onFailure(call: Call, e: IOException) {
            // 在这里对异常情况进行处理
        }
    })
}

备注

参考资料：

Android 进阶之光

第一行代码(第3版)

OkHttp 项目主页地址