Android 的OkHttp 网络请求框架的学习封装 - Android编程 - 软件开发资源站

首页 > 软件编程 > Android编程 > Android 的OkHttp 网络请求框架的学习封装

Android 的OkHttp 网络请求框架的学习封装
类别：Android编程作者：码皇来源：互联网点击：

自述：在此以前，自己从来没有写过博客，今天是第一次写，真心是有点小激动，正要下笔却不知道应该从何说起，若是写的不好，请各位见谅吧！关于网络请求，我自认为自己是一个菜鸟，没有任何经验，之前做的项目都是别人封装好，告诉我怎么调用就好了。

自述：在此以前，自己从来没有写过博客，今天是第一次写，真心是有点小激动，正要下笔却不知道应该从何说起，若是写的不好，请各位见谅吧！关于网络请求，我自认为自己是一个菜鸟，没有任何经验，之前做的项目都是别人封装好，告诉我怎么调用就好了。至于怎么封装逻辑的，真是一窍不通，可近来比较闲，就学习封装了一下OkHttp 。

OkHttp分为同步和异步请求；请求方式常用的有 get和post两种方式，封装请求的大致步骤为：

1、首先创建一个mOkHttpClient = new OkHttpClient()对象；

2、构建Request请求对象（根据get和post不同的请求方式分别创建）；

3、如果是 post请求还需要构建请求参数 Params，RequestBody requestBody = buildFormData(params); builder.post(requestBody).build;；

