android实现okHttp的get和post请求的简单封装与使用

由于Android课程项目需要，特地查阅了okHttp的使用，发现网上找的大多和自己的需求不一样。所以就着团队项目需要，自己简单封装了一个okHttp的get和post请求。

话不多说，直接看代码吧！

一、前期需要用到的属性封装

private static Request request = null;
   private static Call call = null;
   private static int TimeOut = 120;
   //单例获取ohttp3对象
   private static OkHttpClient client = null;
   /**
    * OkHttpClient的构造方法，通过线程锁的方式构造
    * @return OkHttpClient对象
    */
   private static synchronized OkHttpClient getInstance() {
       if (client == null) {
           client = new OkHttpClient.Builder()
                   .readTimeout(TimeOut, TimeUnit.SECONDS)
                   .connectTimeout(TimeOut, TimeUnit.SECONDS)
                   .writeTimeout(TimeOut, TimeUnit.SECONDS)
                   .build();
       }
       return client;
   }

/**
    * callback接口
    * 异步请求时使用
    */
   static class MyCallBack implements Callback {
       private OkHttpCallback okHttpCallBack;

public MyCallBack(OkHttpCallback okHttpCallBack) {
           this.okHttpCallBack = okHttpCallBack;
       }

@Override
       public void onFailure(Call call, IOException e) {
           okHttpCallBack.onFailure(e);
       }

@Override
       public void onResponse(Call call, Response response) throws IOException {
           okHttpCallBack.onSuccess(response);
       }
   }
   /**
    * 获得同步get请求对象Response
    * @param url
    * @return Response
    */
   private static Response doSyncGet(String url) {
       //创建OkHttpClient对象
       client = getInstance();
       request = new Request.Builder()
               .url(url)//请求链接
               .build();//创建Request对象
       try {
           //获取Response对象
           Response response = client.newCall(request).execute();
           return response;
       } catch (IOException e) {
           e.printStackTrace();
           return null;
       }
   }
   /**
    * 获得异步get请求对象
    * @param url      请求地址
    * @param callback 实现callback接口
    */
   private static void doAsyncGet(String url,OkHttpCallback callback) {
       MyCallBack myCallback = new MyCallBack(callback);
       client = getInstance();
       request = new Request.Builder()
               .url(url)
               .get()
               .build();
       client.newCall(request).enqueue(myCallback);
   }

其中，OKHttpCallback接口为：

import java.io.IOException;
import okhttp3.Response;

public interface OkHttpCallback {
   void onFailure(IOException e);
   void onSuccess(Response response);
}

二、get请求封装

1.项目需求是全程使用json格式的字符串进行交互，所以以下是针对json来封装的。
2.在这里说明一下，返回的是字符串类型，表示后台返回的json字符串，另外，为什么要用list来定义返回值result，result.get(0)为return值，因为直接用String来定义result会报错，具体原因未知。。。。

