Android OkHttp完全解析及 一个改善的okHttp封装库（整理）

http://blog.csdn.net/lmj623565791/article/details/47911083； 
本文出自:【张鸿洋的博客】

一、概述

最近在群里听到各种讨论okhttp的话题，可见okhttp的口碑相当好了。再加上Google貌似在6.0版本里面删除了HttpClient相关API，对于这个行为不做评价。为了更好的在应对网络访问，学习下okhttp还是蛮必要的，本篇博客首先介绍okhttp的简单使用，主要包含：

• 一般的get请求

• 一般的post请求

• 基于Http的文件上传

• 文件下载

• 加载图片

最后会对上述几个功能进行封装，完整的封装类的地址见：https://github.com/hongyangAndroid/okhttp-utils

使用前，对于Android Studio的用户，可以选择添加:

1. compile 'com.squareup.okhttp:okhttp:2.4.0'

或者Eclipse的用户，可以下载最新的jar okhttp he latest JAR ，添加依赖就可以用了。

注意:okhttp内部依赖okio，别忘了同时导入okio：

gradle: compile 'com.squareup.okio:okio:1.5.0'

最新的jar地址：okio the latest JAR

---

二、使用教程

（一）Http Get

对了网络加载库，那么最常见的肯定就是http get请求了，比如获取一个网页的内容。

1. //创建okHttpClient对象
2. OkHttpClient mOkHttpClient = new OkHttpClient();
3. //创建一个Request
4. final Request request = new Request.Builder()
5.                 .url("https://github.com/hongyangAndroid")
6.                 .build();
7. //new call
8. Call call = mOkHttpClient.newCall(request); 
9. //请求加入调度
10. call.enqueue(new Callback()
11.         {
12.             @Override
13.             public void onFailure(Request request, IOException e)
14.             {
15.             }
16.  
17.             @Override
18.             public void onResponse(final Response response) throws IOException
19.             {
20.                     //String htmlStr =  response.body().string();
21.             }
22.         });

1. 以上就是发送一个get请求的步骤，首先构造一个Request对象，参数最起码有个url，当然你可以通过Request.Builder设置更多的参数比如：header、method等。

2. 然后通过request的对象去构造得到一个Call对象，类似于将你的请求封装成了任务，既然是任务，就会有execute()和cancel()等方法。

3. 最后，我们希望以异步的方式去执行请求，所以我们调用的是call.enqueue，将call加入调度队列，然后等待任务执行完成，我们在Callback中即可得到结果。

看到这，你会发现，整体的写法还是比较长的，所以封装肯定是要做的，不然每个请求这么写，得累死。

ok，需要注意几点：

• onResponse回调的参数是response，一般情况下，比如我们希望获得返回的字符串，可以通过response.body().string()获取；如果希望获得返回的二进制字节数组，则调用response.body().bytes()；如果你想拿到返回的inputStream，则调用response.body().byteStream()

  看到这，你可能会奇怪，竟然还能拿到返回的inputStream，看到这个最起码能意识到一点，这里支持大文件下载，有inputStream我们就可以通过IO的方式写文件。不过也说明一个问题，这个onResponse执行的线程并不是UI线程。的确是的，如果你希望操作控件，还是需要使用handler等，例如：

  
  

• 1. @Override
  2. public void onResponse(final Response response) throws IOException
  3. {
  4.       final String res = response.body().string();
  5.       runOnUiThread(new Runnable()
  6.       {
  7.           @Override
  8.           public void run()
  9.           {
  10.             mTv.setText(res);
  11.           }
  12.  
  13.       });
  14. }

• 我们这里是异步的方式去执行，当然也支持阻塞的方式，上面我们也说了Call有一个execute()方法，你也可以直接调用call.execute()通过返回一个Response。

---

(二) Http Post 携带参数

看来上面的简单的get请求，基本上整个的用法也就掌握了，比如post携带参数，也仅仅是Request的构造的不同。

1. Request request = buildMultipartFormRequest(
2.         url, new File[]{file}, new String[]{fileKey}, null);
3. FormEncodingBuilder builder = new FormEncodingBuilder();   
4. builder.add("username","张鸿洋");
5.  
6. Request request = new Request.Builder()
7.                    .url(url)
8.                 .post(builder.build())
9.                 .build();
10.  mOkHttpClient.newCall(request).enqueue(new Callback(){});

大家都清楚，post的时候，参数是包含在请求体中的；所以我们通过FormEncodingBuilder。添加多个String键值对，然后去构造RequestBody，最后完成我们Request的构造。

后面的就和上面一样了。

---

（三）基于Http的文件上传

接下来我们在介绍一个可以构造RequestBody的Builder，叫做MultipartBuilder。当我们需要做类似于表单上传的时候，就可以使用它来构造我们的requestBody。

