devbox
lpred
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

Android Okhttp3的使用（很全面，包含Post提交字符串、键值对、表单、上传文件、无参请求和Get有参无参请求，还有自动添加token）

作者：lpred | 2024-01-29 23:41:44

赞

踩

android okhttp3

Okhttp简介

okhttp是现代化应用程序的网络通信的方式。它用来帮助程序交换数据和媒体信息，使用okhttp可以让你的程序加载物料(翻译为服务器数据更合适在)更加高效、更节省网络带宽。

okhttp通过以下措施让你的网络更加高效
1. HTTP/2支持对同一个host的所有网络请求 共享socket。
2. 在不启用HTTP/2的情况，连接池能减少潜在的网络请求。
3. 透明GZIP技术压缩了下载数据的大小。
4. 结果缓存技术避免重复的网络请求。

   OkHttp在网络出现问题时，仍然能支持良好的运行。它能解决常见的网络连接问题。如果你的服务端有多个ip地址，okhttp会在第一个地址连接失败时，自动尝试备用地址。 这种技术在你的服务器有多地备份时，是必须要用到的。OkHttp支持现代TLS特性(TLS 1.3、ALPN、证书固定)。可以将其配置为回滚以实现广播连接。

Okhttp优点

1. 支持HTTP2/SPDY（SPDY是Google开发的基于TCP的传输层协议，用以最小化网络延迟，提升网络速度，优化用户的网络使用体验）。
2. socket自动选择最好路线，并支持自动重连，拥有自动维护的socket连接池，减少握手次数，减少了请求延迟，共享Socket,减少对服务器的请求次数。
3. 基于Headers的缓存策略减少重复的网络请求。
4. 拥有Interceptors轻松处理请求与响应（自动处理GZip压缩）。


Okhttp的应用

用于替代HttpUrlConnection和Apache HttpClient
Android4.4开始，google已经开始将源码中的HttpURLConnection替换为OkHttp
Android6.0里已移除HttpClient。

OKhttp的功能

  1. PUT，DELETE，POST，GET等请求
  2. 文件的上传下载
  3. 加载图片(内部会图片大小自动压缩)
  4. 支持请求回调，直接返回对象、对象集合
  5. 支持session的保持

使用方式

以下代码在项目里，项目地址：https://gitee.com/urasaki/RxJava2AndRetrofit2

1.首先添加访问网络权限在manifest里。

  1. <!-- 允许访问网络的权限 -->
  2. <uses-permission android:name="android.permission.INTERNET" />

2.添加依赖（如果同步失败，可能是因为公司的网络有好多情况下连不到Google的仓库，所以就要连接自己的手机热点进行同步，手机热点一般会同步成功的，但是注意流量消耗）。

  1. //okhttp3网络框架导入（我用的Android Studio 3.0.1）
  2. implementation 'com.squareup.okhttp3:okhttp:3.12.0'
  3. //fastjson(阿里云json解析框架导入)
  4. implementation 'com.alibaba:fastjson:1.2.61'

3.初始化Okhttp3。

（1）Okhttp3的初始化。

  1.  
  2.     private static final String TAG = Okhttp3Manager.class.getSimpleName();
  3.     private OkHttpClient client;
  4.     private static Okhttp3Manager manager;
  5.     public static final int UPDATA = 666;
  6.  
  7.     /**
  8.      * 单例模式，所以构造函数私有化
  9.      */
  10.     private Okhttp3Manager() {
  11.         //创建OkHttpClient对象
  12.         client = new OkHttpClient.Builder()
  13.                 .connectTimeout(5000, TimeUnit.MILLISECONDS) //连接超时
  14.                 .readTimeout(5000, TimeUnit.MILLISECONDS) //读取超时
  15.                 .writeTimeout(5000, TimeUnit.MILLISECONDS) //写入超时
  16.                 .addInterceptor(new AddAccessTokenInterceptor(BaseApplication.getInstance())) //拦截器用于设置header
  17.                 .addInterceptor(new ReceivedAccessTokenInterceptor(BaseApplication.getInstance())) //拦截器用于接收并持久化cookie
  18.                 .sslSocketFactory(SSLSocketManager.getSSLSocketFactory())//配置（只有https请求需要配置）
  19.                 .hostnameVerifier(SSLSocketManager.getHostnameVerifier())//配置（只有https请求需要配置）
  20. //                .proxy(Proxy.NO_PROXY)
  21.                 .build();
  22.     }
  23.  
  24.     /**
  25.      * 线程安全的单例模式，整个项目中只有一个okhttp3实例
  26.      *
  27.      * @return
  28.      */
  29.     public static Okhttp3Manager getInstance() {
  30.         if (manager == null) {
  31.             synchronized (Okhttp3Manager.class) {
  32.                 if (manager == null) {
  33.                     manager = new Okhttp3Manager();
  34.                 }
  35.             }
  36.         }
  37.         return manager;
  38.     }

