Android RetrofitUtils 工具类（支持get post请求、支持图片上传）（持续更新）

已于 2024-08-13 11:59:17 修改
阅读量804 收藏 1
点赞数
分类专栏： 工具类 文章标签： Android 工具类 Retrofit OkHttp3
于 2019-08-13 11:22:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43500004/article/details/99413976
版权

20240813 更新说明
新增OKHttp 插件监听器 在android studio 插件搜索OkHttpProfiler Plugin 可以在插件界面查看接口传参和回调

使用方式

        String headerKey = "token,type";
        String token= "";
        String type = "";
        String parameterKey = "";
        RetrofitUtils.getHttpUtils("主路径")
        .isOpenLog(true)//是否打开log
        .setClassName("名称标识")//主要判断从那个类调用此方法
        .doPost("绝对路径"
        //请求头集合
        , RetrofitUtils.header(headerKey, token,type)
        //也可以手动new HashMap<String,Object>
        //请求参数集合 同上
        , RetrofitUtils.parameter(parameterKey,value1,value2)
        , new RetrofitUtils.CallBack<"返回值对应的实体类">() {
@Override
public void onSuccess("返回值对应的实体类" bean) {
        Log.d(TAG, "onSuccess: " + bean.toString());
        }
        }

@Override
public void onError(String error) {
        Log.d(TAG, "onError: " + error);
        }
        });

全部源码

import android.annotation.SuppressLint;
import android.util.Log;

import com.google.gson.Gson;

import java.io.File;
import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import io.nerdythings.okhttp.profiler.OkHttpProfilerInterceptor;
import io.reactivex.Observable;
import io.reactivex.Observer;
import io.reactivex.android.schedulers.AndroidSchedulers;
import io.reactivex.annotations.NonNull;
import io.reactivex.disposables.Disposable;
import io.reactivex.schedulers.Schedulers;
import okhttp3.Interceptor;
import okhttp3.MediaType;
import okhttp3.MultipartBody;
import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.RequestBody;
import okhttp3.Response;
import okhttp3.ResponseBody;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.http.Body;
import retrofit2.http.FieldMap;
import retrofit2.http.FormUrlEncoded;
import retrofit2.http.GET;
import retrofit2.http.HeaderMap;
import retrofit2.http.Multipart;
import retrofit2.http.POST;
import retrofit2.http.Part;
import retrofit2.http.QueryMap;
import retrofit2.http.Url;

//使用前 需要导入依赖
/*
  //retrofit
  implementation 'com.squareup.retrofit2:retrofit:2.9.0'
  //Gson converter
  implementation 'com.squareup.retrofit2:converter-gson:2.9.0'
  //RxJava2 Adapter
  implementation 'com.squareup.retrofit2:adapter-rxjava2:2.9.0'
  //RxJava
  implementation 'io.reactivex.rxjava2:rxjava:2.2.7'
  implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
  implementation 'io.nerdythings:okhttp-profiler:1.1.1'
*/
public class RetrofitUtils {
   private static RetrofitUtils httpUtils = null;//单例获取对象
   private final API API;
   private final String TAG = RetrofitUtils.class.getName();
   private static final Gson gson = new Gson();
   private static final HashMap<String, Object> h = new HashMap<>();
   private static final HashMap<String,Object> p = new HashMap<>();
   private boolean isOpenLog = false;//是否打开log
   private String classname = "";
   private final MultipartBody.Builder builder;

   //初始化
   private RetrofitUtils(String url) {
       OkHttpClient build = new OkHttpClient.Builder()
               .addInterceptor(new LoggingInterceptor())
               .addInterceptor(new OkHttpProfilerInterceptor())
               .connectTimeout(1000 * 30, TimeUnit.MILLISECONDS)
               .writeTimeout(1000 * 30, TimeUnit.MILLISECONDS)
               .build();
       API = new Retrofit.Builder()
               .baseUrl(url)
               .client(build)
               .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
               .build().create(API.class);
       builder = new MultipartBody.Builder();
   }