1. File file = new File(Environment.getExternalStorageDirectory(), "balabala.mp4");
2.  
3. RequestBody fileBody = RequestBody.create(MediaType.parse("application/octet-stream"), file);
4.  
5. RequestBody requestBody = new MultipartBuilder()
6.      .type(MultipartBuilder.FORM)
7.      .addPart(Headers.of(
8.           "Content-Disposition", 
9.               "form-data; name=\"username\""), 
10.           RequestBody.create(null, "张鸿洋"))
11.      .addPart(Headers.of(
12.          "Content-Disposition", 
13.          "form-data; name=\"mFile\"; 
14.          filename=\"wjd.mp4\""), fileBody)
15.      .build();
16.  
17. Request request = new Request.Builder()
18.     .url("http://192.168.1.103:8080/okHttpServer/fileUpload")
19.     .post(requestBody)
20.     .build();
21.  
22. Call call = mOkHttpClient.newCall(request);
23. call.enqueue(new Callback()
24. {
25.     //...
26. });

上述代码向服务器传递了一个键值对username:张鸿洋和一个文件。我们通过MultipartBuilder的addPart方法可以添加键值对或者文件。

其实类似于我们拼接模拟浏览器行为的方式，如果你对这块不了解，可以参考：从原理角度解析Android （Java） http 文件上传

ok，对于我们最开始的目录还剩下图片下载，文件下载；这两个一个是通过回调的Response拿到byte[]然后decode成图片；文件下载，就是拿到inputStream做写文件操作，我们这里就不赘述了。

关于用法，也可以参考泡网OkHttp使用教程

接下来我们主要看如何封装上述的代码。

---

三、封装

由于按照上述的代码，写多个请求肯定包含大量的重复代码，所以我希望封装后的代码调用是这样的：

（一）使用

1. 一般的get请求

1. OkHttpClientManager.getAsyn("https://github.com/hongyangAndroid", new OkHttpClientManager.StringCallback()
2.         {
3.             @Override
4.             public void onFailure(Request request, IOException e)
5.             {
6.                 e.printStackTrace();
7.             }
8.  
9.             @Override
10.             public void onResponse(String bytes)
11.             {
12.                 mTv.setText(bytes);//注意这里是UI线程回调，可以直接操作控件
13.             }
14.         });

对于一般的请求，我们希望给个url，然后CallBack里面直接操作控件。

1. 文件上传且携带参数

我们希望提供一个方法，传入url,params,file,callback即可。

1.   OkHttpClientManager.postAsyn("http://192.168.1.103:8080/okHttpServer/fileUpload",//
2.     new OkHttpClientManager.StringCallback()
3.     {
4.         @Override
5.         public void onFailure(Request request, IOException e)
6.         {
7.             e.printStackTrace();
8.         }
9.  
10.         @Override
11.         public void onResponse(String result)
12.         {
13.  
14.         }
15.     },//
16.     file,//
17.     "mFile",//
18.     new OkHttpClientManager.Param[]{
19.             new OkHttpClientManager.Param("username", "zhy"),
20.             new OkHttpClientManager.Param("password", "123")}
21.         );

键值对没什么说的，参数3为file，参数4为file对应的name，这个name不是文件的名字； 对应于http中的

<input type="file" name="mFile" >

对应的是name后面的值，即mFile.

1. 文件下载

对于文件下载，提供url，目标dir，callback即可。

1. OkHttpClientManager.downloadAsyn(
2.     "http://192.168.1.103:8080/okHttpServer/files/messenger_01.png",    
3.     Environment.getExternalStorageDirectory().getAbsolutePath(), 
4. new OkHttpClientManager.StringCallback()
5.     {
6.         @Override
7.         public void onFailure(Request request, IOException e)
8.         {
9.  
10.         }
11.  
12.         @Override
13.         public void onResponse(String response)
14.         {
15.             //文件下载成功，这里回调的reponse为文件的absolutePath
16.         }
17. });

1. 展示图片

展示图片，我们希望提供一个url和一个imageview，如果下载成功，直接帮我们设置上即可。

1. OkHttpClientManager.displayImage(mImageView, "http://images.csdn.net/20150817/1.jpg");

内部会自动根据imageview的大小自动对图片进行合适的压缩。虽然，这里可能不适合一次性加载大量图片的场景，但是对于app中偶尔有几个图片的加载，还是可用的。

---

（二）源码

ok，基本介绍完了，对于封装的代码其实也很简单，我就直接贴出来了，因为也没什么好介绍的，如果你看完上面的用法，肯定可以看懂：

