OkHttp的使用

最新推荐文章于 2025-07-10 20:24:18 发布

showdy

最新推荐文章于 2025-07-10 20:24:18 发布

阅读量2.1k

点赞数

CC 4.0 BY-SA版权

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

本文链接：https://blog.youkuaiyun.com/showdy/article/details/50524453

Android 专栏收录该内容

37 篇文章

订阅专栏

OkHttp的介绍:

Android为我们提供了两种HTTP交互的方式：HttpURLConnection 和 Apache HTTP Client，虽然两者都支持HTTPS，流的上传和下载，配置超时，IPv6和连接池，已足够满足我们各种HTTP请求的需求。但更高效的使用HTTP 可以让您的应用运行更快、更节省流量。而OkHttp库就是为此而生
OkHttp是个高效的HTTP库:
- 支持SPDY,共享一个Socket来处理同一个服务器的所有请求
- 如果SPDY不可用,则通过连接池来减少请求延迟
- 无缝支持GZIP来减少数量流量
- 缓存响应数据来减少重复的网络请求
会从很多常用的连接问题中自动恢复。如果您的服务器配置了多个IP地址，当第一个IP连接失败的时候，OkHttp会自动尝试下一个IP。OkHttp还处理了代理服务器问题和SSL握手失败问题。
使用 OkHttp 无需重写您程序中的网络代码。OkHttp实现了几乎和java.net.HttpURLConnection一样的API。如果您用了 Apache HttpClient，则OkHttp也提供了一个对应的okhttp-apache 模块。

总体设计

这里写图片描述

上面是OKHttp总体设计图，主要是通过Diapatcher不断从RequestQueue中取出请求（Call），根据是否已缓存调用Cache或 Network这两类数据获取接口之一，从内存缓存或是服务器取得请求的数据。该引擎有同步和异步请求，同步请求通过Call.execute()直接返回当前的Response，而异步请求会把当前的请求Call.enqueue添加（AsyncCall）到请求队列中，并通过回调（Callback）的方式来获取最后结果。

OkHttp的具体使用:

一般的get请求

private Handler handler= new Handler(Looper.getMainLooper());//初始化handler
            String url="http://www.baidu.com";
                //1.初始化client;
                OkHttpClient client= new OkHttpClient();
                //2.创建请求request对象
                Request request= new Request.Builder()
                        .get()
                        .url(url)
                        .build();
                //3.执行请求,使用异步请求,可以调用execute同步请求
                client.newCall(request).enqueue(new Callback() {
                    @Override
                    public void onFailure(Request request, IOException e) {
                    }
                    //成功的回调,在子线程中,不能修改UI
                    @Override
                    public void onResponse(Response response) throws IOException {
                        if (response.isSuccessful()){
                            final String data = response.body().string();

                       //InputStream inputStream = response.body().byteStream();可以获得字节流,实现文件下载
                       //byte[] bytes = response.body().bytes
                            handler.post(new Runnable() {
                                @Override
                                public void run() {
                                    Toast.makeText(ActivityOkHttp.this, "data"+data.length(), Toast.LENGTH_SHORT).show();
                                }
                            });
                        }
                    }
                });

Post请求提交表单数据:

 //1.初始化client
                OkHttpClient client = new OkHttpClient();
                String url= "http://192.168.1.100:8080/GooglePlayServer/category";
                    /**2. 初始化请求体,根据数据不同有多种请求体
                 *      FormBody为RequestBody的实现类,可以支持表单数据
                 *      MultipartBody为RequestBody的实现,支持多键值对的数据,如文件的上传,也支持表单数据
                 *      支持自定义请求体,如body.create(contentType,content)的
                 */

                RequestBody body = new FormBody.Builder()
                        .addEncoded("index", "0")
                        .build();
                //3.初始化请求对象
                Request request= new Request.Builder()
                        .url(url)
                        .post(body)
                        .build();
                //4.执行请求
                client.newCall(request).enqueue(new Callback() {
                    @Override
                    public void onFailure(Request request, IOException e) {
                        Toast.makeText(ActivityOkHttp.this, "错误", Toast.LENGTH_SHORT).show();
                    }
                    @Override
                    public void onResponse(Response response) throws IOException {
                            if (response.isSuccessful()){
                                final String s = response.body().string();
                                runOnUiThread(new Runnable() {
                                    @Override
                                    public void run() {
                                        Toast.makeText(ActivityOkHttp.this, s, Toast.LENGTH_SHORT).show();
                                    }
                                });
                            }
                    }
                })

Post请求提交Json数据