（2）添加token拦截器（关于accessToken的详细说明，请看还傻傻分不清 Cookie、Session、Token、JWT？_UrasakiNakajima的博客-CSDN博客_jwt和token区别。）

  1. public class AddTokenInterceptor implements Interceptor {
  2. 	
  3. 	private static final String          TAG = "AddCookiesInterceptor";
  4. 	private              BaseApplication baseApplication;
  5. 	
  6. 	public AddTokenInterceptor(BaseApplication baseApplication) {
  7. 		super();
  8. 		this.baseApplication = baseApplication;
  9. 	}
  10. 	
  11. 	@NonNull
  12. 	@Override
  13. 	public Response intercept(@NonNull Chain chain) throws IOException {
  14. 		
  15. 		Request.Builder builder = chain.request().newBuilder();
  16. 		
  17. 		//添加accessToken
  18. 		String accessToken = baseApplication.getAccessToken();
  19. 		if (!TextUtils.isEmpty(accessToken)) {
  20. 			builder.addHeader("accessToken", accessToken);
  21. 			LogManager.i(TAG, "accessToken*****" + accessToken);
  22. 		}
  23. 		
  24. 		//        //添加cookie
  25. 		//        String cookie = baseApplication.getCookie();
  26. 		//        if (cookie != null && !"".equals(cookie)) {
  27. 		//            builder.addHeader("cookie", cookie);
  28. 		//            LogManager.i(TAG, "cookie*****" + cookie);
  29. 		//        }
  30. 		
  31. 		//        //添加用户代理
  32. 		//        builder.removeHeader("User-Agent")
  33. 		//                .addHeader("User-Agent",
  34. 		//                SystemManager.getUserAgent(baseApplication.getApplicationContext())).build();
  35. 		
  36. 		//		builder.removeHeader("User-Agent")//移除旧的
  37. 		//			.addHeader("User-Agent", WebSettings.getDefaultUserAgent(baseApplication));//添加真正的头部
  38. 		return chain.proceed(builder.build());
  39. 	}
  40. }
  1. public class ReceivedTokenInterceptor implements Interceptor {
  2. 	
  3. 	private static final String          TAG = "ReceivedCookiesInterceptor";
  4. 	private              BaseApplication baseApplication;
  5. 	
  6. 	public ReceivedTokenInterceptor(Context context) {
  7. 		super();
  8. 		baseApplication = (BaseApplication) context.getApplicationContext();
  9. 	}
  10. 	
  11. 	@NonNull
  12. 	@Override
  13. 	public Response intercept(@NonNull Chain chain) throws IOException {
  14. 		
  15. 		Response originalResponse = chain.proceed(chain.request());
  16. 		//这里获取请求返回的accessToken
  17. 		String accessToken = originalResponse.header("accessToken");
  18. 		LogManager.i(TAG, "originalResponse appToken*****" + accessToken);
  19. 		if (!TextUtils.isEmpty(accessToken)) {
  20. 			baseApplication.setAccessToken(accessToken);
  21. 			LogManager.i(TAG, "accessToken*****" + accessToken);
  22. 		}
  23. 		
  24. 		//        //这里获取请求返回的cookie
  25. 		//        if (!originalResponse.headers("set-cookie").isEmpty()) {
  26. 		//            String cookie = originalResponse.header("set-cookie").split(";")[0];
  27. 		//            mineApplication.setCookie(cookie);
  28. 		//            LogManager.i(TAG, "cookie*****" + cookie);
  29. 		//        }
  30. 		
  31. 		Response.Builder builder = originalResponse.newBuilder();
  32. 		return builder.build();
  33. 	}
  34. }

（3）Application中的Shared存储（用于存储accessToken）。

  1. //声明 初始化
  2. protected              SharedPreferences        sp;
  3. protected              SharedPreferences.Editor editor;
  4. protected static final int                      MODE = Context.MODE_PRIVATE;

//初始化（在Appcation中的onCreate函数里）

  1. //文件为mySp  存放在/data/data/<packagename>/shared_prefs/目录下的
  2. sp = getSharedPreferences("app", MODE);
  3. editor = sp.edit();
  1. //在Application里添加函数
  2. public void setAccessToken(String accessToken) {
  3. 		LogManager.i(TAG, "setAccessToken***" + accessToken);
  4. 		editor.putString("accessToken", accessToken);
  5. 		editor.commit();
  6. }
  7. 	
  8. public void setLogout() {
  9. 		LogManager.i(TAG, "setLogout***");
  10. 		//        editor.clear();
  11. 		editor.remove("accessToken");
  12. 		editor.remove("isLogin");
  13. 		editor.commit();
  14. }
  15.

（4）添加SSLSocketManager类。（https请求才需要写并配置，http请求不用配置）。

  1. package com.phone.common_library.manager;
  2.  
  3. import java.security.SecureRandom;
  4. import java.security.cert.X509Certificate;
  5.  
  6. import javax.net.ssl.HostnameVerifier;
  7. import javax.net.ssl.SSLContext;
  8. import javax.net.ssl.SSLSession;
  9. import javax.net.ssl.SSLSocketFactory;
  10. import javax.net.ssl.TrustManager;
  11. import javax.net.ssl.X509TrustManager;
  12.  
  13. /**
  14.  * okhttp3忽略https证书
  15.  */
  16. public class SSLSocketManager {
  17.  
  18.     /**
  19.      * 获取这个SSLSocketFactory
  20.      *
  21.      * @return
  22.      */
  23.     public static SSLSocketFactory getSSLSocketFactory() {
  24.         try {
  25.             SSLContext sslContext = SSLContext.getInstance("SSL");
  26.             sslContext.init(null, getTrustManager(), new SecureRandom());
  27.             return sslContext.getSocketFactory();
  28.         } catch (Exception e) {
  29.             throw new RuntimeException(e);
  30.         }
  31.     }
  32.  
  33.     /**
  34.      * 获取trustManager
  35.      *
  36.      * @return
  37.      */
  38.     public static TrustManager[] getTrustManager() {
  39.         TrustManager[] trustManager = new TrustManager[]{
  40.                 new X509TrustManager() {
  41.                     @Override
  42.                     public void checkClientTrusted(X509Certificate[] chain, String authType) {
  43.                     }
  44.  
  45.                     @Override
  46.                     public void checkServerTrusted(X509Certificate[] chain, String authType) {
  47.                     }
  48.  
  49.                     @Override
  50.                     public X509Certificate[] getAcceptedIssuers() {
  51.                         return new X509Certificate[]{};
  52.                     }
  53.                 }
  54.         };
  55.         return trustManager;
  56.     }
  57.  
  58.     /**
  59.      * 获取hostnameVerifier
  60.      *
  61.      * @return
  62.      */
  63.     public static HostnameVerifier getHostnameVerifier() {
  64.         HostnameVerifier hostnameVerifier = new HostnameVerifier() {
  65.             @Override
  66.             public boolean verify(String s, SSLSession sslSession) {
  67.                 return true;
  68.             }
  69.         };
  70.         return hostnameVerifier;
  71.     }
  72.  
  73. }

4.自定义接口。

  1. public interface OnCommonSingleParamCallback<T> {
  2.  
  3.     void onSuccess(T success);
  4.  
  5.     void onError(String error);
  6. }