1. package com.zhy.utils.http.okhttp;
2.  
3. import android.graphics.Bitmap;
4. import android.graphics.BitmapFactory;
5. import android.os.Handler;
6. import android.os.Looper;
7. import android.widget.ImageView;
8.  
9. import com.squareup.okhttp.Call;
10. import com.squareup.okhttp.Callback;
11. import com.squareup.okhttp.FormEncodingBuilder;
12. import com.squareup.okhttp.Headers;
13. import com.squareup.okhttp.MediaType;
14. import com.squareup.okhttp.MultipartBuilder;
15. import com.squareup.okhttp.OkHttpClient;
16. import com.squareup.okhttp.Request;
17. import com.squareup.okhttp.RequestBody;
18. import com.squareup.okhttp.Response;
19.  
20. import java.io.File;
21. import java.io.FileOutputStream;
22. import java.io.IOException;
23. import java.io.InputStream;
24. import java.net.FileNameMap;
25. import java.net.URLConnection;
26. import java.util.Map;
27. import java.util.Set;
28.  
29. /**
30.  * Created by zhy on 15/8/17.
31.  */
32. public class OkHttpClientManager
33. {
34.     private static OkHttpClientManager mInstance;
35.     private OkHttpClient mOkHttpClient;
36.     private Handler mDelivery;
37.  
38.     private static final String TAG = "OkHttpClientManager";
39.  
40.     private OkHttpClientManager()
41.     {
42.         mOkHttpClient = new OkHttpClient();
43.         mDelivery = new Handler(Looper.getMainLooper());
44.     }
45.  
46.     public static OkHttpClientManager getInstance()
47.     {
48.         if (mInstance == null)
49.         {
50.             synchronized (OkHttpClientManager.class)
51.             {
52.                 if (mInstance == null)
53.                 {
54.                     mInstance = new OkHttpClientManager();
55.                 }
56.             }
57.         }
58.         return mInstance;
59.     }
60.  
61.     /**
62.      * 同步的Get请求
63.      *
64.      * @param url
65.      * @return Response
66.      */
67.     private Response _getAsyn(String url) throws IOException
68.     {
69.         final Request request = new Request.Builder()
70.                 .url(url)
71.                 .build();
72.         Call call = mOkHttpClient.newCall(request);
73.         Response execute = call.execute();
74.         return execute;
75.     }
76.  
77.     /**
78.      * 同步的Get请求
79.      *
80.      * @param url
81.      * @return 字符串
82.      */
83.     private String _getAsString(String url) throws IOException
84.     {
85.         Response execute = _getAsyn(url);
86.         return execute.body().string();
87.     }
88.  
89.  
90.     /**
91.      * 异步的get请求
92.      *
93.      * @param url
94.      * @param callback
95.      */
96.     private void _getAsyn(String url, final StringCallback callback)
97.     {
98.         final Request request = new Request.Builder()
99.                 .url(url)
100.                 .build();
101.         deliveryResult(callback, request);
102.     }
103.  
104.  
105.     /**
106.      * 同步的Post请求
107.      *
108.      * @param url
109.      * @param params post的参数
110.      * @return
111.      */
112.     private Response _post(String url, Param... params) throws IOException
113.     {
114.         Request request = buildPostRequest(url, params);
115.         Response response = mOkHttpClient.newCall(request).execute();
116.         return response;
117.     }
118.  
119.  
120.     /**
121.      * 同步的Post请求
122.      *
123.      * @param url
124.      * @param params post的参数
125.      * @return 字符串
126.      */
127.     private String _postAsString(String url, Param... params) throws IOException
128.     {
129.         Response response = _post(url, params);
130.         return response.body().string();
131.     }
132.  
133.     /**
134.      * 异步的post请求
135.      *
136.      * @param url
137.      * @param callback
138.      * @param params
139.      */
140.     private void _postAsyn(String url, final StringCallback callback, Param... params)
141.     {
142.         Request request = buildPostRequest(url, params);
143.         deliveryResult(callback, request);
144.     }
145.  
146.     /**
147.      * 异步的post请求
148.      *
149.      * @param url
150.      * @param callback
151.      * @param params
152.      */
153.     private void _postAsyn(String url, final StringCallback callback, Map<String, String> params)
154.     {
155.         Param[] paramsArr = map2Params(params);
156.         Request request = buildPostRequest(url, paramsArr);
157.         deliveryResult(callback, request);
158.     }
159.  
160.     /**
161.      * 同步基于post的文件上传
162.      *
163.      * @param params
164.      * @return
165.      */
166.     private Response _post(String url, File[] files, String[] fileKeys, Param... params) throws IOException
167.     {
168.         Request request = buildMultipartFormRequest(url, files, fileKeys, params);
169.         return mOkHttpClient.newCall(request).execute();
170.     }
171.  
172.     private Response _post(String url, File file, String fileKey) throws IOException
173.     {
174.         Request request = buildMultipartFormRequest(url, new File[]{file}, new String[]{fileKey}, null);
175.         return mOkHttpClient.newCall(request).execute();
176.     }
177.  
178.     private Response _post(String url, File file, String fileKey, Param... params) throws IOException
179.     {
180.         Request request = buildMultipartFormRequest(url, new File[]{file}, new String[]{fileKey}, params);
181.         return mOkHttpClient.newCall(request).execute();
182.     }
183.  
184.     /**
185.      * 异步基于post的文件上传
186.      *
187.      * @param url
188.      * @param callback
189.      * @param files
190.      * @param fileKeys
191.      * @throws IOException
192.      */
193.     private void _postAsyn(String url, StringCallback callback, File[] files, String[] fileKeys, Param... params) throws IOException
194.     {
195.         Request request = buildMultipartFormRequest(url, files, fileKeys, params);
196.         deliveryResult(callback, request);
197.     }
198.  
199.     /**
200.      * 异步基于post的文件上传，单文件不带参数上传
201.      *
202.      * @param url
203.      * @param callback
204.      * @param file
205.      * @param fileKey
206.      * @throws IOException
207.      */
208.     private void _postAsyn(String url, StringCallback callback, File file, String fileKey) throws IOException
209.     {
210.         Request request = buildMultipartFormRequest(url, new File[]{file}, new String[]{fileKey}, null);
211.         deliveryResult(callback, request);
212.     }
213.  
214.     /**
215.      * 异步基于post的文件上传，单文件且携带其他form参数上传
216.      *
217.      * @param url
218.      * @param callback
219.      * @param file
220.      * @param fileKey
221.      * @param params
222.      * @throws IOException
223.      */
224.     private void _postAsyn(String url, StringCallback callback, File file, String fileKey, Param... params) throws IOException
225.     {
226.         Request request = buildMultipartFormRequest(url, new File[]{file}, new String[]{fileKey}, params);
227.         deliveryResult(callback, request);
228.     }
229.  
230.     /**
231.      * 异步下载文件
232.      *
233.      * @param url
234.      * @param destFileDir 本地文件存储的文件夹
235.      * @param callback
236.      */
237.     private void _downloadAsyn(final String url, final String destFileDir, final StringCallback callback)
238.     {
239.         final Request request = new Request.Builder()
240.                 .url(url)
241.                 .build();
242.         final Call call = mOkHttpClient.newCall(request);
243.         call.enqueue(new Callback()
244.         {
245.             @Override
246.             public void onFailure(final Request request, final IOException e)
247.             {
248.                 sendFailedStringCallback(request, e, callback);
249.             }
250.  
251.             @Override
252.             public void onResponse(Response response)
253.             {
254.                 InputStream is = null;
255.                 byte[] buf = new byte[2048];
256.                 int len = 0;
257.                 FileOutputStream fos = null;
258.                 try
259.                 {
260.                     is = response.body().byteStream();
261.                     File file = new File(destFileDir, getFileName(url));
262.                     fos = new FileOutputStream(file);
263.                     while ((len = is.read(buf)) != -1)
264.                     {
265.                         fos.write(buf, 0, len);
266.                     }
267.                     fos.flush();
268.                     //如果下载文件成功，第一个参数为文件的绝对路径
269.                     sendSuccessStringCallback(file.getAbsolutePath(), callback);
270.                 } catch (IOException e)
271.                 {
272.                     sendFailedStringCallback(response.request(), e, callback);
273.                 } finally
274.                 {
275.                     try
276.                     {
277.                         if (is != null) is.close();
278.                     } catch (IOException e)
279.                     {
280.                     }
281.                     try
282.                     {
283.                         if (fos != null) fos.close();
284.                     } catch (IOException e)
285.                     {
286.                     }
287.                 }
288.  
289.             }
290.         });
291.     }
292.  
293.     private String getFileName(String path)
294.     {
295.         int separatorIndex = path.lastIndexOf("/");
296.         return (separatorIndex < 0) ? path : path.substring(separatorIndex + 1, path.length());
297.     }
298.  
299.     /**
300.      * 加载图片
301.      *
302.      * @param view
303.      * @param url
304.      * @throws IOException
305.      */
306.     private void _displayImage(final ImageView view, final String url, final int errorResId)
307.     {
308.         final Request request = new Request.Builder()
309.                 .url(url)
310.                 .build();
311.         Call call = mOkHttpClient.newCall(request);
312.         call.enqueue(new Callback()
313.         {
314.             @Override
315.             public void onFailure(Request request, IOException e)
316.             {
317.                 setErrorResId(view, errorResId);
318.             }
319.  
320.             @Override
321.             public void onResponse(Response response)
322.             {
323.                 InputStream is = null;
324.                 try
325.                 {
326.                     is = response.body().byteStream();
327.                     ImageUtils.ImageSize actualImageSize = ImageUtils.getImageSize(is);
328.                     ImageUtils.ImageSize imageViewSize = ImageUtils.getImageViewSize(view);
329.                     int inSampleSize = ImageUtils.calculateInSampleSize(actualImageSize, imageViewSize);
330.                     try
331.                     {
332.                         is.reset();
333.                     } catch (IOException e)
334.                     {
335.                         response = _getAsyn(url);
336.                         is = response.body().byteStream();
337.                     }
338.  
339.                     BitmapFactory.Options ops = new BitmapFactory.Options();
340.                     ops.inJustDecodeBounds = false;
341.                     ops.inSampleSize = inSampleSize;
342.                     final Bitmap bm = BitmapFactory.decodeStream(is, null, ops);
343.                     mDelivery.post(new Runnable()
344.                     {
345.                         @Override
346.                         public void run()
347.                         {
348.                             view.setImageBitmap(bm);
349.                         }
350.                     });
351.                 } catch (Exception e)
352.                 {
353.                     setErrorResId(view, errorResId);
354.  
355.                 } finally
356.                 {
357.                     if (is != null) try
358.                     {
359.                         is.close();
360.                     } catch (IOException e)
361.                     {
362.                         e.printStackTrace();
363.                     }
364.                 }
365.             }
366.         });
367.  
368.  
369.     }
370.  
371.     private void setErrorResId(final ImageView view, final int errorResId)
372.     {
373.         mDelivery.post(new Runnable()
374.         {
375.             @Override
376.             public void run()
377.             {
378.                 view.setImageResource(errorResId);
379.             }
380.         });
381.     }
382.  
383.  
384.     //*************对外公布的方法************
385.  
386.  
387.     public static Response getAsyn(String url) throws IOException
388.     {
389.         return getInstance()._getAsyn(url);
390.     }
391.  
392.  
393.     public static String getAsString(String url) throws IOException
394.     {
395.         return getInstance()._getAsString(url);
396.     }
397.  
398.     public static void getAsyn(String url, StringCallback callback)
399.     {
400.         getInstance()._getAsyn(url, callback);
401.     }
402.  
403.     public static Response post(String url, Param... params) throws IOException
404.     {
405.         return getInstance()._post(url, params);
406.     }
407.  
408.     public static String postAsString(String url, Param... params) throws IOException
409.     {
410.         return getInstance()._postAsString(url, params);
411.     }
412.  
413.     public static void postAsyn(String url, final StringCallback callback, Param... params)
414.     {
415.         getInstance()._postAsyn(url, callback, params);
416.     }
417.  
418.  
419.     public static void postAsyn(String url, final StringCallback callback, Map<String, String> params)
420.     {
421.         getInstance()._postAsyn(url, callback, params);
422.     }
423.  
424.  
425.     public static Response post(String url, File[] files, String[] fileKeys, Param... params) throws IOException
426.     {
427.         return getInstance()._post(url, files, fileKeys, params);
428.     }
429.  
430.     public static Response post(String url, File file, String fileKey) throws IOException
431.     {
432.         return getInstance()._post(url, file, fileKey);
433.     }
434.  
435.     public static Response post(String url, File file, String fileKey, Param... params) throws IOException
436.     {
437.         return getInstance()._post(url, file, fileKey, params);
438.     }
439.  
440.     public static void postAsyn(String url, StringCallback callback, File[] files, String[] fileKeys, Param... params) throws IOException
441.     {
442.         getInstance()._postAsyn(url, callback, files, fileKeys, params);
443.     }
444.  
445.  
446.     public static void postAsyn(String url, StringCallback callback, File file, String fileKey) throws IOException
447.     {
448.         getInstance()._postAsyn(url, callback, file, fileKey);
449.     }
450.  
451.  
452.     public static void postAsyn(String url, StringCallback callback, File file, String fileKey, Param... params) throws IOException
453.     {
454.         getInstance()._postAsyn(url, callback, file, fileKey, params);
455.     }
456.  
457.     public static void displayImage(final ImageView view, String url, int errorResId) throws IOException
458.     {
459.         getInstance()._displayImage(view, url, errorResId);
460.     }
461.  
462.  
463.     public static void displayImage(final ImageView view, String url)
464.     {
465.         getInstance()._displayImage(view, url, -1);
466.     }
467.  
468.     public static void downloadAsyn(String url, String destDir, StringCallback callback)
469.     {
470.         getInstance()._downloadAsyn(url, destDir, callback);
471.     }
472.  
473.     //****************************
474.  
475.  
476.     private Request buildMultipartFormRequest(String url, File[] files,
477.                                               String[] fileKeys, Param[] params)
478.     {
479.         params = validateParam(params);
480.  
481.         MultipartBuilder builder = new MultipartBuilder()
482.                 .type(MultipartBuilder.FORM);
483.  
484.         for (Param param : params)
485.         {
486.             builder.addPart(Headers.of("Content-Disposition", "form-data; name=\"" + param.key + "\""),
487.                     RequestBody.create(null, param.value));
488.         }
489.         if (files != null)
490.         {
491.             RequestBody fileBody = null;
492.             for (int i = 0; i < files.length; i++)
493.             {
494.                 File file = files[i];
495.                 String fileName = file.getName();
496.                 fileBody = RequestBody.create(MediaType.parse(guessMimeType(fileName)), file);
497.                 //TODO 根据文件名设置contentType
498.                 builder.addPart(Headers.of("Content-Disposition",
499.                                 "form-data; name=\"" + fileKeys[i] + "\"; filename=\"" + fileName + "\""),
500.                         fileBody);
501.             }
502.         }
503.  
504.         RequestBody requestBody = builder.build();
505.         return new Request.Builder()
506.                 .url(url)
507.                 .post(requestBody)
508.                 .build();
509.     }
510.  
511.     private String guessMimeType(String path)
512.     {
513.         FileNameMap fileNameMap = URLConnection.getFileNameMap();
514.         String contentTypeFor = fileNameMap.getContentTypeFor(path);
515.         if (contentTypeFor == null)
516.         {
517.             contentTypeFor = "application/octet-stream";
518.         }
519.         return contentTypeFor;
520.     }
521.  
522.  
523.     private Param[] validateParam(Param[] params)
524.     {
525.         if (params == null)
526.             return new Param[0];
527.         else return params;
528.     }
529.  
530.     private Param[] map2Params(Map<String, String> params)
531.     {
532.         if (params == null) return new Param[0];
533.         int size = params.size();
534.         Param[] res = new Param[size];
535.         Set<Map.Entry<String, String>> entries = params.entrySet();
536.         int i = 0;
537.         for (Map.Entry<String, String> entry : entries)
538.         {
539.             res[i++] = new Param(entry.getKey(), entry.getValue());
540.         }
541.         return res;
542.     }
543.  
544.     private void deliveryResult(final StringCallback callback, Request request)
545.     {
546.         mOkHttpClient.newCall(request).enqueue(new Callback()
547.         {
548.             @Override
549.             public void onFailure(final Request request, final IOException e)
550.             {
551.                 sendFailedStringCallback(request, e, callback);
552.             }
553.  
554.             @Override
555.             public void onResponse(final Response response)
556.             {
557.                 try
558.                 {
559.                     final String string = response.body().string();
560.                     sendSuccessStringCallback(string, callback);
561.                 } catch (IOException e)
562.                 {
563.                     sendFailedStringCallback(response.request(), e, callback);
564.                 }
565.  
566.             }
567.         });
568.     }
569.  
570.     private void sendFailedStringCallback(final Request request, final IOException e, final StringCallback callback)
571.     {
572.         mDelivery.post(new Runnable()
573.         {
574.             @Override
575.             public void run()
576.             {
577.                 if (callback != null)
578.                     callback.onFailure(request, e);
579.             }
580.         });
581.     }
582.  
583.     private void sendSuccessStringCallback(final String string, final StringCallback callback)
584.     {
585.         mDelivery.post(new Runnable()
586.         {
587.             @Override
588.             public void run()
589.             {
590.                 if (callback != null)
591.                     callback.onResponse(string);
592.             }
593.         });
594.     }
595.  
596.     private Request buildPostRequest(String url, Param[] params)
597.     {
598.         if (params == null)
599.         {
600.             params = new Param[0];
601.         }
602.         FormEncodingBuilder builder = new FormEncodingBuilder();
603.         for (Param param : params)
604.         {
605.             builder.add(param.key, param.value);
606.         }
607.         RequestBody requestBody = builder.build();
608.         return new Request.Builder()
609.                 .url(url)
610.                 .post(requestBody)
611.                 .build();
612.     }
613.  
614.  
615.     public interface StringCallback
616.     {
617.         void onFailure(Request request, IOException e);
618.  
619.         void onResponse(String response);
620.     }
621.  
622.     public static class Param
623.     {
624.         public Param()
625.         {
626.         }
627.  
628.         public Param(String key, String value)
629.         {
630.             this.key = key;
631.             this.value = value;
632.         }
633.  
634.         String key;
635.         String value;
636.     }
637.  
638.  
639. }

