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

okhttp3简单封装GET和POST请求工具类（https）_okhttp3 post 封装requestheadler

作者：羊村懒王 | 2024-03-18 01:18:43

赞

踩

okhttp3 post 封装requestheadler

https://blog.csdn.net/fxjzzyo/article/details/78761373

 

简单封装了okhttp3的工具类以便于以后直接拿来使用。

使用的okhttp版本为：

compile 'com.squareup.okhttp3:okhttp:3.8.1'
1
该工具类的功能如下：

Get请求，同步方式获取网络数据
Post请求，同步方式获取数据
Get请求，异步方式获取网络数据
Post请求，异步方式获取数据
支持HTTPS请求，自动跳过证书验证
判断当前网络是否可用
其中Post请求提交的是键值对<String,String>1. 完整代码
 

  1. import android.content.Context;
  2. import android.net.ConnectivityManager;
  3. import android.net.NetworkInfo;
  4. import android.util.Log;
  5.  
  6. import java.io.IOException;
  7. import java.security.SecureRandom;
  8. import java.security.cert.CertificateException;
  9. import java.security.cert.X509Certificate;
  10. import java.util.Iterator;
  11. import java.util.Map;
  12. import java.util.concurrent.TimeUnit;
  13.  
  14. import javax.net.ssl.HostnameVerifier;
  15. import javax.net.ssl.SSLContext;
  16. import javax.net.ssl.SSLSession;
  17. import javax.net.ssl.SSLSocketFactory;
  18. import javax.net.ssl.TrustManager;
  19. import javax.net.ssl.X509TrustManager;
  20.  
  21. import okhttp3.Call;
  22. import okhttp3.Callback;
  23. import okhttp3.OkHttpClient;
  24. import okhttp3.Request;
  25. import okhttp3.RequestBody;
  26. import okhttp3.Response;
  27.  
  28. /**
  29.  * Created by fxjzzyo on 2017/7/12.
  30.  */
  31.  
  32. public class NetUtils {
  33.     private static final byte[] LOCKER = new byte[0];
  34.     private static NetUtils mInstance;
  35.     private OkHttpClient mOkHttpClient;
  36.  
  37.     private NetUtils() {
  38.         okhttp3.OkHttpClient.Builder ClientBuilder=new okhttp3.OkHttpClient.Builder();
  39.         ClientBuilder.readTimeout(20, TimeUnit.SECONDS);//读取超时
  40.         ClientBuilder.connectTimeout(6, TimeUnit.SECONDS);//连接超时
  41.         ClientBuilder.writeTimeout(60, TimeUnit.SECONDS);//写入超时
  42.         //支持HTTPS请求，跳过证书验证
  43.         ClientBuilder.sslSocketFactory(createSSLSocketFactory());
  44.         ClientBuilder.hostnameVerifier(new HostnameVerifier() {
  45.             @Override
  46.             public boolean verify(String hostname, SSLSession session) {
  47.                 return true;
  48.             }
  49.         });
  50.         mOkHttpClient=ClientBuilder.build();
  51.     }
  52.  
  53.     /**
  54.      * 单例模式获取NetUtils
  55.      * @return
  56.      */
  57.     public static NetUtils getInstance() {
  58.         if (mInstance == null) {
  59.             synchronized (LOCKER) {
  60.                 if (mInstance == null) {
  61.                     mInstance = new NetUtils();
  62.                 }
  63.             }
  64.         }
  65.         return mInstance;
  66.     }
  67.  
  68.     /**
  69.      * get请求，同步方式，获取网络数据，是在主线程中执行的，需要新起线程，将其放到子线程中执行
  70.      * @param url
  71.      * @return
  72.      */
  73.     public  Response getDataSynFromNet(String url) {
  74.         //1 构造Request
  75.         Request.Builder builder = new Request.Builder();
  76.         Request request=builder.get().url(url).build();
  77.         //2 将Request封装为Call
  78.         Call call = mOkHttpClient.newCall(request);
  79.         //3 执行Call，得到response
  80.         Response response = null;
  81.         try {
  82.             response = call.execute();
  83.         } catch (IOException e) {
  84.             e.printStackTrace();
  85.         }
  86.         return response;
  87.     }
  88.     /**
  89.      * post请求，同步方式，提交数据，是在主线程中执行的，需要新起线程，将其放到子线程中执行
  90.      * @param url
  91.      * @param bodyParams
  92.      * @return
  93.      */
  94.     public  Response postDataSynToNet(String url,Map<String,String> bodyParams) {
  95.         //1构造RequestBody
  96.         RequestBody body=setRequestBody(bodyParams);
  97.         //2 构造Request
  98.         Request.Builder requestBuilder = new Request.Builder();
  99.         Request request = requestBuilder.post(body).url(url).build();
  100.         //3 将Request封装为Call
  101.         Call call = mOkHttpClient.newCall(request);
  102.         //4 执行Call，得到response
  103.         Response response = null;
  104.         try {
  105.             response = call.execute();
  106.         } catch (IOException e) {
  107.             e.printStackTrace();
  108.         }
  109.         return response;
  110.     }
  111.     /**
  112.      * 自定义网络回调接口
  113.      */
  114.     public interface MyNetCall{
  115.         void success(Call call, Response response) throws IOException;
  116.         void failed(Call call, IOException e);
  117.     }
  118.  
  119.     /**
  120.      * get请求，异步方式，获取网络数据，是在子线程中执行的，需要切换到主线程才能更新UI
  121.      * @param url
  122.      * @param myNetCall
  123.      * @return
  124.      */
  125.     public  void getDataAsynFromNet(String url, final MyNetCall myNetCall) {
  126.         //1 构造Request
  127.         Request.Builder builder = new Request.Builder();
  128.         Request request=builder.get().url(url).build();
  129.         //2 将Request封装为Call
  130.         Call call = mOkHttpClient.newCall(request);
  131.         //3 执行Call
  132.         call.enqueue(new Callback() {
  133.             @Override
  134.             public void onFailure(Call call, IOException e) {
  135.                 myNetCall.failed(call,e);
  136.             }
  137.  
  138.             @Override
  139.             public void onResponse(Call call, Response response) throws IOException {
  140.                 myNetCall.success(call,response);
  141.  
  142.             }
  143.         });
  144.     }
  145.  
  146.     /**
  147.      * post请求，异步方式，提交数据，是在子线程中执行的，需要切换到主线程才能更新UI
  148.      * @param url
  149.      * @param bodyParams
  150.      * @param myNetCall
  151.      */
  152.     public  void postDataAsynToNet(String url, Map<String,String> bodyParams, final MyNetCall myNetCall) {
  153.         //1构造RequestBody
  154.         RequestBody body=setRequestBody(bodyParams);
  155.         //2 构造Request
  156.         Request.Builder requestBuilder = new Request.Builder();
  157.         Request request = requestBuilder.post(body).url(url).build();
  158.         //3 将Request封装为Call
  159.         Call call = mOkHttpClient.newCall(request);
  160.         //4 执行Call
  161.         call.enqueue(new Callback() {
  162.             @Override
  163.             public void onFailure(Call call, IOException e) {
  164.                 myNetCall.failed(call,e);
  165.             }
  166.  
  167.             @Override
  168.             public void onResponse(Call call, Response response) throws IOException {
  169.                 myNetCall.success(call,response);
  170.  
  171.             }
  172.         });
  173.     }
  174.     /**
  175.      * post的请求参数，构造RequestBody
  176.      * @param BodyParams
  177.      * @return
  178.      */
  179.     private RequestBody setRequestBody(Map<String, String> BodyParams){
  180.         RequestBody body=null;
  181.         okhttp3.FormBody.Builder formEncodingBuilder=new okhttp3.FormBody.Builder();
  182.         if(BodyParams != null){
  183.             Iterator<String> iterator = BodyParams.keySet().iterator();
  184.             String key = "";
  185.             while (iterator.hasNext()) {
  186.                 key = iterator.next().toString();
  187.                 formEncodingBuilder.add(key, BodyParams.get(key));
  188.                 Log.d("post http", "post_Params==="+key+"===="+BodyParams.get(key));
  189.             }
  190.         }
  191.         body=formEncodingBuilder.build();
  192.         return body;
  193.  
  194.     }
  195.  
  196.     /**
  197.      * 判断网络是否可用
  198.      * @param context
  199.      * @return
  200.      */
  201.     public static boolean isNetworkAvailable(Context context) {
  202.         ConnectivityManager cm = (ConnectivityManager) context
  203.                 .getSystemService(Context.CONNECTIVITY_SERVICE);
  204.         if (cm == null) {
  205.         } else {
  206.       //如果仅仅是用来判断网络连接
  207.       //则可以使用cm.getActiveNetworkInfo().isAvailable();
  208.             NetworkInfo[] info = cm.getAllNetworkInfo();
  209.             if (info != null) {
  210.                 for (int i = 0; i < info.length; i++) {
  211.                     if (info[i].getState() == NetworkInfo.State.CONNECTED) {
  212.                         return true;
  213.                     }
  214.                 }
  215.             }
  216.         }
  217.         return false;
  218.     }
  219.     /**
  220.      * 生成安全套接字工厂，用于https请求的证书跳过
  221.      * @return
  222.      */
  223.     public SSLSocketFactory createSSLSocketFactory() {
  224.         SSLSocketFactory ssfFactory = null;
  225.         try {
  226.             SSLContext sc = SSLContext.getInstance("TLS");
  227.             sc.init(null, new TrustManager[]{new TrustAllCerts()}, new SecureRandom());
  228.             ssfFactory = sc.getSocketFactory();
  229.         } catch (Exception e) {
  230.         }
  231.         return ssfFactory;
  232.     }
  233.     /**
  234.      * 用于信任所有证书
  235.      */
  236.     class TrustAllCerts implements X509TrustManager {
  237.         @Override
  238.         public void checkClientTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
  239.         }
  240.         @Override
  241.         public void checkServerTrusted(X509Certificate[] x509Certificates, String s) throws CertificateException {
  242.  
  243.         }
  244.         @Override
  245.         public X509Certificate[] getAcceptedIssuers() {
  246.             return new X509Certificate[0];
  247.         }
  248.     }
  249. }