5.自定义子线程切换主线程管理类MainThreadManager。

  1. public class MainThreadManager {
  2.  
  3.     private Handler mainThreadHandler;
  4.     private OnSubThreadToMainThreadCallback onSubThreadToMainThreadCallback;
  5.  
  6.     public MainThreadManager() {
  7.     }
  8.  
  9.     public MainThreadManager(OnSubThreadToMainThreadCallback onSubThreadToMainThreadCallback) {
  10.         this.onSubThreadToMainThreadCallback = onSubThreadToMainThreadCallback;
  11.         if (Looper.myLooper() != Looper.getMainLooper()) {
  12.  
  13.             // If we finish marking off of the main thread, we need to
  14.             // actually do it on the main thread to ensure correct ordering.
  15.             mainThreadHandler = new Handler(Looper.getMainLooper());
  16.             mainThreadHandler.post(new Runnable() {
  17.                 @Override
  18.                 public void run() {
  19.                     onSubThreadToMainThreadCallback.onSuccess();
  20.                     mainThreadHandler.removeCallbacksAndMessages(null);
  21.                     mainThreadHandler = null;
  22.                 }
  23.             });
  24.         } else {
  25.             onSubThreadToMainThreadCallback.onSuccess();
  26.         }
  27.     }
  28.  
  29.     public void setOnSubThreadToMainThreadCallback(OnSubThreadToMainThreadCallback onSubThreadToMainThreadCallback) {
  30.         this.onSubThreadToMainThreadCallback = onSubThreadToMainThreadCallback;
  31.     }
  32.  
  33.     /**
  34.      * 子线程到主线程
  35.      */
  36.     public void subThreadToUIThread() {
  37.         if (Looper.myLooper() != Looper.getMainLooper()) {
  38.  
  39.             // If we finish marking off of the main thread, we need to
  40.             // actually do it on the main thread to ensure correct ordering.
  41.             mainThreadHandler = new Handler(Looper.getMainLooper());
  42.             mainThreadHandler.post(new Runnable() {
  43.                 @Override
  44.                 public void run() {
  45.                     onSubThreadToMainThreadCallback.onSuccess();
  46.                     mainThreadHandler.removeCallbacksAndMessages(null);
  47.                     mainThreadHandler = null;
  48.                 }
  49.             });
  50.         } else {
  51.             onSubThreadToMainThreadCallback.onSuccess();
  52.         }
  53.     }
  54. }

6.get请求，异步方式。

  1.  
  2.     /**
  3.      * get请求，异步方式，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      *
  5.      * @param url
  6.      * @param onCommonSingleParamCallback
  7.      */
  8.     public void getAsync(String url,
  9.                                 OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  10.         //2.创建Request对象，设置一个url地址（百度地址）,设置请求方式。
  11.         Request request = new Request.Builder().url(url).method("GET", null).build();
  12. //        Request request = new Request.Builder()
  13. //                .url(url)
  14. //                .get()//默认就是GET请求，可以不写（最好写上，要清晰表达出来）
  15. //                .build();
  16.         //3.创建一个call对象,参数就是Request请求对象
  17.         Call call = client.newCall(request);
  18.         //4 执行Call
  19.         call.enqueue(new Callback() {
  20.             @Override
  21.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  22.                 LogManager.i(TAG, "getAsync onFailure e*******" + e.toString());
  23.                 LogManager.i(TAG, "getAsync onFailure e detailMessage*******" + e.getMessage());
  24.                 MainThreadManager mainThreadManager = new MainThreadManager();
  25.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  26.                     @Override
  27.                     public void onSuccess() {
  28.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  29.                     }
  30.                 });
  31.                 mainThreadManager.subThreadToUIThread();
  32.             }
  33.  
  34.             @Override
  35.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  36.                 String responseString = response.body().string();
  37.                 LogManager.i(TAG, "getAsync onResponse responseString*****" + responseString);
  38.                 MainThreadManager mainThreadManager = new MainThreadManager();
  39.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  40.                     @Override
  41.                     public void onSuccess() {
  42.                         if (!TextUtils.isEmpty(responseString)) {
  43.                             BaseResponse baseResponse;
  44.                             try {
  45.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  46.                             } catch (Exception e) {
  47.                                 //如果不是标准json字符串，就返回错误提示
  48.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  49.                                 return;
  50.                             }
  51.                             onCommonSingleParamCallback.onSuccess(responseString);
  52.                         } else {
  53.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  54.                         }
  55.                     }
  56.                 });
  57.                 mainThreadManager.subThreadToUIThread();
  58.             }
  59.         });
  60.     }

