优雅封装Retrofit+RxJava联网的统一管理类

最新推荐文章于 2021-02-24 23:56:48 发布
最新推荐文章于 2021-02-24 23:56:48 发布
阅读量273 收藏
点赞数 1
分类专栏： 网络请求框架 文章标签： Android联网框架封装 Retrofit2.0 Rxjava Android网络管理类 Interceptor拦截器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zj_blog/article/details/80166624
版权
Retrofit的简单用法在上一篇文章 分分钟使用Retrofit+Rxjava实现网络请求，已经做过介绍了，今天就不赘述了。
今天主要分享一下如何结合Rxjava，封装一个RetrofitManager管理类，统一管理联网操作。
《一》让我们先来看看封装后的用法： 
  RetrofitManager.getInstance().getRequestService().getWeather("北京")
                            .compose(RxSchedulers.io_main())
                            .subscribeWith(new DisposableObserver<Object>() {
                                @Override
                                public void onNext(Object result) {                                
                                    Log.e("TAG", "result=" + result.toString());
                                }


                                @Override
                                public void onError(Throwable e) {
                                    Log.e("TAG", "onError=" + e.getMessage());
                                }


                                @Override
                                public void onComplete() {
                                    Log.e("TAG", "onComplete");
                                }
                            });
封装后的用法大家看到了，链式调用，一步到位，非常简洁明了。接下来我就带着大家一步步封装一个RetrofitManager。
《二》封装Retrofit+Rxjava的管理类RetrofitManager
（1）在app的build.gradle下配置Retrofit和Rxjava相关的依赖包 
   //rxandroid
    implementation 'io.reactivex.rxjava2:rxandroid:2.0.2'
    //rxjava
    implementation 'io.reactivex.rxjava2:rxjava:2.1.10'
    //retrofit
    implementation "com.squareup.retrofit2:retrofit:2.4.0"
    //gsonConverter
    implementation "com.squareup.retrofit2:converter-gson:2.4.0"
    //rxjavaAdapter
    implementation "com.squareup.retrofit2:adapter-rxjava2:2.4.0"
    //retrofit log打印
    implementation 'com.squareup.okhttp3:logging-interceptor:3.4.1'
（小提醒： Android Studio3.0之后的依赖，由compile变成了implementation。)

（2）①新建RetrofitManager类，提供单例

public class RetrofitManager {
    /**
     * 获取单例
     */
    private static RetrofitManager mInstance;
       public static RetrofitManager getInstance() {
        if (mInstance == null) {
            synchronized (RetrofitManager.class) {
                if (mInstance == null) {
                    mInstance = new RetrofitManager();
                }
            }
        }
        return mInstance;
    }
}

②配置OkHttp，构建Retrofit对象

  private static final long DEFAULT_TIMEOUT = 60L;
  public Retrofit getRetrofit() {
        if (retrofit == null) {
            synchronized (RetrofitManager.class) {
                if (retrofit == null) {
                    OkHttpClient mClient = new OkHttpClient.Builder()
                            //添加公共查询参数
                            //.addInterceptor(new CommonQueryParamsInterceptor())
                            //.addInterceptor(new MutiBaseUrlInterceptor())
                            //添加header
                            .addInterceptor(new HeaderInterceptor())
                            .addInterceptor(new LoggingInterceptor())//添加请求拦截(可以在此处打印请求信息和响应信息)
                            .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                            .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                            .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                            .build();
                    retrofit = new Retrofit.Builder()
                            .baseUrl(BASE_URL)//基础URL 建议以 / 结尾
                            .addConverterFactory(GsonConverterFactory.create())//设置 Json 转换器
                            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//RxJava 适配器
                            .client(mClient)
                            .build();
                }
            }
        }
        return retrofit;
    }
③通过代理的方式，创建ApiServe接口的实例。 
 public ApiService getRequestService() {
        return getRetrofit().create(ApiService.class);
    }