（1）同步get请求

   /**
    * 同步get请求
    * 例如：请求的最终地址为：http://127.0.0.1:8081/user/getUser/123
    * @param url 基本请求地址   例子： http://127.0.0.1:8081
    * @param args 请求的参数    args[]=new String[]{"user","getUser","123"}
    * @return String
    */
   public static String getSyncRequest(String url,String... args) {
       List<String> result=new ArrayList<>();//返回值
       String address=url;
       for(int i=0;i<args.length;i++){
           address=address+"/"+args[i];
       }
       final String finalAddress = address;
       new Thread(new Runnable() {
           @Override
           public void run() {
               Response finalResponse = doSyncGet(finalAddress);
               String res = null;
               try {
                   Log.d("同步get请求请求地址：",finalAddress);
                   if (finalResponse.isSuccessful()) {//请求成功
                       ResponseBody body = finalResponse.body();//拿到响应体
                       res = body.string();
                       result.add(res);
                       Log.d("HttpUtil", "同步get请求成功！");
                       Log.d("请求对象：", res);
                   } else {
                       Log.d("HttpUtil", "同步get请求失败！");
                   }
               } catch (IOException e) {
                   e.printStackTrace();
               }
           }
       }).start();
       /**因为函数返回是立刻执行的，而result要在请求完成之后才能获得
        * 所以需要等待result获得返回值之后再执行return*/
       while(result.size()==0){
           try {
               TimeUnit.MILLISECONDS.sleep(10);//等待xx毫秒
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       return result.get(0);
   }

（2）异步get请求
 

  /**
    * 异步get请求
    * 例如：请求的最终地址为：http://127.0.0.1:8081/user/getUser/123
    * @param url 基本请求地址   例子： http://127.0.0.1:8081
    * @param args 请求的参数    args[]=new String[]{"user","getUser","123"}
    * @return String
    */
   public static String getAsyncRequest(String url,String... args){
       List<String> result=new ArrayList<>();
       String address=url;
       for(int i=0;i<args.length;i++){
           address=address+"/"+args[i];
       }
       final String finalAddress = address;
       doAsyncGet(finalAddress, new OkHttpCallback() {
           @Override
           public void onFailure(IOException e) {
               Log.d("异步get请求地址：",finalAddress);
               Log.d("HttpUtil", "异步get请求失败！");
           }
           @Override
           public void onSuccess(Response response) {
               Log.d("异步get请求地址：",finalAddress);
               String res = null;
               try {
                   res = response.body().string();
               } catch (IOException e) {
                   e.printStackTrace();
               }
               result.add(res);
               Log.d("HttpUtil", "异步get请求成功！");
               Log.d("请求对象：", res);
           }
       });
       /**因为函数返回是立刻执行的，而result要在请求完成之后才能获得
        * 所以需要等待result获得返回值之后再执行return*/
       while(result.size()==0){
           try {
               TimeUnit.MILLISECONDS.sleep(10);//等待xx毫秒
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       return result.get(0);
   }

三、post请求

在此说明一下，后端接收的是一个name为“json”的字符串，实际就是传了个json字符串作为请求表单中的数据，后端通过解析这个json字符串进行下一步的操作

（1）同步post请求

   /**
    * 同步post请求
    * 例如：请求的最终地址为：http://127.0.0.1:8081/user/getUser/123
    * @param url 基本请求地址   例子： http://127.0.0.1:8081
    * @param json 提交的json字符串
    * @param args 请求的参数    args[]=new String[]{"user","getUser","123"}
    * @return
    */
   public static String postSyncRequest(String url,String json,String... args){
       List<String> result=new ArrayList<>();
       String address=url;
       for(int i=0;i<args.length;i++){
           address=address+"/"+args[i];
       }
       final String finalAddress = address;
       new Thread(new Runnable() {
           @Override
           public void run() {
               client=getInstance();
               Log.d("同步post请求地址：",finalAddress);
               FormBody.Builder formBody = new FormBody.Builder();
               formBody.add("json",json);
               request=new Request.Builder()
                       .url(finalAddress)
                       .post(formBody.build())
                       .addHeader("device-platform", "android")
                       .build();
               try{
                   Response response=client.newCall(request).execute();
                   String res=response.body().string();
                   result.add(res);
                   Log.d("HttpUtil", "同步post请求成功！");
                   Log.d("请求对象：", res);
               }catch (Exception e){
                   Log.d("HttpUtil", "同步post请求失败！");
                   e.printStackTrace();
               }
           }
       }).start();
       /**因为函数返回是立刻执行的，而result要在请求完成之后才能获得
        * 所以需要等待result获得返回值之后再执行return*/
       while(result.size()==0){
           try {
               TimeUnit.MILLISECONDS.sleep(10);//等待xx毫秒
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       return result.get(0);
   }

（2）异步post请求

   /**
    * 异步post请求
    * 例如：请求的最终地址为：http://127.0.0.1:8081/user/getUser/123
    * @param url 基本请求地址   例子： http://127.0.0.1:8081
    * @param json 提交的json字符串
    * @param args 请求的参数    args[]=new String[]{"user","getUser","123"}
    * @return
    */
   public static String postAsyncRequest(String url,String json,String... args){
       List<String> result=new ArrayList<>();
       String address=url;
       for(int i=0;i<args.length;i++){
           address=address+"/"+args[i];
       }
       final String finalAddress = address;
       Log.d("同步post请求地址：",finalAddress);
       client=getInstance();
       FormBody.Builder formBody = new FormBody.Builder();//创建表单请求体
       formBody.add("json",json);
       request = new Request.Builder()
               .url(finalAddress)
               .post(formBody.build())
               .addHeader("device-platform", "android")
               .build();
       Call call=client.newCall(request);
       call.enqueue(new Callback() {
           @Override
           public void onFailure(@NotNull Call call, @NotNull IOException e) {
               new Thread(new Runnable() {
                   @Override
                   public void run() {
                       Log.d("HttpUtil","异步post请求失败！");
                   }
               }).start();
           }

@Override
           public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
               new Thread(new Runnable() {
                   @Override
                   public void run() {
                       String res = null;
                       try {
                           res = response.body().string();
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                       result.add(res);
                       Log.d("HttpUtil","异步post请求成功！");
                       Log.d("请求对象",res);
                   }
               }).start();
           }
       });
       /**因为函数返回是立刻执行的，而result要在请求完成之后才能获得
        * 所以需要等待result获得返回值之后再执行return*/
       while(result.size()==0){
           try {
               TimeUnit.MILLISECONDS.sleep(10);//等待xx毫秒
           } catch (InterruptedException e) {
               e.printStackTrace();
           }
       }
       return result.get(0);
   }

四、依赖以及相关说明

相关依赖为：（okHttp和Gson）

   implementation 'com.squareup.okhttp3:okhttp:4.2.2'
   implementation 'com.google.code.gson:gson:2.7'

由于取消掉延时会导致result还没有被赋值就已经进行到return这里了，所以在每个请求方法中在return之前都加了个延时，直到result被赋值了再执行return

下一篇是讲android是如何通过okHttp跟后端交互起来的，以及相关例子。

来源：https://blog.csdn.net/weixin_47062406/article/details/116330158