7.get请求，携带请求参数​​​​​​​，异步方式。

  1.  
  2.     /**
  3.      * get请求，添加请求参数，异步方式，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      *
  5.      * @param url
  6.      * @param bodyParams
  7.      * @param onCommonSingleParamCallback
  8.      */
  9.     public void getAsync(String url,
  10.                                 Map<String, String> bodyParams,
  11.                                 OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  12.         String urlNew = url;
  13.         // 设置HTTP请求参数
  14.         urlNew += getBodyParams(bodyParams);
  15.         //2.创建Request对象，设置一个url地址,设置请求方式。
  16.         Request request = new Request.Builder().url(urlNew).get().build();
  17. //        Request request = new Request.Builder()
  18. //                .url(url)
  19. //                .get()//默认就是GET请求，可以不写（最好写上，要清晰表达出来）
  20. //                .build();
  21.         //3.创建一个call对象,参数就是Request请求对象
  22.         Call call = client.newCall(request);
  23.         //4 执行Call
  24.         call.enqueue(new Callback() {
  25.             @Override
  26.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  27.                 LogManager.i(TAG, "getAsync onFailure e*******" + e.toString());
  28.                 LogManager.i(TAG, "getAsync onFailure e detailMessage*******" + e.getMessage());
  29.                 MainThreadManager mainThreadManager = new MainThreadManager();
  30.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  31.                     @Override
  32.                     public void onSuccess() {
  33.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  34.                     }
  35.                 });
  36.                 mainThreadManager.subThreadToUIThread();
  37.             }
  38.  
  39.             @Override
  40.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  41.                 String responseString = response.body().string();
  42.                 LogManager.i(TAG, "getAsync onResponse responseString*****" + responseString);
  43.                 MainThreadManager mainThreadManager = new MainThreadManager();
  44.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  45.                     @Override
  46.                     public void onSuccess() {
  47.                         if (!TextUtils.isEmpty(responseString)) {
  48.                             BaseResponse baseResponse;
  49.                             try {
  50.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  51.                             } catch (Exception e) {
  52.                                 //如果不是标准json字符串，就返回错误提示
  53.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  54.                                 return;
  55.                             }
  56.                             onCommonSingleParamCallback.onSuccess(responseString);
  57.                         } else {
  58.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  59.                         }
  60.                     }
  61.                 });
  62.                 mainThreadManager.subThreadToUIThread();
  63.             }
  64.         });
  65.     }
  1.  
  2.     /**
  3.      * 添加参数
  4.      *
  5.      * @param bodyParams
  6.      * @return
  7.      */
  8.     private String getBodyParams(Map<String, String> bodyParams) {
  9.         //1.添加请求参数
  10.         //遍历map中所有参数到builder
  11.         if (bodyParams != null && bodyParams.size() > 0) {
  12.             StringBuffer stringBuffer = new StringBuffer("?");
  13.             for (String key : bodyParams.keySet()) {
  14.                 if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(bodyParams.get(key))) {
  15.                     //如果参数不是null并且不是""，就拼接起来
  16.                     stringBuffer.append("&");
  17.                     stringBuffer.append(key);
  18.                     stringBuffer.append("=");
  19.                     stringBuffer.append(bodyParams.get(key));
  20.                 }
  21.             }
  22.  
  23.             return stringBuffer.toString();
  24.         } else {
  25.             return "";
  26.         }
  27.     }
  28.  
  29.     /**
  30.      * 添加headers
  31.      *
  32.      * @param headerParams
  33.      * @return
  34.      */
  35.     private Headers setHeaderParams(Map<String, String> headerParams) {
  36.         Headers headers = null;
  37.         Headers.Builder headersbuilder = new Headers.Builder();
  38.         if (headerParams != null && headerParams.size() > 0) {
  39.             for (String key : headerParams.keySet()) {
  40.                 if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(bodyParams.get(key))) {
  41.                     //如果参数不是null并且不是""，就拼接起来
  42.                     headersbuilder.add(key, headerParams.get(key));
  43.                 }
  44.             }
  45.         }
  46.  
  47.         headers = headersbuilder.build();
  48.         return headers;
  49.     }

​​​​​​​8.get请求，添加请求参数和header参数，异步方式。

  1.  
  2.     /**
  3.      * get请求，添加请求参数和header参数，异步方式，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      *
  5.      * @param url
  6.      * @param headerParams
  7.      * @param bodyParams
  8.      * @param onCommonSingleParamCallback
  9.      */
  10.     public void getAsync(String url,
  11.                                 Map<String, String> headerParams,
  12.                                 Map<String, String> bodyParams,
  13.                                 OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  14.         String urlNew = url;
  15.         // 设置HTTP请求参数
  16.         urlNew += getBodyParams(bodyParams);
  17.         Headers headers = setHeaderParams(headerParams);
  18.         //2.创建Request对象，设置一个url地址,设置请求方式。
  19.         Request request = new Request.Builder().url(urlNew).get().headers(headers).build();
  20. //        Request request = new Request.Builder()
  21. //                .url(url)
  22. //                .get()//默认就是GET请求，可以不写（最好写上，要清晰表达出来）
  23. //                .build();
  24.         //3.创建一个call对象,参数就是Request请求对象
  25.         Call call = client.newCall(request);
  26.         //4 执行Call
  27.         call.enqueue(new Callback() {
  28.             @Override
  29.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  30.                 LogManager.i(TAG, "getAsync onFailure e*******" + e.toString());
  31.                 LogManager.i(TAG, "getAsync onFailure e detailMessage*******" + e.getMessage());
  32.                 MainThreadManager mainThreadManager = new MainThreadManager();
  33.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  34.                     @Override
  35.                     public void onSuccess() {
  36.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  37.                     }
  38.                 });
  39.                 mainThreadManager.subThreadToUIThread();
  40.             }
  41.  
  42.             @Override
  43.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  44.                 String responseString = response.body().string();
  45.                 LogManager.i(TAG, "getAsync onResponse responseString*****" + responseString);
  46.                 MainThreadManager mainThreadManager = new MainThreadManager();
  47.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  48.                     @Override
  49.                     public void onSuccess() {
  50.                         if (!TextUtils.isEmpty(responseString)) {
  51.                             BaseResponse baseResponse;
  52.                             try {
  53.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  54.                             } catch (Exception e) {
  55.                                 //如果不是标准json字符串，就返回错误提示
  56.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  57.                                 return;
  58.                             }
  59.                             onCommonSingleParamCallback.onSuccess(responseString);
  60.                         } else {
  61.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  62.                         }
  63.                     }
  64.                 });
  65.                 mainThreadManager.subThreadToUIThread();
  66.             }
  67.         });
  68.     }