源码地址okhttp-utils，大家可以自己下载查看。

ok ，最后一段代码好长，建议下载源码查看~~

---------------------------------------------------------------------------------------------------------------------------

Android 一个改善的okHttp封装库

一、概述

之前写了篇Android OkHttp完全解析 是时候来了解OkHttp了，其实主要是作为okhttp的普及文章，当然里面也简单封装了工具类，没想到关注和使用的人还挺多的，由于这股热情，该工具类中的方法也是剧增，各种重载方法，以致于使用起来极不方便，实在惭愧。

于是，在这个周末，抽点时间对该工具类，进行了重新的拆解与编写，顺便完善下功能，尽可能的提升其使用起来的方便性和易扩展性。

标题的改善，也是指的是对于我之前的代码进行改善。

如果你对okhttp不了解，可以通过Android OkHttp完全解析 是时候来了解OkHttp了进行了解。

ok，那么目前，该封装库志支持：

• 一般的get请求
• 一般的post请求
• 基于Http的文件上传
• 文件下载
• 上传下载的进度回调
• 加载图片
• 支持请求回调，直接返回对象、对象集合
• 支持session的保持
• 支持自签名网站https的访问，提供方法设置下证书就行
• 支持取消某个请求

源码地址：https://github.com/hongyangAndroid/okhttp-utils