ApiService是一个自己定义的interface,所有的网络请求接口的配置，都在此接口内完成。网络请求URL的配置可以参考 Retrofit请求参数的配置 
interface ApiService {
    //获取北京的天气信息
//    "https://www.sojson.com/open/api/weather/json.shtml?city=" + "北京"
    @GET("weather/json.shtml")
    Observable<Object> getWeather(@Query("city")String city);
    //上传文件
   @POST("upload/")
    Observable<UserAvatarBean> uploadFile(@Body RequestBody body);
}
④Header的配置 
   /**
     * 添加请求头需要携带的参数
     */
    public class HeaderInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Request requestBuilder = request.newBuilder()
                    .addHeader("Connection", HEADER_CONNECTION)
                    .addHeader("token", "token-value")
                    .method(request.method(), request.body())
                    .build();
            return chain.proceed(requestBuilder);
        }
    }
⑤Retrofit的log日志打印 
/**
     * log打印:参考：http://blog.csdn.net/csdn_lqr/article/details/61420753
     */
    public class LoggingInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            //这个chain里面包含了request和response，所以你要什么都可以从这里拿
            Request request = chain.request();
            long t1 = System.nanoTime();//请求发起的时间
            String method = request.method();
            JSONObject jsonObject = new JSONObject();
            if ("POST".equals(method) || "PUT".equals(method)) {
                if (request.body() instanceof FormBody) {
                    FormBody body = (FormBody) request.body();
                    if (body != null) {
                        for (int i = 0; i < body.size(); i++) {
                            try {
                                jsonObject.put(body.name(i), body.encodedValue(i));
                            } catch (JSONException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                    Log.e("request", String.format("发送请求 %s on %s  %nRequestParams:%s%nMethod:%s",
                            request.url(), chain.connection(), jsonObject.toString(), request.method()));
                } else {
                    Buffer buffer = new Buffer();
                    RequestBody requestBody = request.body();
                    if (requestBody != null) {
                        request.body().writeTo(buffer);
                        String body = buffer.readUtf8();
                        Log.e("request", String.format("发送请求 %s on %s  %nRequestParams:%s%nMethod:%s",
                                request.url(), chain.connection(), body, request.method()));
                    }
                }
            } else {
                Log.e("request", String.format("发送请求 %s on %s%nMethod:%s",
                        request.url(), chain.connection(), request.method()));
            }
            Response response = chain.proceed(request);
            long t2 = System.nanoTime();//收到响应的时间
            ResponseBody responseBody = response.peekBody(1024 * 1024);
            Log.e("request",
                    String.format("Retrofit接收响应: %s %n返回json:【%s】 %n耗时：%.1fms",
                            response.request().url(),
                            responseBody.string(),
                            (t2 - t1) / 1e6d
                    ));
            return response;
        }


    }

看一下日志打印的效果，有了日志打印，我们就能轻松的调试每个网络请求了。


《三》OkHttp的拦截器Interceptor
无论是上面添加header，还是处理log日志打印，或是设置缓存，配置一些公共请求参数等等，都是通过添加拦截器addInterceptor()来实现的，所以拦截器有多重要，就不用我多说了啦~

先举个简单的栗子，了解一下拦截器是个什么东西？
**官方介绍**：拦截器是一种能够监控，重写，重试调用的**强大机制**。拦截发出的请求和传入的响应的日志.
**打个比方**：镖局押着一箱元宝走过一个山间小路，突然从山上下来一群山贼拦住了镖局的去路，将镖局身上值钱的东西搜刮干净后将其放行。其中山贼相当于拦截器，镖局相当于一个正在执行任务的网络请求，请求中的参数就是镖局携带的元宝。拦截器可以将网络请求携带的参数进行修改验证，然后放行。这里面其实设计了AOP编程的思想（ 面向切面编程）。


详细了解可参考：
Okhttp拦截器

Interceptors拦截器

手把手带你深入剖析Retrofit2.0源码



附上RetrofitManager的完整代码（包括Retrofit文件的上传）： 
package com.zongxueguan.naochanle_android.net.retrofit;


import com.zongxueguan.naochanle_android.global.API;
import com.zongxueguan.naochanle_android.retrofitrx.ApiService;
import com.zongxueguan.naochanle_android.util.UserConstants;
import com.zxg.framework.library.common.log.Elog;


import org.json.JSONException;
import org.json.JSONObject;


import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.concurrent.TimeUnit;


import okhttp3.CacheControl;
import okhttp3.FormBody;
import okhttp3.HttpUrl;
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 okhttp3.logging.HttpLoggingInterceptor;
import okio.Buffer;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import retrofit2.converter.gson.GsonConverterFactory;


/**
 * Created by JoJo on 2018/4/24.
 * wechat:18510829974
 * description:
 */
public class RetrofitManager {
    /**
     * 请求接口实例对象
     */
    private static RetrofitManager mInstance;
    private static final long DEFAULT_TIMEOUT = 60L;
    private Retrofit retrofit = null;
    //请求头信息
    private final String HEADER_CONNECTION = "keep-alive";


    public static RetrofitManager getInstance() {
        if (mInstance == null) {
            synchronized (RetrofitManager.class) {
                if (mInstance == null) {
                    mInstance = new RetrofitManager();
                }
            }
        }
        return mInstance;
    }


    public Retrofit getRetrofit() {
        if (retrofit == null) {
            synchronized (RetrofitManager.class) {
                if (retrofit == null) {
                    OkHttpClient mClient = new OkHttpClient.Builder()
                            //添加公告查询参数
//                          .addInterceptor(new CommonQueryParamsInterceptor())
//                          .addInterceptor(new MutiBaseUrlInterceptor())
                            .addInterceptor(new HeaderInterceptor())
                            .addInterceptor(new LoggingInterceptor())//添加请求拦截(可以在此处打印请求信息和响应信息)
                            .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                            .writeTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                            .readTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS)
                            .build();
                    retrofit = new Retrofit.Builder()
                            .baseUrl(API.getInstance().BASE_API_URL)//基础URL 建议以 / 结尾
                            .addConverterFactory(GsonConverterFactory.create())//设置 Json 转换器
                            .addCallAdapterFactory(RxJava2CallAdapterFactory.create())//RxJava 适配器
                            .client(mClient)
                            .build();
                }
            }
        }
        return retrofit;
    }


    public ApiService getRequestService() {
        return getRetrofit().create(ApiService.class);
    }


    /**
     * 设置公共查询参数
     */
    public class CommonQueryParamsInterceptor implements Interceptor {


        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            HttpUrl url = request.url().newBuilder()
                    .addQueryParameter("paramsA", "a")
                    .addQueryParameter("paramsB", "b")
                    .build();
            return chain.proceed(request.newBuilder().url(url).build());
        }
    }


   /**
     * 添加请求头需要携带的参数
     */
    public class HeaderInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            Request requestBuilder = request.newBuilder()
                    .addHeader("Connection", HEADER_CONNECTION)
                    .addHeader("token", "token-value")
                    .method(request.method(), request.body())
                    .build();
            return chain.proceed(requestBuilder);
        }
    }


    /**
     * 设置缓存
     */
    public class CacheInterceptor implements Interceptor {


        @Override
        public Response intercept(Chain chain) throws IOException {
            Request request = chain.request();
            request.newBuilder().cacheControl(CacheControl.FORCE_CACHE)
                    .build();
            Response response = chain.proceed(request);
            int maxAge = 0;
            // 有网络时 设置缓存超时时间0个小时 ,意思就是不读取缓存数据,只对get有用,post没有缓冲
            response.newBuilder()
                    .header("Cache-Control", "public, max-age=" + maxAge)
                    .removeHeader("Retrofit")// 清除头信息，因为服务器如果不支持，会返回一些干扰信息，不清除下面无法生效
                    .build();
            // 无网络时，设置超时为4周  只对get有用,post没有缓冲
            int maxStale = 60 * 60 * 24 * 28;
            response.newBuilder()
                    .header("Cache-Control", "public, only-if-cached, max-stale=" + maxStale)
                    .removeHeader("nyn")
                    .build();
            return response;
        }
    }


    /**
     * log打印:http://blog.csdn.net/csdn_lqr/article/details/61420753
     */
    public class LoggingInterceptor implements Interceptor {
        @Override
        public Response intercept(Chain chain) throws IOException {
            //这个chain里面包含了request和response，所以你要什么都可以从这里拿
            Request request = chain.request();
            long t1 = System.nanoTime();//请求发起的时间
            String method = request.method();
            JSONObject jsonObject = new JSONObject();
            if ("POST".equals(method) || "PUT".equals(method)) {
                if (request.body() instanceof FormBody) {
                    FormBody body = (FormBody) request.body();
                    if (body != null) {
                        for (int i = 0; i < body.size(); i++) {
                            try {
                                jsonObject.put(body.name(i), body.encodedValue(i));
                            } catch (JSONException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                    Elog.e("request", String.format("发送请求 %s on %s  %nRequestParams:%s%nMethod:%s",
                            request.url(), chain.connection(), jsonObject.toString(), request.method()));
                } else {
                    Buffer buffer = new Buffer();
                    RequestBody requestBody = request.body();
                    if (requestBody != null) {
                        request.body().writeTo(buffer);
                        String body = buffer.readUtf8();
                        Elog.e("request", String.format("发送请求 %s on %s  %nRequestParams:%s%nMethod:%s",
                                request.url(), chain.connection(), body, request.method()));
                    }
                }
            } else {
                Elog.e("request", String.format("发送请求 %s on %s%nMethod:%s",
                        request.url(), chain.connection(), request.method()));
            }
            Response response = chain.proceed(request);
            long t2 = System.nanoTime();//收到响应的时间
            ResponseBody responseBody = response.peekBody(1024 * 1024);
            Elog.e("request",
                    String.format("Retrofit接收响应: %s %n返回json:【%s】 %n耗时：%.1fms",
                            response.request().url(),
                            responseBody.string(),
                            (t2 - t1) / 1e6d
                    ));
            return response;
        }


    }


    /**
     * 打印log日志：该拦截器用于记录应用中的网络请求的信息
     */
    private HttpLoggingInterceptor getHttpLogingInterceptor() {
        HttpLoggingInterceptor httpLoggingInterceptor = new HttpLoggingInterceptor(new HttpLoggingInterceptor.Logger() {
            @Override
            public void log(String message) {
                //包含所有的请求信息
                //如果收到响应是json才打印
                if ("{".equals(message) || "[".equals(message)) {
                    Log.d("TAG", "收到响应: " + message);
                }
                Log.d("TAG", "message=" + message);
            }
        });
        httpLoggingInterceptor.setLevel(HttpLoggingInterceptor.Level.BODY);
        return httpLoggingInterceptor;
    }


    private String BASE_URL_OTHER = "http://wthrcdn.etouch.cn/";


    /**
     * 添加可以处理多个Baseurl的拦截器：http://blog.csdn.net/qq_36707431/article/details/77680252
     * Retrofit(OKHttp)多BaseUrl情况下url实时自动替换完美解决方法:https://www.2cto.com/kf/201708/663977.html


//     http://wthrcdn.etouch.cn/weather_mini?city=北京
//    @Headers({"url_name:other"})
//    @GET("weather_mini")
//    Observable<WeatherEntity> getMessage(@Query("city") String city);
     */
    private class MutiBaseUrlInterceptor implements Interceptor {


        @Override
        public Response intercept(Chain chain) throws IOException {
            //获取request
            Request request = chain.request();
            //从request中获取原有的HttpUrl实例oldHttpUrl
            HttpUrl oldHttpUrl = request.url();
            //获取request的创建者builder
            Request.Builder builder = request.newBuilder();
            //从request中获取headers，通过给定的键url_name
            List<String> headerValues = request.headers("url_name");
            if (headerValues != null && headerValues.size() > 0) {
                //如果有这个header，先将配置的header删除，因此header仅用作app和okhttp之间使用
                builder.removeHeader("url_name");
                //匹配获得新的BaseUrl
                String headerValue = headerValues.get(0);
                HttpUrl newBaseUrl = null;
                if ("other".equals(headerValue)) {
                    newBaseUrl = HttpUrl.parse(BASE_URL_OTHER);
//                } else if ("other".equals(headerValue)) {
//                    newBaseUrl = HttpUrl.parse(BASE_URL_PAY);
                } else {
                    newBaseUrl = oldHttpUrl;
                }
                //在oldHttpUrl的基础上重建新的HttpUrl，修改需要修改的url部分
                HttpUrl newFullUrl = oldHttpUrl
                        .newBuilder()
                        .scheme("http")//更换网络协议,根据实际情况更换成https或者http
                        .host(newBaseUrl.host())//更换主机名
                        .port(newBaseUrl.port())//更换端口
                        .removePathSegment(0)//移除第一个参数v1
                        .build();
                //重建这个request，通过builder.url(newFullUrl).build()；
                // 然后返回一个response至此结束修改
                Elog.e("Url", "intercept: " + newFullUrl.toString());
                return chain.proceed(builder.url(newFullUrl).build());
            }
            return chain.proceed(request);
        }
    }


    /**
     * Retrofit上传文件
     *
     * @param mImagePath
     * @return
     */
    public RequestBody getUploadFileRequestBody(String mImagePath) {
        File file = new File(mImagePath);
        //构建body
        RequestBody requestBody = new MultipartBody.Builder().setType(MultipartBody.FORM)
                .addFormDataPart("file", file.getName(), RequestBody.create(MediaType.parse("multipart/form-data"), file))
                .build();
        return requestBody;
    }
}










































一只懂音乐的码虫
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Retrofit+Rxjava实现文件上传和下载功能
08-28
Retrofit+Rxjava 实现文件上传和下载功能 Retrofit 和 Rxjava 是两个非常流行的开源框架，前者是一个网络请求框架，后者是一个响应式编程框架。它们可以结合使用来实现文件上传和下载功能，下面我们来详细介绍如何...
【Android】RxJava2+Retrofit2+OkHttp3的基础、封装和项目中的使用
Jocerly的专栏
11-29 1078
前言： 近些年很火的Retrofit+RxJava+OkHttp网络请求框架，功能强大，结构合理，使用简单方便。后面还会给大家发自己整理过的Retrofit和RxJava、RxAndroid和RxBus。希望大家点一下关注，让我这个懒癌患者有动力继续写下去！ 本篇分三个部分：基础篇、封装篇和自己项目使用篇，项目是自己公司的APP提取的，文章偏长可以分三部分一点点看，当初看了很多优秀的文章然后自...
Android RxJava+Retrofit网络异常、状态码统一处理
热门推荐
却把清梅嗅的博客
04-19 3万+
Android RxJava+Retrofit 网络异常捕获、状态码统一处理前言近来使用RxJava+Retrofit进行开发，在项目中遇到这样一个需求，联网请求获得数据异常时，需要将对应的Message和StatusCode进行获得并展示，比如： 1.服务器连接Error: 对应的返回404，500等等； 2.没有网络状态（没有4g，3g，是否处于wifi环境下等）；参考文章： Rxjava
基于retrofit2的请求管理类
幽默UY的博客
01-14 364
写的一个基于retrofit2的请求管理类，用于管理请求的增删改查以及请求复用，可放在BaseActivity或者BaseFragment中； package com.nbniu.app.common.tool; import java.util.HashMap; import java.util.Iterator; import java.util.Map; import retrofit2...
请求参数 统一 管理 java_Retrofit+Rxjava+okhttp基本操作和统一处理 – R...
weixin_42176612的博客
02-24 205
Retrofit+Rxjava+okhttp基本操作和统一处理的demo1.Retrofit+Rxjava+okhttp基本使用方法2.统一处理请求数据格式3.统一的ProgressDialog和回调Subscriber处理4.取消http请求5.预处理http请求6.返回数据的统一判断7.失败后的retry处理8.RxLifecycle管理生命周期，防止泄露9.文件上传下载(支持多文件，断点续传...
Retrofit+Rxjava网络层的优雅封装
weixin_34342992的博客
09-29 125
想必Retrifit+Rxjava的使用，如今已经非常的普及了吧。在此介绍一种比较优雅的有关Retrifit+Rxjava封装的方法。参考github项目XDroidMvp 原本的步骤应该是这样，首先要创建OKHttpClient ，在其中添加一些拦截和超时处理，然后创建Retrofit对象并注入OKHttpClient对象，再获取接口实例Observable对象，然后绑定生命周期（防止内存泄漏）...
Android 封装Okhttp+Retrofit+RxJava,外加拦截器实例
01-05
1.创建一个接口,用来定义接口使用的 public interface Api { @POST(product/getProductDetail) Observable<Goods> getGoods(@QueryMap Map<String> map); @POST(product/addCart) Observable<Add> getAdd(@...
Retrofit2+Rxjava2网络请求异常统一封装处理
04-15
在Android应用开发中，网络请求是必不可少的一部分，Retrofit2和RxJava2是两种非常流行的库，用于构建和管理网络接口。本篇文章将详细讲解如何使用Retrofit2和RxJava2进行网络请求，并进行异常统一封装处理，以便...
Retrofit+rxjava+mvp形式上传多张图片完整示例
05-26
总结来说，这个示例提供了一个完整的Android应用实现，包括图片选择、Retrofit+RxJava的图片上传以及MVP架构的应用，对于学习和实践Android网络编程和响应式编程具有很高的参考价值。理解并掌握这些技术，将有助于...
WanAndroid-Java：一种采用Java语言，MVVM + Retrofit + RxJava架构开发的玩Android客户端（https：www.wanandroid.com）。PS：Kotlin版（https：github.comchongyucaiyanWanAndroid-Kotlin）
02-03
整个项目采用MVVM + Retrofit + RxJava架构进行开发。 项目截图 项目版本 v1.0.0 基本功能 技术要点 采用MVVM模式开发，查看操作和业务逻辑解耦 采用DataBinding框架实现View与数据的绑定，View层做到极度简洁 采用...
retrofit-helper 简洁的封装retrofit，优雅的取消请求
code小生
05-15 659
code小生,一个专注 Android 领域的技术平台公众号回复 Android 加入我的安卓技术群作者：xchengDroid链接：https://github.com...
优雅地封装使用rxjava2+retrofit2发送http请求
ihchenchen的博客
11-29 2657
优雅地封装使用rxjava2+retrofit2发送http请求
retrofit的manger类
bruceyang的博客
06-12 367
compile 'com.squareup.retrofit2:retrofit:2.3.0' compile 'com.squareup.retrofit2:converter-gson:2.3.0' package com.supermap.testdemo; import android.content.Context; import android.content.SharedPr
Android 日志拦截器
qq_41880248的博客
12-10 332
import android.util.Log; import java.io.IOException; import okhttp3.FormBody; import okhttp3.Interceptor; import okhttp3.Request; import okhttp3.Response; import okhttp3.ResponseBody; public cl...
Retrofit+GreenDao请求数据保存数据库
RenZjun的博客
12-03 1285
//recyclerview适配器 public class MyAdapter extends RecyclerView.Adapter { private Context context; private List list; public MyAdapter(Context context, List list) { this.context
mvp关联activity生命周期_Rxjava+Retrofit统一异常处理与生命周期管理
weixin_39520210的博客
12-20 207
一、引入9102年了，终于准备用mvp来重构一下了之前写过Mvc模式下的Retrofit统一异常处理，这次用MVP重构过程中发现诸多不足之处，便重新进行修缮，使其在我看来更加优雅emmmmmm，文中不足之处，还望诸位同仁多多指点。推荐阅读:终于有人把 【移动开发】 从基础到实战的全套视频弄全了二、基本流程描述BaseViewBaseView接口定义了可能用到的方法，特别是addSubscribe，...
Retrofit之动态设置Baseurl，并保存在本地。
凯文-杰的博客
09-03 3255
解决需求：只有一个baseurl,且baseurl可以动态配置,配置后可保存也可更新。 前段时间做项目，遇到这样一个需求，APP要求访问的服务主地址可以用户自己配置，且配置过后，还可以手动更新。需求分析一下明白了，就是想动态配置主域名嘛，其余路径不变。刚好项目中我用的又是Retrofit，好吧，明白了，就是想动态配置那个baseurl嘛。配置了肯定要保存，这个简单，就用SharedPrefere...
RetrofitManager
weixin_43897285的博客
05-13 731
public class RetrofitManager { private final String baseUrl; private static RetrofitManager instance; private static OkHttpClient okHttpClient; //静态块 static { getOkHttpC...
Retrofit+RxJava+OkHttp：Android高效网络请求封装与实战指南
1. 基础的Retrofit+RxJava+OkHttp使用方法，简化了开发者的工作流程。 2. 统一的数据格式处理，确保了请求和响应的一致性。 3. 提供了统一的进度指示器和回调处理，提高用户体验。 4. 取消请求功能，方便在需要时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值