9.post请求提交字符串，异步方式。

  1.  
  2.     /**
  3.      * post请求提交字符串，异步方式，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      *
  5.      * @param url
  6.      * @param bodyParams
  7.      * @param onCommonSingleParamCallback
  8.      */
  9.     public void postAsyncString(String url,
  10.                                        Map<String, String> bodyParams,
  11.                                        OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  12.         JSONObject jsonObject = new JSONObject(bodyParams);
  13.         String requestData = jsonObject.toString();
  14.         LogManager.i(TAG, "postAsyncString requestData*****" + requestData);
  15.         MediaType mediaType = MediaType.parse("application/json; charset=utf-8");//"类型,字节码"
  16.         //2.通过RequestBody.create 创建requestBody对象
  17.         RequestBody requestBody = RequestBody.create(mediaType, requestData);
  18.         //3.创建Request对象，设置URL地址，将RequestBody作为post方法的参数传入
  19.         Request request = new Request.Builder().url(url).post(requestBody).build();
  20.         //4.创建一个call对象,参数就是Request请求对象
  21.         Call call = client.newCall(request);
  22.         //4 执行Call
  23.         call.enqueue(new Callback() {
  24.             @Override
  25.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  26.                 LogManager.i(TAG, "postAsyncString onFailure e*******" + e.toString());
  27.                 LogManager.i(TAG, "postAsyncString onFailure e detailMessage*******" + e.getMessage());
  28.                 MainThreadManager mainThreadManager = new MainThreadManager();
  29.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  30.                     @Override
  31.                     public void onSuccess() {
  32.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  33.                     }
  34.                 });
  35.                 mainThreadManager.subThreadToUIThread();
  36.             }
  37.  
  38.             @Override
  39.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  40.                 String responseString = response.body().string();
  41.                 LogManager.i(TAG, "postAsyncString onResponse responseString*****" + responseString);
  42.                 MainThreadManager mainThreadManager = new MainThreadManager();
  43.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  44.                     @Override
  45.                     public void onSuccess() {
  46.                         if (!TextUtils.isEmpty(responseString)) {
  47.                             BaseResponse baseResponse;
  48.                             try {
  49.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  50.                             } catch (Exception e) {
  51.                                 //如果不是标准json字符串，就返回错误提示
  52.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  53.                                 return;
  54.                             }
  55.                             onCommonSingleParamCallback.onSuccess(responseString);
  56.                         } else {
  57.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  58.                         }
  59.                     }
  60.                 });
  61.                 mainThreadManager.subThreadToUIThread();
  62.             }
  63.         });
  64.     }

10.post请求不传递参数，异步方式。

  1.  
  2.     /**
  3.      * post请求不携带参数，异步方式，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      *
  5.      * @param url
  6.      * @param onCommonSingleParamCallback
  7.      */
  8.     public void postAsync(String url,
  9.                                  OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  10.         //这句话是重点Request
  11.         //3.创建Request对象，设置URL地址，将RequestBody作为post方法的参数传入
  12.         Request request = new Request.Builder().post(RequestBody.create(null, "")).url(url).build();
  13.         //4.创建一个call对象,参数就是Request请求对象
  14.         Call call = client.newCall(request);
  15.         //4 执行Call
  16.         call.enqueue(new Callback() {
  17.             @Override
  18.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  19.                 LogManager.i(TAG, "postAsync onFailure e*******" + e.toString());
  20.                 LogManager.i(TAG, "postAsync onFailure e detailMessage*******" + e.getMessage());
  21.                 MainThreadManager mainThreadManager = new MainThreadManager();
  22.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  23.                     @Override
  24.                     public void onSuccess() {
  25.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  26.                     }
  27.                 });
  28.                 mainThreadManager.subThreadToUIThread();
  29.  
  30. //                MainThreadManager mainThreadManager2 =
  31. //                        new MainThreadManager(new OnSubThreadToMainThreadCallback() {
  32. //                            @Override
  33. //                            public void onSuccess() {
  34. //                                onCommonSingleParamCallback.onError(context.getResources().getString(R.string.network_sneak_off));
  35. //                            }
  36. //                        });
  37.             }
  38.  
  39.             @Override
  40.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  41.                 String responseString = response.body().string();
  42.                 LogManager.i(TAG, "postAsync onResponse responseString*****" + responseString);
  43.                 MainThreadManager mainThreadManager = new MainThreadManager();
  44.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  45.                     @Override
  46.                     public void onSuccess() {
  47.                         if (!TextUtils.isEmpty(responseString)) {
  48.                             BaseResponse baseResponse;
  49.                             try {
  50.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  51.                             } catch (Exception e) {
  52.                                 //如果不是标准json字符串，就返回错误提示
  53.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  54.                                 return;
  55.                             }
  56.                             onCommonSingleParamCallback.onSuccess(responseString);
  57.                         } else {
  58.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  59.                         }
  60.                     }
  61.                 });
  62.                 mainThreadManager.subThreadToUIThread();
  63.             }
  64.         });
  65.     }

11.post请求提交流，异步方式。

  1.  
  2.     /**
  3.      * post请求提交流，异步方式，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      *
  5.      * @param url
  6.      * @param requestData
  7.      * @param onCommonSingleParamCallback
  8.      */
  9.     public void postAsyncStream(String url,
  10.                                        String requestData,
  11.                                        OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  12.         LogManager.i(TAG, "requestData*****" + requestData);
  13.  
  14.         //2.通过new RequestBody 创建requestBody对象
  15.         RequestBody requestBody = new RequestBody() {
  16.             @Nullable
  17.             @Override
  18.             public MediaType contentType() {
  19.                 return MediaType.parse("text/x-markdown; charset=utf-8");
  20.             }
  21.  
  22.             @Override
  23.             public void writeTo(@NonNull BufferedSink sink) throws IOException {
  24.                 sink.writeUtf8(requestData);
  25.             }
  26.         };
  27.         //3.创建Request对象，设置URL地址，将RequestBody作为post方法的参数传入
  28.         Request request = new Request.Builder().url(url).post(requestBody).build();
  29.         //4.创建一个call对象,参数就是Request请求对象
  30.         Call call = client.newCall(request);
  31.         //4 执行Call
  32.         call.enqueue(new Callback() {
  33.             @Override
  34.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  35.                 LogManager.i(TAG, "postAsyncStream onFailure e*******" + e.toString());
  36.                 LogManager.i(TAG, "postAsyncStream onFailure e detailMessage*******" + e.getMessage());
  37.                 MainThreadManager mainThreadManager = new MainThreadManager();
  38.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  39.                     @Override
  40.                     public void onSuccess() {
  41.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  42.                     }
  43.                 });
  44.                 mainThreadManager.subThreadToUIThread();
  45.             }
  46.  
  47.             @Override
  48.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  49.                 String responseString = response.body().string();
  50.                 LogManager.i(TAG, "postAsyncStream onResponse responseString*****" + responseString);
  51.                 MainThreadManager mainThreadManager = new MainThreadManager();
  52.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  53.                     @Override
  54.                     public void onSuccess() {
  55.                         if (!TextUtils.isEmpty(responseString)) {
  56.                             BaseResponse baseResponse;
  57.                             try {
  58.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  59.                             } catch (Exception e) {
  60.                                 //如果不是标准json字符串，就返回错误提示
  61.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  62.                                 return;
  63.                             }
  64.                             onCommonSingleParamCallback.onSuccess(responseString);
  65.                         } else {
  66.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  67.                         }
  68.                     }
  69.                 });
  70.                 mainThreadManager.subThreadToUIThread();
  71.             }
  72.         });
  73.     }

