Android小白之OkHttp的使用介绍

2017-08-03 本文已影响0人梧桐树biu

前言

在Android开发中，OKhttp已经成为眼下最火的http请求框架，那么OKhttp有什么过人之处呢？接下来就对OKhttp的学习进行总结。

一. OKhttp优势：

OkHttp 是一个高效的 http 客户端，特点如下：

支持 http2（基于SPDY协议）协议，对同一个主机的所有请求允许使用同一个 socket；
如果 http2 不可用，使用链接池技术来降低了请求响应的延迟；
使用透明的 gzip 压缩减少了数据流量；
使用网络缓存避免了重复的网络请求。

拓展--SPDY协议：SPDY协议是Google提出的基于传输控制协议(TCP)的应用层协议，通过压缩、多路复用和优先级来缩短加载时间。该协议是一种更加快速的内容传输协议。SPDY协议相比于HTTP的优势在于：

复用连接，可在一个TCP连接上传送多个资源。应对了TCP慢启动的特性。
请求分优先级，重要的资源优先传送。
HTTP头部数据也被压缩，省流量。
服务器端可主动连接客户端来推送资源（Server Push）。

二. OKhttp的主要功能：

发送get，post请求；
文件的上传，下载；
加载图片（内部会根据图片的大小进行压缩）；
支持请求回调，直接返回对象或者对象集合；
支持session的保持。

三. OKhttp的基本使用：

OKhttp使用之前需要添加依赖：

compile "com.squareup.okhttp:okhttp:3.2.0"

清单文件中添加网络访问权限：

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

1. get请求和post请求的区别：

get是从服务器上获取数据，post是向服务器上传输数据。
get是把参数数据队列加到提交表单的ACTION属性所指的URL中，值和表单内各个字段一一对应，在URL中可以看到。post是通过HTTP post机制，将表单内各个字段与其内容放置在HTML HEADER内一起传送到ACTION属性所指的URL地址。用户看不到这个过程。
对于get方式，服务器端用Request.QueryString获取变量的值，对于post方式，服务器端用Request.Form获取提交的数据。
get传送的数据量较小，不能大于2KB。post传送的数据量较大，一般被默认为不受限制。但理论上，IIS4中最大量为80KB，IIS5中为100KB。
get安全性非常低，post安全性较高。但是执行效率却比Post方法好。
get可以被浏览器缓存，post不可以。
get请求是安全的，post不安全。
项目开发中，当涉及到参数的安全问题或者参数比较大的时候，应该使用Post请求方式（例如:登录，注册，上传，支付，下单）；如果是相对简单的查询类接口可以使用Get请求方式（例如：获取图片，获取文章详情）。

2. 同步/异步发送get请求：

（1）创建OkHttpClient对象:

OkHttpClient okHttpClient = new OkHttpClient();

（2）使用Request.Builder构建请求对象:

Request类封装了请求报文信息：请求的Url地址、请求的方法（如GET、POST等）、各种请求头（如Content-Type、Cookie）以及可选的请求体。一般通过内部类Request.Builder的链式调用生成Request对象。

Request request = new Request.Builder()
            .url(URL)
            .build();

（3）创建一个call对象，对象是response，发送请求

Call代表了一个实际的HTTP请求，它是连接Request和Response的桥梁，通过Request对象的newCall()方法可以得到一个Call对象。Call对象既支持同步获取数据，也可以异步获取数据。

执行Call对象的execute()方法，会阻塞当前线程去获取数据，该方法返回一个Response对象。
执行Call对象的enqueue()方法，不会阻塞当前线程，该方法接收一个Callback对象，当异步获取到数据之后，会回调执行Callback对象的相应方法。如果请求成功，则执行Callback对象的onResponse方法，并将Response对象传入该方法中；如果请求失败，则执行Callback对象的onFailure方法。
```
  Call call = okHttpClient.newCall(request);
```

（4）通过调用execute()发送同步请求,调用enqueue()发送异步请求,获取到response对象

Response类封装了响应报文信息：状态吗（200、404等）、响应头（Content-Type、Server等）以及可选的响应体。可以通过Call对象的execute()方法获得Response对象，异步回调执行Callback对象的onResponse方法时也可以获取Response对象。

//调用execute()发送同步请求
try {
     Response response = call.execute();
    //判断请求是否成功
    if(response.isSuccessful()) {
        Log.i("TAG",response.body().string());
        response.body().close();
    }
    //关闭body
    response.body().close();
    } catch (IOException e) {
        e.printStackTrace();
    }

//通过调用enqueue()发送异步请求,异步请求开启了新的线程执行网络请求
call.enqueue(new Callback() {
    @Override
    public void onFailure(Request request, IOException e) {
        //请求失败的回调方法
    }

    @Override
    public void onResponse(Response response) throws IOException {   
        //请求成功的回调方法
        String result = response.body().string();
        Log.i("TAG",result);
        //关闭body
        response.body().close();
    }
});