2. 用法举例
推荐使用异步请求，因为已经把网络请求自动放到子线程了，用起来稍简单。而同步请求还需要自己new Thread+handler来做，几乎和原始的网络请求没区别了。因此这里举例就只举异步请求了。

异步GET请求
点击按钮登录 

  1. public void login(View view) {
  2.   final String account = etAccount.getText().toString();
  3.   final String pass = etPassword.getText().toString();
  4.   if (account.isEmpty() || pass.isEmpty()) {
  5.     Toast.makeText(this, "用户名或密码不能为空！", Toast.LENGTH_SHORT).show();
  6.            return;
  7.        }
  8.        if(!Global.isNetAvailable)
  9.        {
  10.            Toast.makeText(this, "网络不可用！", Toast.LENGTH_SHORT).show();
  11.            return;
  12.        }
  13.        //进度条
  14.        loginProgress.setVisibility(View.VISIBLE);
  15.        //获取网络工具类实例
  16.        NetUtils netUtils = NetUtils.getInstance();
  17.        //请求网络，一句代码搞定
  18.        netUtils.getDataAsynFromNet(Global.LOGIN + "?username=" + account + "&password=" + pass,
  19.                new NetUtils.MyNetCall() {
  20.                    @Override
  21.                    public void success(Call call, Response response) throws IOException {
  22.                        Log.i("tag", "success");
  23.                        String result = response.body().string();
  24.                        final ResponseBean responseBean = JSON.parseObject(result, ResponseBean.class);
  25.  
  26.                        if (responseBean != null) {
  27.                            runOnUiThread(new Runnable() {
  28.                                @Override
  29.                                public void run() {
  30.                                    loginProgress.setVisibility(View.GONE);
  31.                                    String errcode = responseBean.getErrcode();
  32.                                    if (errcode.equals("0")) {//登录成功
  33.                                        //记录学号
  34.                                        Global.account = account;
  35.                                        //存储用户名密码
  36.                                        saveUserName(account, pass);
  37.  
  38.                                        Intent intent = new Intent(LoginActivity.this, MainActivity.class);
  39.                                        startActivity(intent);
  40.                                        LoginActivity.this.finish();
  41.                                    } else {
  42.                                        Toast.makeText(LoginActivity.this, "请求失败！错误代码： " + errcode, Toast.LENGTH_SHORT).show();
  43.                                    }
  44.  
  45.                                }
  46.                            });
  47.  
  48.                        }
  49.                    }
  50.  
  51.                    @Override
  52.                    public void failed(Call call, IOException e) {
  53.                        Log.i("tag", "failed");
  54.                        runOnUiThread(new Runnable() {
  55.                            @Override
  56.                            public void run() {
  57.                                loginProgress.setVisibility(View.GONE);
  58.                                Toast.makeText(LoginActivity.this, "请求失败！", Toast.LENGTH_SHORT).show();
  59.                            }
  60.                        });
  61.                    }
  62.                }
  63.  
  64.        );
  65.  
  66.    }