4、进行网络异步请求mOkHttpClient.newCall(request).enqueue(new Callback() {} ），如果是同步请求，则改为 Response response = mOkHttpClient.newCall(request).execute()进行；

具体实现就不细说了，直接上代码如下：

public class OkHttpManager {
private static OkHttpManager mOkHttpManager;
private OkHttpClient mOkHttpClient;
private Gson mGson;
private Handler handler;
private OkHttpManager() {
mOkHttpClient = new OkHttpClient();
mOkHttpClient.newBuilder().connectTimeout(10, TimeUnit.SECONDS).readTimeout(10, TimeUnit.SECONDS) .writeTimeout(10, TimeUnit.SECONDS);
mGson = new Gson();
handler = new Handler(Looper.getMainLooper());
}
//创建单例模式（OkHttp官方建议如此操作） public static OkHttpManager getInstance() {
if (mOkHttpManager == null) {
mOkHttpManager = new OkHttpManager();
}
return mOkHttpManager;
}
/*********************** * 对外公布的可调方法 ************************/ public void getRequest(String url, final BaseCallBack callBack) {
Request request = buildRequest(url, null, HttpMethodType.GET);
doRequest(request, callBack);
}
public void postRequest(String url, final BaseCallBack callBack, Map params) {
Request request = buildRequest(url, params, HttpMethodType.POST);
doRequest(request, callBack);
}
public void postUploadSingleImage(String url, final BaseCallBack callback, File file, String fileKey, Map params) {
Param[] paramsArr = fromMapToParams(params);
try {
postAsyn(url, callback, file, fileKey, paramsArr);
}
catch (IOException e) {
e.printStackTrace();
}
}
public void postUploadMoreImages(String url, final BaseCallBack callback, File[] files, String[] fileKeys, Map params) {
Param[] paramsArr = fromMapToParams(params);
try {
postAsyn(url, callback, files, fileKeys, paramsArr);
}
catch (IOException e) {
e.printStackTrace();
}
}
/*********************** * 对内方法 ************************/ //单个文件上传请求不带参数 private void postAsyn(String url, BaseCallBack callback, File file, String fileKey) throws IOException {
Request request = buildMultipartFormRequest(url, new File[]{
file}
, new String[]{
fileKey}
, null);
doRequest(request, callback);
}
//单个文件上传请求带参数 private void postAsyn(String url, BaseCallBack callback, File file, String fileKey, Param... params) throws IOException {
Request request = buildMultipartFormRequest(url, new File[]{
file}
, new String[]{
fileKey}
, params);
doRequest(request, callback);
}
//多个文件上传请求带参数 private void postAsyn(String url, BaseCallBack callback, File[] files, String[] fileKeys, Param... params) throws IOException {
Request request = buildMultipartFormRequest(url, files, fileKeys, params);
doRequest(request, callback);
}
//异步下载文件 public void asynDownloadFile(final String url, final String destFileDir, final BaseCallBack callBack) {
final Request request = buildRequest(url, null, HttpMethodType.GET);
callBack.OnRequestBefore(request);
//提示加载框 mOkHttpClient.newCall(request).enqueue(new Callback() {
@Override public void onFailure(Call call, IOException e) {
callBack.onFailure(call, e);
}
@Override public void onResponse(Call call, Response response) throws IOException {
// callBack.onResponse(response);
InputStream is = null;
byte[] buf = new byte[1024*2];
final long fileLength = response.body().contentLength();
int len = 0;
long readLength = 0;
FileOutputStream fos = null;
try {
is = response.body().byteStream();
File file = new File(destFileDir, getFileName(url));
fos = new FileOutputStream(file);
while ((len = is.read(buf)) != -1) {
fos.write(buf, 0, len);
readLength += len;
int curProgress = (int) (((float) readLength / fileLength) * 100);
Log.e("lgz", "onResponse: >>>>>>>>>>>>>" + curProgress + ", readLength = " + readLength + ", fileLength = " + fileLength);
callBack.inProgress(curProgress, fileLength, 0);
}
fos.flush();
//如果下载文件成功，第一个参数为文件的绝对路径 callBackSuccess(callBack, call, response, file.getAbsolutePath());
}
catch (IOException e) {
callBackError(callBack, call, response.code());
}
finally {
try {
if (is != null) is.close();
}
catch (IOException e) {
}
try {
if (fos != null) fos.close();
}
catch (IOException e) {
}
}
}
}
);
}
//构造上传图片 Request private Request buildMultipartFormRequest(String url, File[] files, String[] fileKeys, Param[] params) {
params = validateParam(params);
MultipartBody.Builder builder = new MultipartBody.Builder().setType(MultipartBody.FORM);
for (Param param : params) {
builder.addPart(Headers.of("Content-Disposition", "form-data;
name="" + param.key + """), RequestBody.create(MediaType.parse("image/png"), param.value));
}
if (files != null) {
RequestBody fileBody = null;
for (int i = 0;
i < files.length;
i++) {
File file = files[i];
String fileName = file.getName();
fileBody = RequestBody.create(MediaType.parse(guessMimeType(fileName)), file);
//TODO 根据文件名设置contentType builder.addPart(Headers.of("Content-Disposition", "form-data;
name="" + fileKeys[i] + "";
filename="" + fileName + """), fileBody);
}
}
RequestBody requestBody = builder.build();
return new Request.Builder() .url(url) .post(requestBody) .build();
}
//Activity页面所有的请求以Activity对象作为tag，可以在onDestory()里面统一取消,this public void cancelTag(Object tag) {
for (Call call : mOkHttpClient.dispatcher().queuedCalls()) {
if (tag.equals(call.request().tag())) {
call.cancel();
}
}
for (Call call : mOkHttpClient.dispatcher().runningCalls()) {
if (tag.equals(call.request().tag())) {
call.cancel();
}
}
}
private String guessMimeType(String path) {
FileNameMap fileNameMap = URLConnection.getFileNameMap();
String contentTypeFor = fileNameMap.getContentTypeFor(path);
if (contentTypeFor == null) {
contentTypeFor = "application/octet-stream";
}
return contentTypeFor;
}
private String getFileName(String path) {
int separatorIndex = path.lastIndexOf("/");
return (separatorIndex < 0) ? path : path.substring(separatorIndex + 1, path.length());
}
private Param[] fromMapToParams(Map params) {
if (params == null) return new Param[0];
int size = params.size();
Param[] res = new Param[size];
Set> entries = params.entrySet();
int i = 0;
for (Map.Entry entry : entries) {
res[i++] = new Param(entry.getKey(), entry.getValue());
}
return res;
}
//去进行网络异步请求 private void doRequest(Request request, final BaseCallBack callBack) {
callBack.OnRequestBefore(request);
mOkHttpClient.newCall(request).enqueue(new Callback() {
@Override public void onFailure(Call call, IOException e) {
callBack.onFailure(call, e);
}
@Override public void onResponse(Call call, Response response) throws IOException {
callBack.onResponse(response);
String result = response.body().string();
if (response.isSuccessful()) {
if (callBack.mType == String.class) {
// callBack.onSuccess(call, response, result);
callBackSuccess(callBack, call, response, result);
}
else {
try {
Object object = mGson.fromJson(result, callBack.mType);
//自动转化为泛型对象// callBack.onSuccess(call, response, object);
callBackSuccess(callBack, call, response, object);
}
catch (JsonParseException e) {
//json解析错误时调用 callBack.onEror(call, response.code(), e);
}
}
}
else {
callBack.onEror(call, response.code(), null);
}
}
}
);
}
//创建 Request对象 private Request buildRequest(String url, Map params, HttpMethodType methodType) {
Request.Builder builder = new Request.Builder();
builder.url(url);
if (methodType == HttpMethodType.GET) {
builder.get();
}
else if (methodType == HttpMethodType.POST) {
RequestBody requestBody = buildFormData(params);
builder.post(requestBody);
}
return builder.build();
}
//构建请求所需的参数表单 private RequestBody buildFormData(Map params) {
FormBody.Builder builder = new FormBody.Builder();
builder.add("platform", "android");
builder.add("version", "1.0");
builder.add("key", "123456");
if (params != null) {
for (Map.Entry entry : params.entrySet()) {
builder.add(entry.getKey(), entry.getValue());
}
}
return builder.build();
}
private void callBackSuccess(final BaseCallBack callBack, final Call call, final Response response, final Object object) {
handler.post(new Runnable() {
@Override public void run() {
callBack.onSuccess(call, response, object);
}
}
);
}
private void callBackError(final BaseCallBack callBack, final Call call, final int code) {
handler.post(new Runnable() {
@Override public void run() {
callBack.onEror(call, code, null);
}
}
);
}
private Param[] validateParam(Param[] params) {
if (params == null) return new Param[0];
else return params;
}
public static class Param {
public Param() {
}
public Param(String key, String value) {
this.key = key;
this.value = value;
}
String key;
String value;
}
enum HttpMethodType {
GET, POST }
}