3. 同步/异步发送post请求：

public static final MediaType JSON = MediaType
        .parse("application/json; charset=utf-8");
public static final String json = "{android: hello world!}";

/**
 * 同步发送post请求提交json数据
 */

OkHttpClient okhttpClient = new OkHttpClient();

//创建一个RequestBody对象（参数1：参数类型，参数2：传输的json串）
RequestBody requestBody = RequestBody.create(JSON,json);

//创建一个请求对象
Request request = new Request.Builder()
        .url(URL)
        .post(requestBody)
        .build();

//发送同步请求，获取响应对象
Call call = okhttpClient.newCall(request);
try {
    Response response = call.execute();
    //判断请求是否成功
    if(response.isSuccessful()) {
        Log.i("TAG",response.body().string());
        response.body().close();
    }
} catch (IOException e) {
    e.printStackTrace();
}

/**
 * 异步发送post请求提交键值对
 */

OkHttpClient okHttpClient = new OkHttpClient();
//创建一个请求体
RequestBody requestBody = new FormEncodingBuilder()
        .add("name","张三")
        .add("age","24")
        .add("sex","男")
        .build();
//创建一个请求对象
Request request = new Request.Builder()
        .url(URL)
        .post(requestBody)
        .build();

//发送异步请求，获取响应对象
Call call = okHttpClient.newCall(request);
call.enqueue(new Callback() {
    @Override
    public void onFailure(Request request, IOException e) {
        
    }

    @Override
    public void onResponse(Response response) throws IOException {
        //判断请求是否成功
        if(response.isSuccessful()) {
            Log.i("TAG",response.body().string());
            response.body().close();
        }
    }
});

OkHttp的简单封装 :

在项目中使用okhttp作为网络访问框架的时候，还是要对其封装使用的，下面就简单的封装一下：

public class OkHttpManager {

    public static OkHttpManager instence;
    private OkHttpClient mOkHttpClient;
    private Handler okHandler;

    private OkHttpManager() {
        //声明Handler对指定为主线程looper,确保执行线程在主线程中。
        okHandler = new Handler(Looper.getMainLooper());

        //指定超时时间等参数
        OkHttpClient.Builder builder = new OkHttpClient.Builder()
                .connectTimeout(15, TimeUnit.SECONDS)
                .readTimeout(20, TimeUnit.SECONDS)
                .writeTimeout(20, TimeUnit.SECONDS);
        mOkHttpClient = builder.build();
    }

    /**
     * 获取当前的实例对象，确保唯一性
     */
    public static OkHttpManager getInstence() {
        if (instence == null) {
            synchronized (OkHttpManager.class) {
                if (instence == null) {
                    instence = new OkHttpManager();
                }
            }
        }
        return instence;
    }

    /**
     * 发送get请求
     *
     * @param url
     * @param resultCallback
     */
    public void getNet(String url, ResultCallback resultCallback) {
        Request request = new Request.Builder()
                .url(url)  //接口地址
                .method("GET", null)  //默认的也是GET,可以不设置
                .build();
        dealNet(request,resultCallback);
    }

    /**
     * 发送post请求
     *
     * @param url
     * @param resultCallback
     * @param param          传入数量不定的参数
     */
    public void postNet(String url, ResultCallback resultCallback, Param... param) {
        if (param == null) {
            param = new Param[0];
        }
        FormBody.Builder frombody = new FormBody.Builder();
        for (Param p : param) {
            frombody.add(p.key, p.value);
        }
        RequestBody requestBody = frombody.build();
        Request request = new Request.Builder()
                .url(url)
                .post(requestBody)  //传入构建好的参数
                .build();

        dealNet(request,resultCallback);
    }

    /**
     * 网络请求
     *
     * @param request        请求
     * @param resultCallback 自定义的监听回调
     */
    public void dealNet(final Request request, final ResultCallback resultCallback) {
        mOkHttpClient.newCall(request).enqueue(new Callback() {
            @Override
            public void onFailure(Call call, final IOException e) {
                okHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        //请求失败的时候执行的方法
                        resultCallback.onFailed(request, e);
                    }
                });
            }

            @Override
            public void onResponse(Call call, final Response response) throws IOException {
                String str = "";
                try {
                    str = response.body().string();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                final String finalStr = str;
                Log.i("OkHttpManager", "onResponse" + finalStr);
                okHandler.post(new Runnable() {
                    @Override
                    public void run() {
                        //请求成功的时候执行的方法
                        resultCallback.onSuccess(finalStr);
                    }
                });
            }
        });
    }

    /**
     * 自定义监听回调
     */
    public static abstract class ResultCallback {
        public abstract void onFailed(Request request, IOException e);

        public abstract void onSuccess(String response);
    }

    /**
     * 参数封装类
     */
    public static class Param {
        String key;
        String value;

        public Param() {
        }

        public Param(String key, String value) {
            this.key = key;
            this.value = value;
        }
    }
}