异步POST请求
点击按钮，提交数据

  1. public void postSelect() {
  2.         //确保选择了楼号
  3.         if (tvTargetBuilding.getText().toString().isEmpty()) {
  4.             Toast.makeText(getActivity(),"请选择楼号！",Toast.LENGTH_SHORT).show();
  5.             return;
  6.         }
  7.         //构造请求参数
  8.         Map<String, String> reqBody = new ConcurrentSkipListMap<>();
  9.         reqBody.put("num", "1");
  10.         reqBody.put("stuid", Global.account);
  11.         reqBody.put("buildingNo", selectBuilding + "");
  12.         //获取网络请求工具类实例
  13.         NetUtils netUtils = NetUtils.getInstance();
  14.         //提交数据
  15.         netUtils.postDataAsynToNet(Global.SELECT_ROOM, reqBody, new NetUtils.MyNetCall() {
  16.             @Override
  17.             public void success(Call call, Response response) throws IOException {
  18.                 Log.i("tag", "success");
  19.                 String result = response.body().string();
  20.                 Log.i("tag", "result: " + result);
  21.                 //解析数据
  22.                 JSONObject jsonObject1 = JSON.parseObject(result);
  23.                 if (jsonObject1 != null) {
  24.                     final int error_code = jsonObject1.getIntValue("error_code");
  25.  
  26.                     getActivity().runOnUiThread(new Runnable() {
  27.                         @Override
  28.                         public void run() {
  29.                             Log.i("tag", "errcode: " + error_code);
  30.                             if (error_code == 0) {//提交成功
  31.                                 Toast.makeText(getActivity(), "选择成功！", Toast.LENGTH_SHORT).show();
  32.                                 //跳转到selectSuccessfragment
  33.                                 MainActivity.mainActivityInstance.switchFragment(getParentFragment(),SelectSuccessFragment.newInstance("", ""));
  34.                             } else {
  35.                                 Toast.makeText(getActivity(), "选择失败！错误代码： " + error_code, Toast.LENGTH_SHORT).show();
  36.                             }
  37.  
  38.                         }
  39.                     });
  40.  
  41.                 }
  42.             }
  43.             @Override
  44.             public void failed(Call call, IOException e) {
  45.                 Log.i("tag", "failed");
  46.                 getActivity().runOnUiThread(new Runnable() {
  47.                     @Override
  48.                     public void run() {
  49.                         Toast.makeText(getActivity(), "请求失败！", Toast.LENGTH_SHORT).show();
  50.                     }
  51.                 });
  52.             }
  53.         });
  54.  
  55.     }


什么？还嫌代码太长？

其实很短的，除去注释和打印的日志以及一些不相干的部分（我这里的是一个实际的项目，所以涉及到一些其他的东西），你会发现代码很少，核心的代码就是一句。（这时候你可能要说，哼，是一句，但一句有十多行。。。拜托~不要那么懒啦好不好 -_-|||）

要注意的是获取数据后，更新UI要在主线程中。我这里使用的是runOnUiThread也可以用Handler。

用Handler后你会发现这一部分的代码很少了，因为只需要把获取的数据用Message发送到Handler处理就好了，这样就把代码分散开了

用runOnUiThread的好处是很直接，不过看起来代码都堆到一起，其实很方便的。

完结，撒花~

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/259325
推荐阅读
相关标签

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

  

闽ICP备14008679号