其中的 BaseCallBack回调机制封装如下：

public abstract class BaseCallBack {
public Type mType;
static Type getSuperclassTypeParameter(Class subclass) {
Type superclass = subclass.getGenericSuperclass();
if (superclass instanceof Class) {
throw new RuntimeException("Missing type parameter.");
}
ParameterizedType parameterized = (ParameterizedType) superclass;
return $Gson$Types.canonicalize(parameterized.getActualTypeArguments()[0]);
}
public BaseCallBack() {
mType = getSuperclassTypeParameter(getClass());
}
protected abstract void OnRequestBefore(Request request);
protected abstract void onFailure(Call call, IOException e);
protected abstract void onSuccess(Call call, Response response, T t);
protected abstract void onResponse(Response response);
protected abstract void onEror(Call call, int statusCode, Exception e);
protected abstract void inProgress(int progress, long total , int id);
}

上面这个类OkHttpManager 是我根据网络上各家资源学习封装好的，copy进代码可以直接使用，并且根据okhttp3.0以后的版本，对之前的一下请求参数设置进行了最新的修改，具体如下：

1、设置请求超时参数；

okhttp3.0以前的版本是这样设置的

new OkHttpClient();

mHttpClient.setConnectTimeout(10, TimeUnit.SECONDS);

mHttpClient.setReadTimeout(10,TimeUnit.SECONDS);

mHttpClient.setWriteTimeout(30,TimeUnit.SECONDS);

之后的版本是这样设置的：

new OkHttpClient.Builder()
.readTimeout(READ_TIMEOUT,TimeUnit.SECONDS)//设置读取超时时间
.writeTimeout(WRITE_TIMEOUT,TimeUnit.SECONDS)//设置写的超时时间
.connectTimeout(CONNECT_TIMEOUT,TimeUnit.SECONDS)//设置连接超时时间

2、post方式请求时，构建表单对象参数；

okhttp3.0以前的版本是这样构建的：new FormEncodingBuilder（）对象，然后向里面add (key,value)参数；

之后的版本更改为：FormBody body = new FormBody.Builder()，.add(key, value)；即是FormEncodingBuilder已被FormBody取代；

至于BaseCallBack类，根据请求数据的功能的不同，还需要对此进行封装，集成自己需要的方法实现；

一、进行一般的数据加载请求，可直接调用如下：

模拟用户登录：