12.post请求提交键值对，异步方式。

  1.  
  2.     /**
  3.      * post请求提交键值对，异步方式，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      *
  5.      * @param url
  6.      * @param bodyParams
  7.      * @param onCommonSingleParamCallback
  8.      */
  9.     public void postAsyncKeyValuePairs(String url,
  10.                                               Map<String, String> bodyParams,
  11.                                               OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  12.         if (bodyParams != null && bodyParams.size() > 0) {
  13.             LogManager.i(TAG, "postAsyncKeyValuePairs bodyParams*****" + bodyParams.toString());
  14.             LogManager.i(TAG, "postAsyncKeyValuePairs bodyParams json*****" + MapManager.mapToJsonStr(bodyParams));
  15.         }
  16.  
  17.         //2.通过new FormBody()调用build方法,创建一个RequestBody,可以用add添加键值对
  18.         FormBody.Builder formEncodingBuilder = new FormBody.Builder();
  19.         //1.添加请求参数
  20.         //遍历map中所有参数到builder
  21.         if (bodyParams != null && bodyParams.size() > 0) {
  22.             for (String key : bodyParams.keySet()) {
  23.                 if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(bodyParams.get(key))) {
  24.                     formEncodingBuilder.add(key, bodyParams.get(key));
  25.                 }
  26.             }
  27.         }
  28.  
  29.         //构建请求体
  30.         RequestBody requestBody = formEncodingBuilder.build();
  31.         //3.创建Request对象，设置URL地址，将RequestBody作为post方法的参数传入
  32.         Request request = new Request.Builder().url(url).post(requestBody).build();
  33.         //4.创建一个call对象,参数就是Request请求对象
  34.         Call call = client.newCall(request);
  35.         //4 执行Call
  36.         call.enqueue(new Callback() {
  37.             @Override
  38.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  39.                 LogManager.i(TAG, "postAsyncKeyValuePairs onFailure e*******" + e.toString());
  40.                 LogManager.i(TAG, "postAsyncKeyValuePairs onFailure e detailMessage*******" + e.getMessage());
  41.                 MainThreadManager mainThreadManager = new MainThreadManager();
  42.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  43.                     @Override
  44.                     public void onSuccess() {
  45.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  46.                     }
  47.                 });
  48.                 mainThreadManager.subThreadToUIThread();
  49.  
  50. //                MainThreadManager mainThreadManager2 =
  51. //                        new MainThreadManager(new OnSubThreadToMainThreadCallback() {
  52. //                            @Override
  53. //                            public void onSuccess() {
  54. //                                onCommonSingleParamCallback.onError(context.getResources().getString(R.string.network_sneak_off));
  55. //                            }
  56. //                        });
  57.             }
  58.  
  59.             @Override
  60.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  61.                 String responseString = response.body().string();
  62.                 LogManager.i(TAG, "postAsyncKeyValuePairs onResponse responseString*****" + responseString);
  63.                 MainThreadManager mainThreadManager = new MainThreadManager();
  64.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  65.                     @Override
  66.                     public void onSuccess() {
  67.                         if (!TextUtils.isEmpty(responseString)) {
  68.                             BaseResponse baseResponse;
  69.                             try {
  70.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  71.                             } catch (Exception e) {
  72.                                 //如果不是标准json字符串，就返回错误提示
  73.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  74.                                 return;
  75.                             }
  76.                             onCommonSingleParamCallback.onSuccess(responseString);
  77.                         } else {
  78.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  79.                         }
  80.                     }
  81.                 });
  82.                 mainThreadManager.subThreadToUIThread();
  83.             }
  84.         });
  85.     }