   //单例获取对象
   public static RetrofitUtils getHttpUtils(String url) {
       if (httpUtils == null) {
           synchronized (RetrofitUtils.class) {
               if (httpUtils == null) {
                   httpUtils = new RetrofitUtils(url);
               }
           }
       }
       return httpUtils;
   }
   //get请求有参
   public <T> void doGet(String url, Map<String, Object> map, final CallBack<T> callBack) {
       API.doGet(url, map)
               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {
                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);
                           }
                           Type[] genericInterfaces = callBack.getClass().getGenericInterfaces();
                           Type[] actualTypeArguments = ((ParameterizedType) genericInterfaces[0]).getActualTypeArguments();
                           Type actualTypeArgument = actualTypeArguments[0];
                           T o = gson.fromJson(string, actualTypeArgument);
                           callBack.onSuccess(o);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {
                       callBack.onError(e.toString());
                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //get请求请求头 有参
   public <T> void doGet(String url, Map<String, Object> header, Map<String, Object> map, final CallBack<T> callBack) {
       API.doGet(url, header, map)
               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {
                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);
                           }
                           Type[] genericInterfaces = callBack.getClass().getGenericInterfaces();
                           Type[] actualTypeArguments = ((ParameterizedType) genericInterfaces[0]).getActualTypeArguments();
                           Type actualTypeArgument = actualTypeArguments[0];
                           T o = gson.fromJson(string, actualTypeArgument);
                           callBack.onSuccess(o);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {
                       callBack.onError(e.toString());
                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //get请求 返回值是集合
   public <T> void doGetArray(String url, final ArrayCallBack callBack) {
       API.doGetArray(url)
               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {
                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);
                           }
                           callBack.onSuccess(string);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {
                       callBack.onError(e.toString());
                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //get请求 无参
   public <T> void doGet(String url, final CallBack<T> callBack) {
       API.doGet(url)
               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {
                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);

                           }
                           Type[] genericInterfaces = callBack.getClass().getGenericInterfaces();
                           Type[] actualTypeArguments = ((ParameterizedType) genericInterfaces[0]).getActualTypeArguments();
                           Type actualTypeArgument = actualTypeArguments[0];
                           T o = gson.fromJson(string, actualTypeArgument);
                           callBack.onSuccess(o);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {
                       callBack.onError(e.toString());
                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //post请求 有参
   public <T> void doPost(String url, Map<String, Object> map, final CallBack<T> callBack) {
       API.doPost(url, map)
               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {
                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);

                           }
                           Type[] genericInterfaces = callBack.getClass().getGenericInterfaces();
                           Type[] actualTypeArguments = ((ParameterizedType) genericInterfaces[0]).getActualTypeArguments();
                           Type actualTypeArgument = actualTypeArguments[0];
                           T o = gson.fromJson(string, actualTypeArgument);
                           callBack.onSuccess(o);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {
                       callBack.onError(e.toString());
                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //post请求 无参
   public <T> void doPost(String url, final CallBack<T> callBack) {
       API.doPost(url)
               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {
                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);

                           }
                           Type[] genericInterfaces = callBack.getClass().getGenericInterfaces();
                           Type[] actualTypeArguments = ((ParameterizedType) genericInterfaces[0]).getActualTypeArguments();
                           Type actualTypeArgument = actualTypeArguments[0];
                           T o = gson.fromJson(string, actualTypeArgument);
                           callBack.onSuccess(o);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {
                       callBack.onError(e.toString());
                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //post请求 请求头 有参
   public <T> void doPost(String url, Map<String, Object> header, Map<String, Object> map, final CallBack<T> callBack) {
       API.doPost(url, header, map)
               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {
                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);
                           }
                           Type[] genericInterfaces = callBack.getClass().getGenericInterfaces();
                           Type[] actualTypeArguments = ((ParameterizedType) genericInterfaces[0]).getActualTypeArguments();
                           Type actualTypeArgument = actualTypeArguments[0];
                           T o = gson.fromJson(string, actualTypeArgument);
                           callBack.onSuccess(o);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {
                       callBack.onError(e.toString());
                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //上传图片
   public <T> void doFile(String url, File file, final CallBack<T> callBack) {
       RequestBody body = RequestBody.create(MediaType.parse("image/*"), file);//上传的文件
       List<MultipartBody.Part> parts = builder.setType(MultipartBody.FORM)
               //在这里添加服务器除了文件之外的其他参数
               .addFormDataPart("file", file.getName(), body).build().parts();
       final Observable<ResponseBody> upload = API.upload(url, parts);
       upload.subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {
                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);
                           }
                           Type[] genericInterfaces = callBack.getClass().getGenericInterfaces();
                           Type[] actualTypeArguments = ((ParameterizedType) genericInterfaces[0]).getActualTypeArguments();
                           Type actualTypeArgument = actualTypeArguments[0];
                           T o = gson.fromJson(string, actualTypeArgument);
                           callBack.onSuccess(o);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {


                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //上传图片 请求头
   public <T> void doFile(String url, Map<String, Object> header, File file, final CallBack<T> callBack) {
       RequestBody body = RequestBody.create(MediaType.parse("image/*"), file);//上传的文件
       List<MultipartBody.Part> parts = builder.setType(MultipartBody.FORM)
               //在这里添加服务器除了文件之外的其他参数
               .addFormDataPart("file", file.getName(), body).build().parts();
       final Observable<ResponseBody> upload = API.upload(url, header, parts);
       upload.subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {
                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);
                           }

                           Type[] genericInterfaces = callBack.getClass().getGenericInterfaces();
                           Type[] actualTypeArguments = ((ParameterizedType)
                                   genericInterfaces[0]).getActualTypeArguments();
                           Type actualTypeArgument = actualTypeArguments[0];

                           T o = gson.fromJson(string, actualTypeArgument);

                           callBack.onSuccess(o);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {


                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //post请求 请求头 有参
   @SuppressLint("NewApi")
   public void doPostString(String url, Map<String, Object> header, Map<String, Object> map, final CallBack<String> callBack) {

       API.doPost(url, header, map)
               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {

                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       String string = null;
                       try {
                           string = responseBody.string();

                           callBack.onSuccess(string);
                       } catch (IOException e) {
                           Log.e(TAG, "onNext: " + classname + "\n" + e.toString() + "\n" + string);
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {
                       callBack.onError(e.toString());
                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }
   //post请求 RequestBody 请求头
   @SuppressLint("NewApi")
   public <T> void doPost(String url,RequestBody body, Map<String, Object> header,final CallBack<T> callBack) {

       API.doPost(url,body, header)
               .subscribeOn(Schedulers.io())
               .observeOn(AndroidSchedulers.mainThread())
               .subscribe(new Observer<ResponseBody>() {

                   @Override
                   public void onSubscribe(@NonNull Disposable d) {

                   }

                   @Override
                   public void onNext(@NonNull ResponseBody responseBody) {
                       try {
                           String string = responseBody.string();
                           if (isOpenLog) {
                               Log.e(TAG, "onNext: " + classname + "\n" + string);
                           }

                           Type[] genericInterfaces = callBack.getClass().getGenericInterfaces();
                           Type[] actualTypeArguments = ((ParameterizedType)
                                   genericInterfaces[0]).getActualTypeArguments();
                           Type actualTypeArgument = actualTypeArguments[0];

                           T o = gson.fromJson(string, actualTypeArgument);

                           callBack.onSuccess(o);
                       } catch (IOException e) {
                           e.printStackTrace();
                       }
                   }

                   @Override
                   public void onError(@NonNull Throwable e) {
                       callBack.onError(e.toString());
                   }

                   @Override
                   public void onComplete() {

                   }
               });
   }

   interface API {
       @POST
       @FormUrlEncoded
       Observable<ResponseBody> doPost(@Url String url, @FieldMap Map<String, Object> map);

       @GET
       Observable<ResponseBody> doGet(@Url String url, @QueryMap Map<String, Object> map);

       @GET
       Observable<ResponseBody> doGet(@Url String url);

       @GET
       Observable<ResponseBody> doGetArray(@Url String url);

       @POST
       @FormUrlEncoded
       Observable<ResponseBody> doPost(@Url String url, @HeaderMap Map<String, Object> headerMap, @FieldMap Map<String, Object> map);

       @GET
       Observable<ResponseBody> doGet(@Url String url, @HeaderMap Map<String, Object> headerMap, @QueryMap Map<String, Object> map);

       @Multipart
       @POST
       Observable<ResponseBody> upload(@Url String url, @Part List<MultipartBody.Part> partList);

       @Multipart
       @POST
       Observable<ResponseBody> upload(@Url String url, @HeaderMap Map<String, Object> headerMap, @Part List<MultipartBody.Part> partList);

       @POST
       Observable<ResponseBody> doPost(@Url String url, @Body RequestBody body, @HeaderMap Map<String, Object> header);

       @POST
       @FormUrlEncoded
       Observable<ResponseBody> doPost(@Url String url);

   }

   public RetrofitUtils setClassName(String name) {
       this.classname = name;
       return httpUtils;
   }
   //是否显示log
   public RetrofitUtils isOpenLog(boolean isOpenLog) {
       this.isOpenLog = isOpenLog;
       return httpUtils;
   }

   public static HashMap<String, Object> header(String appid, String version) {
       clearHMap();
       h.put("appid", appid);
       h.put("version", version);
       return h;
   }

   //请求头集合 key通过“，”拼接 如果是String以外的数据类型 需要手动添加对应方法 或者进行转换
   public static HashMap<String, Object> header(String key, String... parameter) {
       clearHMap();
       String[] split = key.split(",");
       for (int i = 0; i < split.length; i++) {
           h.put(split[i], parameter[i]);
       }
       return h;
   }

   //参数集合 key通过“，”拼接 如果是String以外的数据类型 需要手动添加对应方法 或者进行转换
   public static HashMap<String, Object> parameter(String key, String... parameter) {
       clearPMap();
       String[] split = key.split(",");
       for (int i = 0; i < split.length; i++) {
           p.put(split[i], parameter[i]);
       }
       return p;
   }

   //参数集合 手动添加
   public static HashMap<String, Object> parameter() {
       clearPMap();
       return p;
   }

   //数据返回回调方法
   public interface CallBack<T> {
       void onSuccess(T bean);

       void onError(String error);
   }

   //返回数据是数组，回调方法
   interface ArrayCallBack {
       void onSuccess(String responseBody);

       void onError(String error);
   }
   //清空参数集合
   private static void clearPMap() {
       if (p != null && p.size() > 0) {
           p.clear();
       }
   }
   //清空请求头集合
   private static void clearHMap() {
       if (h != null && h.size() > 0) {
           h.clear();
       }
   }
   //拦截器
   static class LoggingInterceptor implements Interceptor {
       private static final String TAG = "LoggingInterceptor";

       @NonNull
       @Override
       public Response intercept(Chain chain) throws IOException {
           Request request = chain.request();//获取请求数据
           //1.请求前--打印请求信息
           long startTime = System.nanoTime();
           Log.d(TAG, String.format("Sending request %s on %s%n%s", request.url(), chain.connection(), request.headers()));
           //2.网络请求
           Response response = chain.proceed(request);
           //3.网络响应后--打印响应信息
           long endTime = System.nanoTime();
           Log.d(TAG, String.format("Received response for %s in %.1fms%n%s", response.request().url(), (endTime - startTime) / 1e6d, response.headers()));
           return response;
       }
   }

}
是寒霜啊
关注
专栏目录
Android Rxjava+Retrofit网络请求框架封装（二）
斌林诚上的博客
03-01 9808
一、前言 二、BaseResponse与BaseObserver的封装 三、RxHelper调度类封装 四、Retrofit初始化封装 五、细节完善 1、服务错误信息处理 2、添加“正在加载”弹窗 3、Retorfit请求方法汇总 4、提交参数方式汇总（可忽略） 六、总结 七、Demo地址 八、内容推荐 一、前言 由于《Rxjava+Retrofit网络请求框架封装...
Android平台下用GET获得公开API数据的方法--Retrofit
sunzhe91的博客
07-26 1540
最近根据同学的建议，编写了一个网络音乐播放器的小项目。主要目的在练习网络相关的内容，其中根据百度音乐公开的API进行网络部分的编写。这就遇到了获取返回JSON数据的问题。很多人都知道，公开的API格式一般是这样的： http://tingapi.ting.baidu.com/v1/restserver/ting?format=json&calback=&from=webapp_music&met
Android-RxRetrofitUtils封装工具类
08-13
RxRetrofitUtils 封装工具类
Android网络请求库RetrofitUtils
ElegantHedgehog的博客
11-08 338
RetrofitUtils GitHub地址，帮忙给个Star 项目介绍 Retrofit+Okhttp辅助类的简单封装，vesion 1.0.X 实现了Get，Post-Form、Post-Json 三种形式的网络请求，后续版本会实现文件上传下载and各类raw的请求方式。 功能 Get Post表单 PostJson 后续版本待实现功能 文件上传下载（开发中...） 拦截器 RxJava+Retrofit+Okhttp 考虑去掉loading（丑且无用），是否把所用到的第三方库打包进库中 使用...
retrofit基本使用和原理梳理
最新发布
qq_45674709的博客
08-29 334
从使用retrofit的使用方法进行逐步理解其工作。总：retrofit是基于okhttp，restful风格的一个网络请求库，简化、规范使用流程。
Android代码-RetrofitUtils
08-06
RetrofitUtils RxJava Retrofit封装，包含对相同格式请求数据、相同格式返回数据处理，显示Material Design加载dialog，文件上传下载进度展示、全局异常捕捉。 Preview 演示中upload.png为上传图片源文件。 Describe 实现功能： 1、对于相同格式请求数据统一处理； 2、对于相同返回结果进行预处理； 3、显示加载dialog; 4、支持文件带进度上传下载。 主要几个类作用： 1、RetrofitUtils.java 主要是数据post、get等请求工具类，所有请求调用doHttp()方法。 2、RetrofitFileUtils.java 主要用于文件下载工具类，包含uploadFile()文件上传、downloadFile()文件下载两个方法。 3、BaseFileDownload.java 文件下载请求基类，文件下载请求实体类需继承该类实现内部方法。 4、BaseFileUpload.java 文件上传请求基类，文件上传请求实体类需继承该类实现内部方法。 5、HttpResultFunc.java 基本数据请求基类，
RxJava + Retrofit+okhttp 封装，包含对相同格式请求数据、相同格式返回数据处理，显示 Material Design 加载 dialog，文件上传下载进度展示、全局异常捕捉。
未来很长，但我会努力的走下去。
10-28 825
RxJava + Retrofit+okhttp 封装，包含对相同格式请求数据、相同格式返回数据处理，显示 Material Design 加载 dialog，文件上传下载进度展示、全局异常捕捉。
RetrofitUtils使用
JAVA技术博客
12-13 2449
RetrofitUtils
Android开发常用工具类
12-15
- `RetrofitUtils`：基于Retrofit库的工具类，提供简洁的接口调用方式，支持异步和同步请求。 4. **文件操作工具类**： - `FileUtils`：读写文件、创建目录、删除文件等操作，还有文件流的处理，如文件复制、移动...
android 常用的工具类
07-04
在Android开发过程中，工具类（Utility Classes）是开发者不可或缺的一部分，它们封装了各种常见的功能，提高了代码的可重用性和可维护性。本篇将详细探讨Android常用的工具类及其应用场景。 1. **字符串处理工具类...
Android Retrofit工具类 （kotlin版本）
qq_43500004的博客
03-15 513
与请求参数相同，作为http请求的请求头设置到请求中。主要是网络解析添加参数，然后获取到请求回调的方法。通过可变参数，可以实现多参数添加。
Android-retrofit网络工具类
08-13
写在前面: Retrofit与okhttp共同出自于Square公司，是目前市场上使用最多的联网框架,retrofit是对okhttp做了一层封装,不过封装之后的retrofit上手还是极其复杂,为了解决使用难度问题,本文推荐使用github开源项目RetrofitUtils.
retrofit和公共参数拦截器封装
wei844067872的博客
03-20 767
public class RetrofitUtil {    private static RetrofitUtil retrofitUtil = null;    private Retrofit retrofit;    private RetrofitUtil() {    }    private RetrofitUtil(String baseUrl) {        OkHttpCl...
RetrofitUtils
TT5205658的博客
01-14 276
package com.example.bw.utils.okhttputils; import android.content.Context; import android.content.SharedPreferences; import android.text.TextUtils; import com.example.bw.App; import java.io.File; i...
retrofit工具类
mm_name_zhang的博客
04-20 256
public class RetyofitUitl { private static RetyofitUitl retyofitUitl; private RetyofitUitl(){ } public static RetyofitUitl getRetyofitUitl (){ if (retyofitUitl==
Retrofit工具类
weixin_43629061的博客
01-06 340
package com.example.week2.retrofitUtils; import android.util.Log; import com.example.week2.model.Contacts; import java.io.IOException; import java.util.Map; import java.util.concurrent.TimeUnit; impor...
这些小工具让你的Android 开发更高效
热门推荐
tikitoo的专栏
04-07 2万+
在做Android 开发过程中，会遇到一些小的问题，虽然自己动手也能解决，但是有了一些小工具，解决这些问题就得心应手了，今天就为大家推荐一下Android 开发遇到的小工具，来让你的开发更高效。
RetrofitUtils：优雅地集成Retrofit，让网络请求变得更简单
gitblog_00022的博客
03-29 375
RetrofitUtils：优雅地集成Retrofit，让网络请求变得更简单 项目地址:https://gitcode.com/hcs-xph/RetrofitUtils 项目简介 RetrofitUtils 是一个基于Android平台的开源库，它以简洁、高效的方式封装了Retrofit 和 OkHttp，旨在简化Android应用中的网络请求操作。通过提供一套易于理解和使用的API，开发者可以...
RetrofitUtils工具类+MVP
weixin_44032211的博客
02-18 199
Retrofit public class RetrofitUtils { private static RetrofitUtils instence; private final Retrofit retrofit; //单例模式 public static RetrofitUtils getInstence() { if (instence==null){ synch...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值