Map params = new HashMap();
params.put("Mobile", username.getText().toString());
params.put("PassWord", password.getText().toString());
OkHttpManager.getInstance().postRequest(Constants.LOGIN_URL, new LoadCallBack(getActivity()) {
@Override protected void onSuccess(Call call, Response response, String s) {
Log.e("lgz", "onSuccess = " + s);
Toast.makeText(getActivity(), "登录成功！", Toast.LENGTH_LONG).show();
}
@Override protected void onEror(Call call, int statusCode, Exception e) {
Log.e("lgz", "Exception = " + e.toString());
}
}
, params);

上面登录请求中就用到了自己根据需要再次封装的Callback类的继承实现，LoadCallBack类：

//添加对请求时对话框的处理public abstract class LoadCallBack extends BaseCallBack {
private Context context;
private SpotsDialog spotsDialog;
public LoadCallBack(Context context) {
this.context = context;
spotsDialog = new SpotsDialog(context);
}
private void showDialog() {
spotsDialog.show();
}
private void hideDialog() {
if (spotsDialog != null) {
spotsDialog.dismiss();
}
}
public void setMsg(String str) {
spotsDialog.setMessage(str);
}
public void setMsg(int resId) {
spotsDialog.setMessage(context.getString(resId));
}
@Override protected void OnRequestBefore(Request request) {
showDialog();
}
@Override protected void onFailure(Call call, IOException e) {
hideDialog();
}
@Override protected void onResponse(Response response) {
hideDialog();
}
@Override protected void inProgress(int progress, long total, int id) {
}

其实这个类就是对BaseCallBack再次继承实现；

二、下载文件，并显示进度条对话框的请求操作：

下载一张图片：

OkHttpManager.getInstance().asynDownloadFile("http://www.7mlzg.com/uploads/bwf_1477419976.jpg", FILE_PATH, new FileCallBack(getActivity()) {
@Override protected void onResponse(Response response) {
}
@Override protected void onSuccess(Call call, Response response, String s) {
super.onSuccess(call, response, s);
Log.e("lgz", "status = : " + s);
Toast.makeText(getActivity(), "下载成功", Toast.LENGTH_LONG).show();
Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);
Uri uri = Uri.fromFile(new File(s));
//广播通知系统图集更新 intent.setData(uri);
getActivity().sendBroadcast(intent);
}
}
);

上面下载图片中，就用到了自己根据需要再次继承Callback类封装得到的FileCallBack类如下：

public abstract class FileCallBack extends BaseCallBack {
private Context mContext;
private ProgressDialog mProgressDialog;
public FileCallBack(Context context) {
mContext = context;
initDialog();
}
private void initDialog(){
mProgressDialog = new ProgressDialog(mContext);
mProgressDialog.setTitle("下载中...");
mProgressDialog.setCanceledOnTouchOutside(true);
mProgressDialog.setProgressStyle(ProgressDialog.STYLE_HORIZONTAL);
mProgressDialog.setMax(100);
}
private void hideDialog() {
if (mProgressDialog != null) {
mProgressDialog.dismiss();
}
}
@Override protected void OnRequestBefore(Request request) {
mProgressDialog.show();
}
@Override protected void onFailure(Call call, IOException e) {
hideDialog();
}
@Override protected void onSuccess(Call call, Response response, T t) {
Log.e("lgz", "onSuccess: >>>>>>>>>>>>>");
hideDialog();
}
@Override protected void onEror(Call call, int statusCode, Exception e) {
hideDialog();
}
@Override protected void inProgress(int progress, long total, int id) {
Log.e("lgz", "inProgress: >>>>>>>>>>>>>"+progress);
mProgressDialog.setProgress(progress);
}
}

三、最后说一下使用okhttp的配置：

在Android Studio 中，直接在build.gradle文件里配置：compile 'com.squareup.okhttp3:okhttp:3.4.1'

在Eclipse里需要导入jar包使用，下载最新jar；

当然了，这里只是对Okhttp常用的一些功能进行了封装处理，使用的都是异步请求方式，至于同步操作，我个人觉得不是很常用，使用时需要开启一个线程，不然会阻塞UI线程的；最后，这只是一个简单的学习，其中要是有不足和错误，还希望大家留言批评指正，谢谢！

相关热词搜索：

上一篇：Android各种访问权限Permission详解
下一篇：Android Studio Instant Run的工作原理

Android 的OkHttp 网络请求框架的学习封装 类别：Android编程 作者：码皇 来源：互联网 点击：

Android 的OkHttp 网络请求框架的学习封装
类别：Android编程作者：码皇来源：互联网点击：