目的：对主流框架OKHttp的封装，达到一行代码实现一个业务逻辑，避免繁琐的代码调用
开发工具：android studio
配置OKHttp：
compile "com.squareup.okhttp3:okhttp:3.5.0"
compile "com.squareup.okhttp3:logging-interceptor:3.5.0" 一个封装类如下： 需要修改 BASE_URL package com.anzer.meetingminutes.utils;
import android.content.Context;
import android.os.Build;
import android.os.Handler;
import android.util.Log;
import com.anzer.meetingminutes.bean.UploadInfo;
import java.io.File;
import java.io.IOException;
import java.net.URLEncoder;
import java.util.HashMap;
import java.util.concurrent.TimeUnit;
import okhttp3.Call;
import okhttp3.Callback;
import okhttp3.FormBody;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okio.Buffer;
import okio.BufferedSink;
import okio.Okio;
import okio.Source;
public class OkHttpManager {
private static final MediaType MEDIA_TYPE_JSON = MediaType.parse("application/x-www-form-urlencoded; charset=utf-8");//mdiatype 这个需要和服务端保持一致
private static final MediaType MEDIA_TYPE_MARKDOWN = MediaType.parse("text/x-markdown; charset=utf-8");//mdiatype 这个需要和服务端保持一致
private static final String TAG = com.bumptech.glide.RequestManager.class.getSimpleName();
private static final String BASE_URL = "http://192.168.16.146:8081";//请求接口根地址
private static volatile OkHttpManager mInstance;//单利引用
public static final int TYPE_GET = 0;//get请求
public static final int TYPE_POST_JSON = 1;//post请求参数为json
public static final int TYPE_POST_FORM = 2;//post请求参数为表单
private OkHttpClient mOkHttpClient;//okHttpClient 实例
private Handler okHttpHandler;//全局处理子线程和M主线程通信
/**
* 初始化RequestManager
*/
private OkHttpManager(Context context) {
//初始化OkHttpClient
mOkHttpClient = new OkHttpClient().newBuilder()
.connectTimeout(10, TimeUnit.SECONDS)//设置超时时间
.readTimeout(10, TimeUnit.SECONDS)//设置读取超时时间
.writeTimeout(10, TimeUnit.SECONDS)//设置写入超时时间
.build();
//初始化Handler
okHttpHandler = new Handler(context.getMainLooper());
}
/**
* 获取单例引用
*
* @return
*/
public static OkHttpManager getInstance(Context context) {
OkHttpManager inst = mInstance;
if (inst == null) {
synchronized (OkHttpManager.class) {
inst = mInstance;
if (inst == null) {
inst = new OkHttpManager(context.getApplicationContext());
mInstance = inst;
}
}
}
return inst;
}
/**
* okHttp同步请求统一入口
* @param actionUrl 接口地址
* @param requestType 请求类型
* @param paramsMap 请求参数
*/
public void requestSyn(String actionUrl, int requestType, HashMap<String, String> paramsMap) {
switch (requestType) {
case TYPE_GET:
requestGetBySyn(actionUrl, paramsMap);
break;
case TYPE_POST_JSON:
requestPostBySyn(actionUrl, paramsMap);
break;
case TYPE_POST_FORM:
requestPostBySynWithForm(actionUrl, paramsMap);
break;
}
}
/**
* okHttp get同步请求
* @param actionUrl 接口地址
* @param paramsMap 请求参数
*/
private void requestGetBySyn(String actionUrl, HashMap<String, String> paramsMap) {
StringBuilder tempParams = new StringBuilder();
try {
//处理参数
int pos = 0;
for (String key : paramsMap.keySet()) {
if (pos > 0) {
tempParams.append("&");
}
//对参数进行URLEncoder
tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
pos++;
}
//补全请求地址
String requestUrl = String.format("%s/%s?%s", BASE_URL, actionUrl, tempParams.toString());
//创建一个请求
Request request = addHeaders().url(requestUrl).build();
//创建一个Call
final Call call = mOkHttpClient.newCall(request);
//执行请求
final Response response = call.execute();
response.body().string();
} catch (Exception e) {
Log.e(TAG, e.toString());
}
}
/**
* okHttp post同步请求
* @param actionUrl 接口地址
* @param paramsMap 请求参数
*/
private void requestPostBySyn(String actionUrl, HashMap<String, String> paramsMap) {
try {
//处理参数
StringBuilder tempParams = new StringBuilder();
int pos = 0;
for (String key : paramsMap.keySet()) {
if (pos > 0) {
tempParams.append("&");
}
tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
pos++;
}
//补全请求地址
String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
//生成参数
String params = tempParams.toString();
//创建一个请求实体对象 RequestBody
RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, params);
//创建一个请求
final Request request = addHeaders().url(requestUrl).post(body).build();
//创建一个Call
final Call call = mOkHttpClient.newCall(request);
//执行请求
Response response = call.execute();
//请求执行成功
if (response.isSuccessful()) {
//获取返回数据 可以是String，bytes ,byteStream
Log.e(TAG, "response ----->" + response.body().string());
}
} catch (Exception e) {
Log.e(TAG, e.toString());
}
}
/**
* okHttp post同步请求表单提交
* @param actionUrl 接口地址
* @param paramsMap 请求参数
*/
private void requestPostBySynWithForm(String actionUrl, HashMap<String, String> paramsMap) {
try {
//创建一个FormBody.Builder
FormBody.Builder builder = new FormBody.Builder();
for (String key : paramsMap.keySet()) {
//追加表单信息
builder.add(key, paramsMap.get(key));
}
//生成表单实体对象
RequestBody formBody = builder.build();
//补全请求地址
String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
//创建一个请求
final Request request = addHeaders().url(requestUrl).post(formBody).build();
//创建一个Call
final Call call = mOkHttpClient.newCall(request);
//执行请求
Response response = call.execute();
if (response.isSuccessful()) {
Log.e(TAG, "response ----->" + response.body().string());
}
} catch (Exception e) {
Log.e(TAG, e.toString());
}
}
/**
* okHttp异步请求统一入口
* @param actionUrl 接口地址
* @param requestType 请求类型
* @param paramsMap 请求参数
* @param callBack 请求返回数据回调
* @param <T> 数据泛型
**/
public <T> Call requestAsyn(String actionUrl, int requestType, HashMap<String, String> paramsMap, ReqCallBack<T> callBack) {
Call call = null;
switch (requestType) {
case TYPE_GET:
call = requestGetByAsyn(actionUrl, paramsMap, callBack);
break;
case TYPE_POST_JSON:
call = requestPostByAsyn(actionUrl, paramsMap, callBack);
break;
case TYPE_POST_FORM:
call = requestPostByAsynWithForm(actionUrl, paramsMap, callBack);
break;
}
return call;
}
/**
* okHttp get异步请求
* @param actionUrl 接口地址
* @param paramsMap 请求参数
* @param callBack 请求返回数据回调
* @param <T> 数据泛型
* @return
*/
private <T> Call requestGetByAsyn(String actionUrl, HashMap<String, String> paramsMap, final ReqCallBack<T> callBack) {
StringBuilder tempParams = new StringBuilder();
try {
int pos = 0;
for (String key : paramsMap.keySet()) {
if (pos > 0) {
tempParams.append("&");
}
tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
pos++;
}
String requestUrl = String.format("%s/%s?%s", BASE_URL, actionUrl, tempParams.toString());
final Request request = addHeaders().url(requestUrl).build();
final Call call = mOkHttpClient.newCall(request);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
failedCallBack("访问失败", callBack);
Log.e(TAG, e.toString());
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (response.isSuccessful()) {
String string = response.body().string();
Log.e(TAG, "response ----->" + string);
successCallBack((T) string, callBack);
} else {
failedCallBack("服务器错误", callBack);
}
}
});
return call;
} catch (Exception e) {
Log.e(TAG, e.toString());
}
return null;
}
/**
* okHttp post异步请求
* @param actionUrl 接口地址
* @param paramsMap 请求参数
* @param callBack 请求返回数据回调
* @param <T> 数据泛型
* @return
*/
private <T> Call requestPostByAsyn(String actionUrl, HashMap<String, String> paramsMap, final ReqCallBack<T> callBack) {
try {
StringBuilder tempParams = new StringBuilder();
int pos = 0;
for (String key : paramsMap.keySet()) {
if (pos > 0) {
tempParams.append("&");
}
tempParams.append(String.format("%s=%s", key, URLEncoder.encode(paramsMap.get(key), "utf-8")));
pos++;
}
String params = tempParams.toString();
RequestBody body = RequestBody.create(MEDIA_TYPE_JSON, params);
String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
final Request request = addHeaders().url(requestUrl).post(body).build();
final Call call = mOkHttpClient.newCall(request);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
failedCallBack("访问失败", callBack);
Log.e(TAG, e.toString());
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (response.isSuccessful()) {
String string = response.body().string();
Log.e(TAG, "response ----->" + string);
successCallBack((T) string, callBack);
} else {
failedCallBack("服务器错误", callBack);
}
}
});
return call;
} catch (Exception e) {
Log.e(TAG, e.toString());
}
return null;
}
/**
* okHttp post异步请求表单提交
* @param actionUrl 接口地址
* @param paramsMap 请求参数
* @param callBack 请求返回数据回调
* @param <T> 数据泛型
* @return
*/
private <T> Call requestPostByAsynWithForm(String actionUrl, HashMap<String, String> paramsMap, final ReqCallBack<T> callBack) {
try {
FormBody.Builder builder = new FormBody.Builder();
for (String key : paramsMap.keySet()) {
builder.add(key, paramsMap.get(key));
}
RequestBody formBody = builder.build();
String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
final Request request = addHeaders().url(requestUrl).post(formBody).build();
final Call call = mOkHttpClient.newCall(request);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
failedCallBack("访问失败", callBack);
Log.e(TAG, e.toString());
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (response.isSuccessful()) {
String string = response.body().string();
Log.e(TAG, "response ----->" + string);
successCallBack((T) string, callBack);
} else {
failedCallBack("服务器错误", callBack);
}
}
});
return call;
} catch (Exception e) {
Log.e(TAG, e.toString());
}
return null;
}
public interface ReqCallBack<T> {
/**
* 响应成功
*/
void onReqSuccess(T result);
/**
* 响应失败
*/
void onReqFailed(String errorMsg);
}
/**
* 统一为请求添加头信息
* @return
*/
private Request.Builder addHeaders() {
Request.Builder builder = new Request.Builder()
.addHeader("Connection", "keep-alive")
.addHeader("platform", "2")
.addHeader("phoneModel", Build.MODEL)
.addHeader("systemVersion", Build.VERSION.RELEASE)
.addHeader("appVersion", "3.2.0");
return builder;
}
/**
* 统一同意处理成功信息
* @param result
* @param callBack
* @param <T>
*/
private <T> void successCallBack(final T result, final ReqCallBack<T> callBack) {
okHttpHandler.post(new Runnable() {
@Override
public void run() {
if (callBack != null) {
callBack.onReqSuccess(result);
}
}
});
}
/**
* 统一处理失败信息
* @param errorMsg
* @param callBack
* @param <T>
*/
private <T> void failedCallBack(final String errorMsg, final ReqCallBack<T> callBack) {
okHttpHandler.post(new Runnable() {
@Override
public void run() {
if (callBack != null) {
callBack.onReqFailed(errorMsg);
}
}
});
}
/**
* 不带参数上传文件
* @param actionUrl 接口地址
* @param filePath 本地文件地址
*/
public <T> void upLoadFile(String actionUrl, String filePath, final ReqCallBack<T> callBack) {
/*
//补全请求地址
String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
//创建File
File file = new File(filePath);
//创建RequestBody
RequestBody body = RequestBody.create(MEDIA_OBJECT_STREAM, file);
//创建Request
final Request request = new Request.Builder().url(requestUrl).post(body).build();
final Call call = mOkHttpClient.newBuilder().writeTimeout(50, TimeUnit.SECONDS).build().newCall(request);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Log.e(TAG, e.toString());
failedCallBack("上传失败", callBack);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (response.isSuccessful()) {
String string = response.body().string();
Log.e(TAG, "response ----->" + string);
successCallBack((T) string, callBack);
} else {
failedCallBack("上传失败", callBack);
}
}
});
*/
}
/**
* 带参数上传文件
* @param actionUrl 接口地址
* @param paramsMap 参数
* @param callBack 回调
* @param <T>
*/
public <T>void upLoadFile(String actionUrl, HashMap<String, Object> paramsMap, final ReqCallBack<T> callBack) {
try {
//补全请求地址
String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
MultipartBody.Builder builder = new MultipartBody.Builder();
//设置类型
builder.setType(MultipartBody.FORM);
//追加参数
for (String key : paramsMap.keySet()) {
Object object = paramsMap.get(key);
if (!(object instanceof File)) {
builder.addFormDataPart(key, object.toString());
} else {
File file = (File) object;
builder.addFormDataPart(key, file.getName(), RequestBody.create(null, file));
}
}
//创建RequestBody
RequestBody body = builder.build();
//创建Request
final Request request = new Request.Builder().url(requestUrl).post(body).build();
//单独设置参数 比如读取超时时间
final Call call = mOkHttpClient.newBuilder().writeTimeout(50, TimeUnit.SECONDS).build().newCall(request);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Log.e(TAG, e.toString());
failedCallBack("上传失败", callBack);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (response.isSuccessful()) {
String string = response.body().string();
Log.e(TAG, "response ----->" + string);
successCallBack((T) string, callBack);
} else {
failedCallBack("上传失败", callBack);
}
}
});
} catch (Exception e) {
Log.e(TAG, e.toString());
}
}
/**
* 带参数带进度上传文件
* @param actionUrl 接口地址
* @param paramsMap 参数
* @param callBack 回调
* @param <T>
*/
public <T> void upLoadFile(String actionUrl, HashMap<String, Object> paramsMap, final ReqProgressCallBack<T> callBack) {
try {
//补全请求地址
String requestUrl = String.format("%s/%s", BASE_URL, actionUrl);
MultipartBody.Builder builder = new MultipartBody.Builder();
//设置类型
builder.setType(MultipartBody.FORM);
//追加参数
for (String key : paramsMap.keySet()) {
Object object = paramsMap.get(key);
if (!(object instanceof File)) {
builder.addFormDataPart(key, object.toString());
} else {
File file = (File) object;
builder.addFormDataPart(key, file.getName(), createProgressRequestBody(MediaType.parse("application/octet-stream"), file, callBack));
}
}
//创建RequestBody
RequestBody body = builder.build();
//创建Request
final Request request = new Request.Builder().url(requestUrl).post(body).build();
final Call call = mOkHttpClient.newBuilder().writeTimeout(50, TimeUnit.SECONDS).build().newCall(request);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Log.e(TAG, e.toString());
failedCallBack("上传失败", callBack);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
if (response.isSuccessful()) {
String string = response.body().string();
Log.i(TAG, "response ----->" + string);
successCallBack((T) string, callBack);
} else {
failedCallBack("上传失败", callBack);
}
}
});
} catch (Exception e) {
Log.e(TAG, e.toString());
}
}
/**
* 创建带进度的RequestBody
* @param contentType MediaType
* @param file 准备上传的文件
* @param callBack 回调
* @param <T>
* @return
*/
public <T> RequestBody createProgressRequestBody(final MediaType contentType, final File file, final ReqProgressCallBack<T> callBack) {
return new RequestBody() {
@Override
public MediaType contentType() {
return contentType;
}
@Override
public long contentLength() {
return file.length();
}
@Override
public void writeTo(BufferedSink sink) throws IOException {
Source source;
try {
source = Okio.source(file);
Buffer buf = new Buffer();
long remaining = contentLength();
long current = 0;
for (long readCount; (readCount = source.read(buf, 2048)) != -1; ) {
sink.write(buf, readCount);
current += readCount;
Log.i(TAG, "createProgressRequestBody writeTo current------>" + current);
progressCallBack(remaining, current, callBack);
}
} catch (Exception e) {
e.printStackTrace();
}
}
};
}
/**
* 不带进度文件下载
* @param fileUrl 文件url
* @param destFileDir 存储目标目录
*/
public <T> void downLoadFile(String fileUrl, final String destFileDir, final ReqCallBack<T> callBack) {
// final String fileName = MD5.encode(fileUrl);
// final File file = new File(destFileDir, fileName);
// if (file.exists()) {
// successCallBack((T) file, callBack);
// return;
// }
// final Request request = new Request.Builder().url(fileUrl).build();
// final Call call = mOkHttpClient.newCall(request);
// call.enqueue(new Callback() {
// @Override
// public void onFailure(Call call, IOException e) {
// Log.e(TAG, e.toString());
// failedCallBack("下载失败", callBack);
// }
//
// @Override
// public void onResponse(Call call, Response response) throws IOException {
// InputStream is = null;
// byte[] buf = new byte[2048];
// int len = 0;
// FileOutputStream fos = null;
// try {
// long total = response.body().contentLength();
// Log.e(TAG, "total------>" + total);
// long current = 0;
// is = response.body().byteStream();
// fos = new FileOutputStream(file);
// while ((len = is.read(buf)) != -1) {
// current += len;
// fos.write(buf, 0, len);
// Log.e(TAG, "current------>" + current);
// }
// fos.flush();
// successCallBack((T) file, callBack);
// } catch (IOException e) {
// Log.e(TAG, e.toString());
// failedCallBack("下载失败", callBack);
// } finally {
// try {
// if (is != null) {
// is.close();
// }
// if (fos != null) {
// fos.close();
// }
// } catch (IOException e) {
// Log.e(TAG, e.toString());
// }
// }
// }
// });
}
/**
* 下载文件
* @param fileUrl 文件url
* @param destFileDir 存储目标目录
*/
public <T> void downLoadFile(String fileUrl, final String destFileDir, final ReqProgressCallBack<T> callBack) {
/*
final String fileName = MD5.encode(fileUrl);
final File file = new File(destFileDir, fileName);
if (file.exists()) {
successCallBack((T) file, callBack);
return;
}
final Request request = new Request.Builder().url(fileUrl).build();
final Call call = mOkHttpClient.newCall(request);
call.enqueue(new Callback() {
@Override
public void onFailure(Call call, IOException e) {
Log.e(TAG, e.toString());
failedCallBack("下载失败", callBack);
}
@Override
public void onResponse(Call call, Response response) throws IOException {
InputStream is = null;
byte[] buf = new byte[2048];
int len = 0;
FileOutputStream fos = null;
try {
long total = response.body().contentLength();
Log.e(TAG, "total------>" + total);
long current = 0;
is = response.body().byteStream();
fos = new FileOutputStream(file);
while ((len = is.read(buf)) != -1) {
current += len;
fos.write(buf, 0, len);
Log.e(TAG, "current------>" + current);
progressCallBack(total, current, callBack);
}
fos.flush();
successCallBack((T) file, callBack);
} catch (IOException e) {
Log.e(TAG, e.toString());
failedCallBack("下载失败", callBack);
} finally {
try {
if (is != null) {
is.close();
}
if (fos != null) {
fos.close();
}
} catch (IOException e) {
Log.e(TAG, e.toString());
}
}
}
});
*/
}
public interface ReqProgressCallBack<T> extends ReqCallBack<T>{
/**
* 响应进度更新
*/
void onProgress(long total, long current);
}
/**
* 统一处理进度信息
* @param total 总计大小
* @param current 当前进度
* @param callBack
* @param <T>
*/
private <T> void progressCallBack(final long total, final long current, final ReqProgressCallBack<T> callBack) {
okHttpHandler.post(new Runnable() {
@Override
public void run() {
if (callBack != null) {
callBack.onProgress(total, current);
}
}
});
}
/**
*for test
*/
public void test(Context context){
//上传文件
OkHttpManager okHttpManager=OkHttpManager.getInstance(context);
HashMap<String,Object> paramMap=new HashMap<String,Object>();
paramMap.put("file",new File("/mnt/sdacad/test.amr"));
paramMap.put("filetype",2);
okHttpManager.upLoadFile("/baseupload",paramMap,new OkHttpManager.ReqProgressCallBack<String>(){
@Override
public void onProgress(long total, long current) {
Log.i(TAG,"upLoadFile onProgress total -->"+total+",current-->"+current);
}
@Override
public void onReqSuccess(String result) {
Log.i(TAG,"upLoadFile onReqSuccess result -->"+result);
}
@Override
public void onReqFailed(String errorMsg) {
Log.e(TAG,"upLoadFile onReqFailed -->"+errorMsg);
}
});
}
}
![与专家面对面：Android开发入门问与答[图]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)