---

引入：

• Android Studio

  使用前，对于Android Studio的用户，可以选择添加:

  compile project(':okhttputils')

  • 
    

  或者

  compile 'com.zhy:okhttputils:2.0.0'

  • 
    

• Eclipse

  自行copy源码。

二、基本用法

目前基本的用法格式为：

OkHttpUtils
    .get()
    .url(url)
    .addParams("username", "hyman")
    .addParams("password", "123")
    .build()
    .execute(callback);

• 
  

通过链式去根据自己的需要添加各种参数，最后调用execute(callback)进行执行，传入callback则代表是异步。如果单纯的execute()则代表同步的方法调用。

可以看到，取消了之前一堆的get重载方法，参数也可以进行灵活的选择了。

下面简单看一下，全部的用法：

（1）GET请求

String url = "http://www.csdn.net/";
OkHttpUtils
    .get()
    .url(url)
    .addParams("username", "hyman")
    .addParams("password", "123")
    .build()
    .execute(new StringCallback()
            {
                @Override
                public void onError(Request request, Exception e)
                {

                }

                @Override
                public void onResponse(String response)
                {

                }
            });

• 
  

（2）POST请求

 OkHttpUtils
    .post()
    .url(url)
    .addParams("username", "hyman")
    .addParams("password", "123")
    .build()
    .execute(callback);