public static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
            OkHttpClient client = new OkHttpClient();
            String post(String url, String json) throws IOException {
            // 自定义requestBody,可以提交JSON数据;
            RequestBody body = RequestBody.create(JSON, json);
            Request request = new Request.Builder()
                                .url(url)
                                .post(body)
                                .build();
            Response response = client.newCall(request).execute();
            return response.body().string();
            }

Post提交分块请求
- MultipartBuilder可以构建复杂的请求体，与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 final OkHttpClient client = new OkHttpClient();
            public void run() throws Exception {
                // Use the imgur image upload API as documented at https://api.imgur.com/endpoints/image
                RequestBody requestBody = new MultipartBuilder()
                    .type(MultipartBuilder.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(requestBody)
                    .build();

                Response response = client.newCall(request).execute();
                if (!response.isSuccessful()) throw new IOException("Unexpected code " + response);

                System.out.println(response.body().string());
            }

OkHttp的简单封装:

自定义接口回调

public abstract class OkCallBack<T> {
            public Type mType;
            static Type getSupperClassTypeParameter(Class<?> subclass) {
                Type supperClass = subclass.getGenericSuperclass();
                if (supperClass instanceof Class) {
                    throw new RuntimeException("Missing Type paramter.");
                }
                ParameterizedType parameterizedType = (ParameterizedType) supperClass;
                return $Gson$Types.canonicalize(parameterizedType.getActualTypeArguments()[0]);
            }

            public OkCallBack(){
                mType=getSupperClassTypeParameter(getClass());
            }
            public abstract void onPreRequest(Request request);

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

            public abstract void onSucess(Response response,T t);

            public abstract void onError(Response response, Exception e, int code);
        }

OkHttp的封装:

public class OkHttpHelper {
        private static OkHttpHelper mOkHttpHelper;
        private OkHttpClient mOkHttpClient;
        private Gson mGson;
        private Handler mHandler;

        private OkHttpHelper() {
            mOkHttpClient = new OkHttpClient().newBuilder()
                    .readTimeout(10, TimeUnit.SECONDS)
                    .writeTimeout(10, TimeUnit.SECONDS)
                    .connectTimeout(10, TimeUnit.SECONDS)
                    .build();
            mGson = new Gson();
            mHandler = new Handler(Looper.getMainLooper());
        }

        public static OkHttpHelper getInstance() {
            if (mOkHttpHelper == null) {
                synchronized (OkHttpHelper.class) {
                    mOkHttpHelper = new OkHttpHelper();
                }
            }
            return mOkHttpHelper;
        }

        public void AsyncGet(String url, OkCallBack callBack) {
            Request request = buildRequst(url, null, OkHttpMethodType.GET);
            doRequest(request, callBack);

        }

        public void AsyncPost(String url, Map<String, String> params, OkCallBack callBack) {
            Request request = buildRequst(url, params, OkHttpMethodType.POST);
            doRequest(request, callBack);
        }


        public void doRequest(final Request request, final OkCallBack callBack) {
            callBack.onPreRequest(request);
            mOkHttpClient.newCall(request).enqueue(new Callback() {
                @Override
                public void onFailure(Request request, IOException e) {
                    callBackFailure(request,e,callBack);
                }

                @Override
                public void onResponse(Response response) throws IOException {
                    if (response.isSuccessful()) {
                        String str = response.body().string();
                        if (callBack.mType == String.class) {
                            callBackSuccess(response,str,callBack);
                        } else {
                            try {
                                Object o = mGson.fromJson(str, callBack.mType);
                                callBackSuccess(response,o,callBack);
                            } catch (JsonParseException e) {
                                callBack.onError(response, null, response.code());
                            }
                        }
                    } else {
                        callBack.onError(response, null, response.code());
                    }
                }
            });

        }

        private Request buildRequst(String url, Map<String, String> params, OkHttpMethodType type) {
            Request.Builder builder = new Request.Builder();
            if (type == OkHttpMethodType.GET) {
                builder.url(url)
                        .get();
            }
            if (type == OkHttpMethodType.POST) {
                builder.url(url)
                        .post(buildFormData(params));
            }

            return builder.build();
        }

        private RequestBody buildFormData(Map<String, String> params) {
            FormBody.Builder builder = new FormBody.Builder();

            if (params == null) {
                return null;
            }
            for (Map.Entry<String, String> map : params.entrySet()) {
                builder.addEncoded(map.getKey(), map.getValue());
            }
            return builder.build();
        }


        enum OkHttpMethodType {
            GET,
            POST
        }

        private void callBackSuccess(final Response response, final Object o, final OkCallBack callBack) {
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    callBack.onSucess(response,o);
                }
            });
        }

        private void callBackFailure(final Request request, final Exception e, final OkCallBack callBack) {
            mHandler.post(new Runnable() {
                @Override
                public void run() {
                    callBack.onFailure(request,e);
                }
            });
        }
    }