13.post请求上传Form表单，异步方式。

  1.  
  2.     /**
  3.      * post请求上传Form表单，异步方式，提交表单，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      * 这个函数可以把服务器返回的数据统一处理
  5.      *
  6.      * @param url
  7.      * @param bodyParams
  8.      * @param onCommonSingleParamCallback
  9.      */
  10.     public void postAsyncForm(String url,
  11.                                      Map<String, String> bodyParams,
  12.                                      OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  13.         if (bodyParams != null && bodyParams.size() > 0) {
  14.             LogManager.i(TAG, "postAsyncForm bodyParams String*******" + bodyParams.toString());
  15.             LogManager.i(TAG, "postAsyncForm bodyParams json*****" + MapManager.mapToJsonStr(bodyParams));
  16.         }
  17.  
  18.         // form 表单形式上传
  19.         MultipartBody.Builder multipartBodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
  20.         //1.添加请求参数
  21.         //遍历map中所有参数到builder
  22.         if (bodyParams != null && bodyParams.size() > 0) {
  23.             for (String key : bodyParams.keySet()) {
  24.                 if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(bodyParams.get(key))) {
  25.                     multipartBodyBuilder.addFormDataPart(key, bodyParams.get(key));
  26.                 }
  27.             }
  28.         }
  29.  
  30.         //构建请求体
  31.         RequestBody requestBody = multipartBodyBuilder.build();
  32.         Request request = new Request.Builder().post(requestBody).url(url).build();
  33.         //3 将Request封装为Call
  34.         Call call = client.newCall(request);
  35.         //4 执行Call
  36.         call.enqueue(new Callback() {
  37.             @Override
  38.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  39.                 LogManager.i(TAG, "postAsyncForm onFailure e*******" + e.toString());
  40.                 LogManager.i(TAG, "postAsyncForm onFailure e detailMessage*******" + e.getMessage());
  41.                 MainThreadManager mainThreadManager = new MainThreadManager();
  42.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  43.                     @Override
  44.                     public void onSuccess() {
  45.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  46.                     }
  47.                 });
  48.                 mainThreadManager.subThreadToUIThread();
  49.             }
  50.  
  51.             @Override
  52.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  53. //                //服务器返回的是加密字符串，要解密
  54. //                String dataEncrypt = response.body().string();
  55. //                LogManager.i(TAG, "login onResponse dataEncrypt*****" + dataEncrypt);
  56.                 String responseString = response.body().string();
  57. //                try {
  58. //                    responseString = AESManager.aesDecrypt(dataEncrypt);
  59.                 LogManager.i(TAG, "postAsyncForm onResponse responseString*****" + responseString);
  60.                 MainThreadManager mainThreadManager = new MainThreadManager();
  61.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  62.                     @Override
  63.                     public void onSuccess() {
  64.                         if (!TextUtils.isEmpty(responseString)) {
  65.                             BaseResponse baseResponse;
  66.                             try {
  67.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  68.                             } catch (Exception e) {
  69.                                 //如果不是标准json字符串，就返回错误提示
  70.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  71.                                 return;
  72.                             }
  73.                             onCommonSingleParamCallback.onSuccess(responseString);
  74.                         } else {
  75.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  76.                         }
  77.                     }
  78.                 });
  79.                 mainThreadManager.subThreadToUIThread();
  80. //                } catch (Exception e) {
  81. //                    e.printStackTrace();
  82. //                }
  83.             }
  84.         });
  85.     }

14.post请求上传Form表单和图片文件（上传java服务器），异步方式。

  1.  
  2.     /**
  3.      * post请求上传Form表单和图片文件（上传java服务器），异步方式，提交表单，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      * 这个函数可以把服务器返回的数据统一处理
  5.      *
  6.      * @param url
  7.      * @param bodyParams
  8.      * @param fileList
  9.      * @param onCommonSingleParamCallback
  10.      */
  11.     public void postAsyncFormAndFiles(String url,
  12.                                              Map<String, String> bodyParams,
  13.                                              List<File> fileList,
  14.                                              OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  15.         if (bodyParams != null && bodyParams.size() > 0) {
  16.             LogManager.i(TAG, "postAsyncFormAndFiles bodyParams String*******" + bodyParams.toString());
  17.             LogManager.i(TAG, "postAsyncFormAndFiles bodyParams json*****" + MapManager.mapToJsonStr(bodyParams));
  18.         }
  19.         //        MediaType MEDIA_TYPE = MediaType.parse("image/png");
  20.         MediaType MEDIA_TYPE = MediaType.parse("image/*");
  21.         // form 表单形式上传
  22.         MultipartBody.Builder multipartBodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
  23.         //1.添加请求参数
  24.         //遍历map中所有参数到builder
  25.         if (bodyParams != null && bodyParams.size() > 0) {
  26.             for (String key : bodyParams.keySet()) {
  27.                 if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(bodyParams.get(key))) {
  28.                     multipartBodyBuilder.addFormDataPart(key, bodyParams.get(key));
  29.                 }
  30.             }
  31.         }
  32.  
  33.         //遍历fileList中所有图片绝对路径到builder，并约定key如"upload"作为上传php服务器接受多张图片的key
  34.         if (fileList != null && fileList.size() > 0) {
  35.             for (int i = 0; i < fileList.size(); i++) {
  36.                 if (fileList.get(i).exists()) {
  37.                     multipartBodyBuilder.addFormDataPart("upload", fileList.get(i).getName(), RequestBody.create(MEDIA_TYPE, fileList.get(i)));
  38.                 }
  39.             }
  40.         } else {
  41.             LogManager.i(TAG, "postAsyncFormAndFiles fileList.size() = 0");
  42.         }
  43.  
  44.         //构建请求体
  45.         RequestBody requestBody = multipartBodyBuilder.build();
  46.         Request request = new Request.Builder().post(requestBody).url(url).build();
  47.         //3 将Request封装为Call
  48.         Call call = client.newCall(request);
  49.         //4 执行Call
  50.         call.enqueue(new Callback() {
  51.             @Override
  52.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  53.                 LogManager.i(TAG, "postAsyncFormAndFiles onFailure e*******" + e.toString());
  54.                 LogManager.i(TAG, "postAsyncFormAndFiles onFailure e detailMessage*******" + e.getMessage());
  55.                 MainThreadManager mainThreadManager = new MainThreadManager();
  56.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  57.                     @Override
  58.                     public void onSuccess() {
  59.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  60.                     }
  61.                 });
  62.                 mainThreadManager.subThreadToUIThread();
  63.             }
  64.  
  65.             @Override
  66.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  67.                 String responseString = response.body().string();
  68.                 LogManager.i(TAG, "postAsyncFormAndFiles onResponse responseString*****" + responseString);
  69.                 MainThreadManager mainThreadManager = new MainThreadManager();
  70.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  71.                     @Override
  72.                     public void onSuccess() {
  73.                         if (!TextUtils.isEmpty(responseString)) {
  74.                             BaseResponse baseResponse;
  75.                             try {
  76.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  77.                             } catch (Exception e) {
  78.                                 //如果不是标准json字符串，就返回错误提示
  79.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  80.                                 return;
  81.                             }
  82.                             onCommonSingleParamCallback.onSuccess(responseString);
  83.                         } else {
  84.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  85.                         }
  86.                     }
  87.                 });
  88.                 mainThreadManager.subThreadToUIThread();
  89.             }
  90.         });
  91.     }