• 
  

（3）Post String

OkHttpUtils
    .postString()
    .url(url)
    .content(new Gson().toJson(new User("zhy", "123")))
    .build()
    .execute(new MyStringCallback());   

• 
  

将string作为请求体传入到服务端，例如json字符串。

（4）Post File

OkHttpUtils
    .postFile()
    .url(url)
    .file(file)
    .build()
    .execute(new MyStringCallback());

• 
  

将file作为请求体传入到服务端.

（5）基于POST的文件上传（类似web上的表单）

OkHttpUtils.post()//
    .addFile("mFile", "messenger_01.png", file)//
    .addFile("mFile", "test1.txt", file2)//
    .url(url)
    .params(params)//
    .headers(headers)//
    .build()//
    .execute(new MyStringCallback());

• 
  

（6）下载文件

OkHttpUtils//
    .get()//
    .url(url)//
    .build()//
    .execute(new FileCallBack(Environment.getExternalStorageDirectory().getAbsolutePath(), "gson-2.2.1.jar")//
    {
        @Override
        public void inProgress(float progress)
        {
            mProgressBar.setProgress((int) (100 * progress));
        }

        @Override
        public void onError(Request request, Exception e)
        {
            Log.e(TAG, "onError :" + e.getMessage());
        }

        @Override
        public void onResponse(File file)
        {
            Log.e(TAG, "onResponse :" + file.getAbsolutePath());
        }
    });