15.post请求上传Form表单和文件（上传php服务器），异步方式。

  1.  
  2.     /**
  3.      * post请求上传Form表单和文件（上传php服务器），异步方式，提交表单，是在子线程中执行的，需要切换到主线程才能更新UI
  4.      *
  5.      * @param url
  6.      * @param bodyParams
  7.      * @param fileList
  8.      * @param onCommonSingleParamCallback
  9.      */
  10.     public void postAsyncPhpFormAndFiles(String url,
  11.                                                 Map<String, String> bodyParams,
  12.                                                 List<File> fileList,
  13.                                                 OnCommonSingleParamCallback<String> onCommonSingleParamCallback) {
  14.         if (bodyParams != null && bodyParams.size() > 0) {
  15.             LogManager.i(TAG, "postAsyncPhpFormAndFiles bodyParams String*******" + bodyParams.toString());
  16.             LogManager.i(TAG, "postAsyncPhpFormAndFiles bodyParams json*****" + MapManager.mapToJsonStr(bodyParams));
  17.         }
  18.         MediaType MEDIA_TYPE = MediaType.parse("image/png");
  19.         // form 表单形式上传
  20.         MultipartBody.Builder multipartBodyBuilder = new MultipartBody.Builder().setType(MultipartBody.FORM);
  21.         //1.添加请求参数
  22.         //遍历map中所有参数到builder
  23.         if (bodyParams != null && bodyParams.size() > 0) {
  24.             for (String key : bodyParams.keySet()) {
  25.                 if (!TextUtils.isEmpty(key) && !TextUtils.isEmpty(bodyParams.get(key))) {
  26.                     multipartBodyBuilder.addFormDataPart(key, bodyParams.get(key));
  27.                 }
  28.             }
  29.         }
  30.  
  31.         //遍历fileList中所有图片绝对路径到builder，并约定key如"upload[]"作为php服务器接受多张图片的key
  32.         if (fileList != null && fileList.size() > 0) {
  33.             for (int i = 0; i < fileList.size(); i++) {
  34.                 if (fileList.get(i).exists()) {
  35.                     multipartBodyBuilder.addFormDataPart("upload[]", fileList.get(i).getName(), RequestBody.create(MEDIA_TYPE, fileList.get(i)));
  36.                 }
  37.             }
  38.         }
  39.  
  40.  
  41.         //构建请求体
  42.         RequestBody requestBody = multipartBodyBuilder.build();
  43.         Request request = new Request.Builder().post(requestBody).url(url).build();
  44.         //3 将Request封装为Call
  45.         Call call = client.newCall(request);
  46.         //4 执行Call
  47.         call.enqueue(new Callback() {
  48.             @Override
  49.             public void onFailure(@NonNull Call call, @NonNull IOException e) {
  50.                 LogManager.i(TAG, "postAsyncPhpFormAndFiles onFailure e*******" + e.toString());
  51.                 LogManager.i(TAG, "postAsyncPhpFormAndFiles onFailure e detailMessage*******" + e.getMessage());
  52.                 MainThreadManager mainThreadManager = new MainThreadManager();
  53.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  54.                     @Override
  55.                     public void onSuccess() {
  56.                         onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.network_sneak_off));
  57.                     }
  58.                 });
  59.                 mainThreadManager.subThreadToUIThread();
  60.             }
  61.  
  62.             @Override
  63.             public void onResponse(@NonNull Call call, @NonNull Response response) throws IOException {
  64.                 String responseString = response.body().string();
  65.                 LogManager.i(TAG, "postAsyncPhpFormAndFiles onResponse responseString*****" + responseString);
  66.                 MainThreadManager mainThreadManager = new MainThreadManager();
  67.                 mainThreadManager.setOnSubThreadToMainThreadCallback(new OnSubThreadToMainThreadCallback() {
  68.                     @Override
  69.                     public void onSuccess() {
  70.                         if (!TextUtils.isEmpty(responseString)) {
  71.                             BaseResponse baseResponse;
  72.                             try {
  73.                                 baseResponse = JSON.parseObject(responseString, BaseResponse.class);
  74.                             } catch (Exception e) {
  75.                                 //如果不是标准json字符串，就返回错误提示
  76.                                 onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  77.                                 return;
  78.                             }
  79.                             onCommonSingleParamCallback.onSuccess(responseString);
  80.                         } else {
  81.                             onCommonSingleParamCallback.onError(BaseApplication.getInstance().getResources().getString(R.string.server_sneak_off));
  82.                         }
  83.                     }
  84.                 });
  85.                 mainThreadManager.subThreadToUIThread();
  86.             }
  87.         });
  88.     }

16.判断网络是否可用。

  1.  
  2.     /**
  3.      * 判断网络是否可用
  4.      *
  5.      * @param context
  6.      * @return
  7.      */
  8.     public static boolean isNetworkAvailable(Context context) {
  9.         ConnectivityManager connectivityManager = (ConnectivityManager) context.getApplicationContext()
  10.                 .getSystemService(Context.CONNECTIVITY_SERVICE);
  11.         if (connectivityManager != null) {
  12.             //如果仅仅是用来判断网络连接
  13.             //connectivityManager.getActiveNetworkInfo().isAvailable();
  14.             NetworkInfo[] info = connectivityManager.getAllNetworkInfo();
  15. //            LogManager.i(TAG, "isNetworkAvailable*****" + info.toString());
  16.             if (info != null) {
  17.                 for (int i = 0; i < info.length; i++) {
  18.                     if (info[i].getState() == NetworkInfo.State.CONNECTED) {
  19.                         return true;
  20.                     }
  21.                 }
  22.             }
  23.         }
  24.         return false;
  25.     }

17.代码中定义的字符串的string值。

  1. <string name="network_sneak_off">網絡開小差了</string>
  2. <string name="server_sneak_off">服務器開小差了</string>

如对此有疑问，请联系qq1164688204。

推荐Android开源项目

项目功能介绍：RxJava2和Retrofit2项目，添加自动管理token功能，添加RxJava2生命周期管理，使用App架构设计是MVP模式和MVVM模式，同时使用组件化，部分代码使用Kotlin，此项目持续维护中。

项目地址：https://gitee.com/urasaki/RxJava2AndRetrofit2

本文内容由网友自发贡献，转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号