• 
  

（7）显示图片

OkHttpUtils
    .get()//
    .url(url)//
    .build()//
    .execute(new BitmapCallback()
    {
        @Override
        public void onError(Request request, Exception e)
        {
            mTv.setText("onError:" + e.getMessage());
        }

        @Override
        public void onResponse(Bitmap bitmap)
        {
            mImageView.setImageBitmap(bitmap);
        }
    });

• 
  

哈，目前来看，清晰多了。

三、对于上传下载的回调

new Callback<?>()
{
    //...
    @Override
    public void inProgress(float progress)
    {
       //use progress: 0 ~ 1
    }
}

• 
  

对于传入的callback有个inProgress方法，需要拿到进度直接复写该方法即可。

四、对于自动解析为实体类

目前去除了Gson的依赖，提供了自定义Callback的方式，让用户自己去解析返回的数据，目前提供了StringCallback，FileCallback,BitmapCallback 分别用于返回string，文件下载，加载图片。

当然如果你希望解析为对象，你可以：

public abstract class UserCallback extends Callback<User>
{
    //非UI线程，支持任何耗时操作
    @Override
    public User parseNetworkResponse(Response response) throws IOException
    {
        String string = response.body().string();
        User user = new Gson().fromJson(string, User.class);
        return user;
    }
}

• 
  

自己使用自己喜欢的Json解析库完成即可。

解析成List<User>，则如下：

public abstract class ListUserCallback extends Callback<List<User>>
{
    @Override
    public List<User> parseNetworkResponse(Response response) throws IOException
    {
        String string = response.body().string();
        List<User> user = new Gson().fromJson(string, List.class);
        return user;
    }


}

• 
  

五、对于https单向认证

非常简单，拿到xxx.cert的证书。

然后调用

OkHttpUtils.getInstance()
        .setCertificates(inputstream);

• 
  

建议使用方式，例如我的证书放在assets目录：

/**
 * Created by zhy on 15/8/25.
 */
public class MyApplication extends Application
{
    @Override
    public void onCreate()
    {
        super.onCreate();

        try
        {    
        OkHttpUtils
         .getInstance()
         .setCertificates(getAssets().open("aaa.cer"),
 getAssets().open("server.cer"));
        } catch (IOException e)
        {
            e.printStackTrace();
        }
    }
}

• 
  

即可。别忘了注册Application。

注意：如果https网站为权威机构颁发的证书，不需要以上设置。自签名的证书才需要。

六、配置

（1）全局配置

可以在Application中，通过：

OkHttpClient client = 
OkHttpUtils.getInstance().getOkHttpClient();

• 
  

然后调用client的各种set方法。

例如：

client.setConnectTimeout(100000, TimeUnit.MILLISECONDS);

• 
  

（2）为单个请求设置超时

比如涉及到文件的需要设置读写等待时间多一点。

 OkHttpUtils
    .get()//
    .url(url)//
    .tag(this)//
    .build()//
    .connTimeOut(20000)
    .readTimeOut(20000)
    .writeTimeOut(20000)
    .execute()

• 
  

调用build()之后，可以随即设置各种timeOut.

（3）取消单个请求

 RequestCall call = OkHttpUtils.get().url(url).build();
 call.cancel();

• 
  

（4）根据tag取消请求

目前对于支持的方法都添加了最后一个参数Object tag，取消则通过OkHttpUtils.cancelTag(tag)执行。

例如：在Activity中，当Activity销毁取消请求：

OkHttpUtils
    .get()//
    .url(url)//
    .tag(this)//
    .build()//

@Override
protected void onDestroy()
{
    super.onDestroy();
    //可以取消同一个tag的
    OkHttpUtils.cancelTag(this);//取消以Activity.this作为tag的请求
}

• 
  

比如，当前Activity页面所有的请求以Activity对象作为tag，可以在onDestory里面统一取消。

七、浅谈封装

其实整个封装的过程比较简单，这里简单描述下，对于okhttp一个请求的流程大致是这样的：

//创建okHttpClient对象
OkHttpClient mOkHttpClient = new OkHttpClient();
//创建一个Request
final Request request = new Request.Builder()
                .url("https://github.com/hongyangAndroid")
                .build();
//new call
Call call = mOkHttpClient.newCall(request); 
//请求加入调度
call.enqueue(new Callback()
{
    @Override
    public void onFailure(Request request, IOException e)
    {
    }

    @Override
    public void onResponse(final Response response) throws IOException
    {
            //String htmlStr =  response.body().string();
    }
});             

• 
  

其中主要的差异，其实就是request的构建过程。

我对Request抽象了一个类：OkHttpRequest

public abstract class OkHttpRequest
{
    protected RequestBody requestBody;
    protected Request request;

    protected String url;
    protected String tag;
    protected Map<String, String> params;
    protected Map<String, String> headers;

    protected OkHttpRequest(String url, String tag,
                            Map<String, String> params, Map<String, String> headers)
    {
        this.url = url;
        this.tag = tag;
        this.params = params;
        this.headers = headers;
    }

    protected abstract Request buildRequest();
    protected abstract RequestBody buildRequestBody();

    protected void prepareInvoked(ResultCallback callback)
    {
        requestBody = buildRequestBody();
        requestBody = wrapRequestBody(requestBody, callback);
        request = buildRequest();
    }

    protected RequestBody wrapRequestBody(RequestBody requestBody, final ResultCallback callback)
    {
        return requestBody;
    }


    public void invokeAsyn(ResultCallback callback)
    {
        prepareInvoked(callback);
        mOkHttpClientManager.execute(request, callback);
    }


     // other common methods
 }   

• 
  

一个request的构建呢，我分三个步骤：buildRequestBody , wrapRequestBody ,buildRequest这样的次序，当以上三个方法没有问题时，我们就拿到了request，然后执行即可。

但是对于不同的请求，requestBody以及request的构建过程是不同的，所以大家可以看到buildRequestBody ,buildRequest为抽象的方法，也就是不同的请求类，比如OkHttpGetRequest、OkHttpPostRequest等需要自己去构建自己的request。

对于wrapRequestBody方法呢，可以看到它默认基本属于空实现，主要是因为并非所有的请求类都需要复写它，只有上传的时候呢，需要回调进度，需要对requestBody进行包装，所以这个方法类似于一个钩子。

其实这个过程有点类似模板方法模式，有兴趣可以看看一个短篇介绍设计模式 模版方法模式 展现程序员的一天 .

对于更加详细的用法，可以查看github上面的readme，以及demo，目前demo包含：

对于上传文件的两个按钮，需要自己搭建服务器，其他的按钮可以直接测试。

最后，由于本人水平有限，以及时间比较仓促~~发现问题，欢迎提issue，我会抽时间解决。 have a nice day ~

源码点击下载