Rxjava结合Retrofit

原创 于 2021-02-02 15:27:31 发布 · 219 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络 #android

本文介绍如何使用Retrofit实现网络请求，包括依赖引入、API接口编写、请求响应处理及异常管理等内容。

1、引入依赖

implementation 'com.squareup.retrofit2:retrofit:2.1.0'
implementation 'com.squareup.okhttp3:okhttp:3.4.1'
implementation 'com.squareup.okhttp3:logging-interceptor:3.3.1'
implementation 'com.squareup.retrofit2:converter-gson:2.1.0'
implementation 'io.reactivex.rxjava2:rxjava:2.2.10'
implementation 'io.reactivex.rxjava2:rxandroid:2.1.1'
implementation 'com.squareup.retrofit2:adapter-rxjava2:2.6.0'
implementation 'com.squareup.retrofit2:converter-scalars:2.6.0'

2、编写api接口

public interface AppApi {

    //用户登录
    @POST("/app/checkLogin")
    Observable<BaseResponse<LoginResponse>> pswLogin(@Body RequestBody requestBody);

    // 获取首页饼状图，在线设备状态
    @POST("/app/getDeviceStatusChart")
    Observable<BaseResponse<DeviceStatusResponse>> getDeviceStatusChart(@Body Map<String, String> request);


    //    POST /app/alarm/getDataHisAlarmList
//            获取历史告警列表
    @POST("/app/getAlarmList")
    Observable<BaseResponse<JSONObject>> getDeviceAlarmList(@Body SearchAlarm searchAlarm);

    // 获取视频设备列表
    @POST("/app/deviceVideo/getVideoList")
    Observable<BaseResponse<List<DeviceVideoResponse>>> getDeviceVideoList(@Body DeviceListRequest request);
    @POST("app/storeTimeInterval")
    Observable<BaseResponse<JSONObject>> appStoreTimeInterval(@Query("organizeIds") String organizeIds,@Query("interval") String interval);
    //视频设备  基本信息
    @POST("/app/deviceVideo/getDeviceVideo")
    Observable<BaseResponse<DeviceVideoInfoResponse>> getDeviceVideo(@Body Map<String, String> request);
    @Multipart
    //文件上传
    @POST("app/uploadVoiceAudio")
    Observable<BaseResponse<JSONObject>> uploadVoiceAudio(@Part MultipartBody.Part voiceAudio,@Query("oIds") String oIds,@Query("count") int count);

}

代理api接口RetrofitClient

public class RetrofitClient {
    private static final RetrofitClient mInstance = new RetrofitClient();
    private static final String TAG ="RetrofitClient" ;
    private AppApi mAppApi;
    public String s ;
    private String mCookie;
    public static RetrofitClient getInstance() {
        return mInstance;
    }
    private RetrofitClient() {
    }
    public AppApi getAppApi() {

        Log.d(TAG, "getAppApi: "+IConstantImpl.BASE_URL);
        OkHttpClient okHttpClient = new OkHttpClient.Builder()
                .retryOnConnectionFailure(true)
                .connectTimeout(20, TimeUnit.SECONDS)
                .readTimeout(20, TimeUnit.SECONDS)
                .writeTimeout(20, TimeUnit.SECONDS)
                .addInterceptor(sLoggingInterceptor)
                .build();

        Retrofit retrofit = new Retrofit.Builder()
                .client(okHttpClient)
                .baseUrl(IConstantImpl.BASE_URL)
               .addConverterFactory(ResponseConverterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .addConverterFactory(ScalarsConverterFactory.create())
                .build();

        if (mAppApi == null) {
            mAppApi = retrofit.create(AppApi.class);
        }
        return mAppApi;
    }

    /**
     * 打印返回的json数据拦截器
     */
    private static final Interceptor sLoggingInterceptor = new Interceptor() {

        @Override
        public Response intercept(Chain chain) throws IOException {
            final Request request = chain.request();
            Buffer requestBuffer = new Buffer();
            if (request.body() != null) {
                request.body().writeTo(requestBuffer);
            } else {
                Log.d("LogTAG", "request.body() == null");
            }
            //打印url信息
            Log.w("LogTAG",request.url() + (request.body() != null ? "?" + _parseParams(request.body(), requestBuffer) : ""));
            Response response = chain.proceed(request);
            /** DEBUG STUFF */

            //I am logging the response body in debug mode. When I do this I consume the response (OKHttp only lets you do this once) so i have re-build a new one using the cached body
            String bodyString = response.body().string();
            System.out.println(String.format("Sending request %s with headers %s ", request.url(), request.headers()));
            System.out.println(String.format("Got response HTTP %s %s \n\n with body %s \n\n ", response.code(), response.message(), bodyString));
            response = response.newBuilder().body(ResponseBody.create(response.body().contentType(), bodyString)).build();

            return response;
        }
    };

    @NonNull
    private static String _parseParams(RequestBody body, Buffer requestBuffer) throws UnsupportedEncodingException {
        if (body.contentType() != null && !body.contentType().toString().contains("multipart")) {
            return URLDecoder.decode(requestBuffer.readUtf8(), "UTF-8");
        }
        return "null";
    }
}

线程调度

public class SchedulersCompat {

    public static <T> ObservableTransformer<T, T> defaultSchedulers() {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(Observable<T> upstream) {
                return upstream.subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread());
            }
        };
    }


}

使用

public class DataManager {
    private static DataManager sInstance = new DataManager();

    private static AppApi mAppApi;
    private  String TAG="DEBUGDataManager";
    private Map<String,String> mDeviceSerialVerifyCodeMap = new HashMap<String,String>();
    public static DataManager getsInstance() {
        if (mAppApi == null) {
            mAppApi = RetrofitClient.getInstance().getAppApi();
        }

        return sInstance;
    }

    public Observable<BaseResponse<com.alibaba.fastjson.JSONObject>> appDelThresholds(String texts)
    {
        return mAppApi.appDelThresholds(texts).compose(SchedulersCompat.<BaseResponse<com.alibaba.fastjson.JSONObject>>defaultSchedulers());
    }

转换器工厂

public class ResponseConverterFactory extends Converter.Factory {

    public static ResponseConverterFactory create() {
        return create(new Gson());
    }


    public static ResponseConverterFactory create(Gson gson) {
        return new ResponseConverterFactory(gson);
    }

    private final Gson gson;

    private ResponseConverterFactory(Gson gson) {
        if (gson == null) throw new NullPointerException("gson == null");
        this.gson = gson;
    }

    @Override
    public Converter<ResponseBody, ?> responseBodyConverter(Type type, Annotation[] annotations, Retrofit retrofit) {
        //返回我们自定义的Gson响应体变换器
        return new GsonResponseBodyConverter<>(gson, type);
    }



}

转换器

public class GsonResponseBodyConverter<T> implements Converter<ResponseBody, T> {

    private final Gson gson;
    private final Type type;


    public GsonResponseBodyConverter(Gson gson, Type type) {
        this.gson = gson;
        this.type = type;
    }

    @Override
    public T convert(ResponseBody value) throws IOException {

        String response = value.string();
        //先将返回的json数据解析到Response中，如果code==200，则解析到我们的实体基类中，否则抛异常
        Response httpResponse = gson.fromJson(response, Response.class);
        if (httpResponse.getCode() == 200) {
            //正确的时候就直接解析，不可能出现解析异常。因为我们实体基类中传入的泛型，就是数据成功时候的格式
            return gson.fromJson(response, type);
        } else {
            //抛一个自定义ResultException
            throw new ResultException(httpResponse.getCode(), httpResponse.getMsg());
        }
    }
}

Response实体类

public class Response {
    private int code;
    private String msg;



    public int getCode() {
        return code;
    }

    public void setCode(int code) {
        this.code = code;
    }

    public String getMsg() {
        return msg;
    }

    public void setMsg(String msg) {
        this.msg = msg;
    }
}

自定义异常

public class ResultException extends RuntimeException {
    private int errCode;
    private String msg;

    public ResultException(int errCode, String msg) {
        super();
        this.errCode = errCode;
        this.msg = msg;
    }
    public int getErrCode() {
        return errCode;
    }

    public String getMsg() {
        return msg;
    }

    @Override
    public String toString() {
        return msg;
    }

    @Override
    public String getMessage() {
        return msg;
    }
}

观察者

public abstract class BaseSubscriber<T extends BaseResponse> implements Observer<T> {

    private static final String TAG = "BaseSubscriber";

    @Override
    public void onSubscribe(Disposable d) {

    }

    @Override
    public void onNext(T t) {

        onSuccess(t);
    }

    @Override
    public void onError(Throwable e) {
        Log.d(TAG, "onError: ");
        if (e.toString().equals("该账户不存在")) {
            ActivityUtils.startActivity(LoginActivity.class);
        }
        LogUtils.w("网络异常： " + e.toString());
        if (!NetUtils.isNetworkConnected(BaseApplication.getContext())) {
            onFail("请打开手机网络");
        } else if (e instanceof SocketTimeoutException || e instanceof TimeoutException) {
            onFail("网络请求超时，请检查您的网络状态");
        } else if (e instanceof ConnectException) {
            onFail("请求中断，请检查您的网络状态");
        } else if (e instanceof ResultException) {

            LogUtils.w("error == code!=200 code == " + ((ResultException) e).getErrCode());
            if (((ResultException) e).getErrCode() == 421) {
                ActivityUtils.startActivity(LoginActivity.class);
                BaseTimer.getInstans().killTimer();
                return;
            }
            if (((ResultException) e).getErrCode() == 401) {
                ActivityUtils.startActivity(LoginActivity.class);
                return;
            }
            onFail(((ResultException) e).getMsg());
        } else {
            onFail("" + e.getMessage());
        }
    }

    @Override
    public void onComplete() {

    }


    public abstract void onFail(String errorMsg);

    public abstract void onSuccess(T t);
}

网络状态工具类

public class NetUtils {

    public static enum NetType {
        WIFI, CMNET, CMWAP, NONE
    }

    public static boolean isNetworkAvailable(Context context) {
        ConnectivityManager mgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo[] info = mgr.getAllNetworkInfo();
        if (info != null) {
            for (int i = 0; i < info.length; i++) {
                if (info[i].getState() == NetworkInfo.State.CONNECTED) {
                    return true;
                }
            }
        }
        return false;
    }

    public static boolean isNetworkConnected(Context context) {
        try {

            if (context != null) {
                ConnectivityManager mConnectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
                NetworkInfo mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
                if (mNetworkInfo != null) {
                    return mNetworkInfo.isAvailable();
                }
            }
        } catch (Exception e) {
            LogUtils.w(e.toString());
            return false;
        }
        return false;
    }

    public static boolean isWifiConnected(Context context) {
        if (context != null) {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mWiFiNetworkInfo = mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
            if (mWiFiNetworkInfo != null) {
                return mWiFiNetworkInfo.isAvailable();
            }
        }
        return false;
    }

    public static boolean isMobileConnected(Context context) {
        if (context != null) {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mMobileNetworkInfo = mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
            if (mMobileNetworkInfo != null) {
                return mMobileNetworkInfo.isAvailable();
            }
        }
        return false;
    }

    public static int getConnectedType(Context context) {
        if (context != null) {
            ConnectivityManager mConnectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mNetworkInfo = mConnectivityManager.getActiveNetworkInfo();
            if (mNetworkInfo != null && mNetworkInfo.isAvailable()) {
                return mNetworkInfo.getType();
            }
        }
        return -1;
    }

    public static NetType getAPNType(Context context) {
        ConnectivityManager connMgr = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
        if (networkInfo == null) {
            return NetType.NONE;
        }
        int nType = networkInfo.getType();

        if (nType == ConnectivityManager.TYPE_MOBILE) {
            if (networkInfo.getExtraInfo().toLowerCase(Locale.getDefault()).equals("cmnet")) {
                return NetType.CMNET;
            } else {
                return NetType.CMWAP;
            }
        } else if (nType == ConnectivityManager.TYPE_WIFI) {
            return NetType.WIFI;
        }
        return NetType.NONE;
    }
}
Rxjava_Retrofit配合使用
11-28
快速掌握 Rxjava_Retrofit配合使用 本想免费 但资源分没有0分唉
Android-RxJava和Retrofit结合使用完成基本的登录和注册功能
08-13
RxJava 和 Retrofit 结合使用完成基本的登录和注册功能
RxJava+Retrofit你值得拥有
11-25
RxJava+Retrofit你值得拥有： 1.网络请求带缓存 2.可取消网络请求 3.加载时显示圆形进度条,加载完毕后移除 4.简单的封装
RxJava系列之配合Retrofit
吓成一坨兔子
01-06 507
Retrofit retrofit是网络封装库，内部网络请求交由OkHttp来做的。本文中使用RxJava+Retrofit实现下面这样的需求： 需求： 1.请求服务器注册操作 2.注册完成之后，更新注册UI 3.马上去登录服务器操作 4.登录完成之后，更新登录的UI 定义网络请求接口 public interface IRequestNetwork { // 请求注册 功能 tod...
RxJava+Retrofit使用
黄孝果的博客
06-05 737
引用 api 'com.alibaba:fastjson:1.2.70' api 'androidx.lifecycle:lifecycle-extensions:2.2.0' //rxbinding导入,已经包含rxjava和rxandroid，rxbinding-core是核心，其他只是效果上的辅助 api 'com.jakewharton.rxbinding4:rxbinding-core:4.0.0' api 'com.jakewharton.rxbinding4:rx.
RxJava整合Retrofit2.0网络框架
12-07
在实际项目中，还可以结合其他RxJava操作符，如`map`、`filter`、`concatMap`等，进行更复杂的数据转换和操作。例如，可以使用`map`将原始响应转换为自定义的模型类，或者使用`retry`来重试失败的请求。 总的来说，...
RxJava与Retrofit结合使用案例
11-09
RxJava与Retrofit结合使用是Android开发中一种高效、灵活的网络请求处理方式。RxJava是一个响应式编程库，它允许开发者通过观察者模式来处理异步数据流，而Retrofit则是一个简洁的HTTP客户端库，用于将网络接口转换...
RxJava+Retrofit+OkHttp实现多文件下载之断点续传
08-28
断点续传下载一直是移动开发中必不可少的一项重要的技术，通过RxJava和Retrofit的结合，可以封装一个适合自己的下载框架，简单而且安全！ 知识点1：断点续传下载的重要性 断点续传下载是移动开发中必不可少的一项...
RxJava+Retrofit简单Demo
05-28
在Android开发中，RxJava与Retrofit的结合可以实现优雅的异步网络请求处理。通过Retrofit创建的网络接口，可以返回一个`Observable`对象，然后利用RxJava的操作符对网络请求进行链式操作，如添加缓存策略、处理异常...
rxjava+retrofit+okhttp实现网络请求
12-24
例如，将Retrofit接口与RxJava结合： ```java ApiService service = retrofit.create(ApiService.class); service.getUser(1).subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) ....
Rxjava+ReTrofit+okHttp深入浅出-终极封装三（文件上传）
10-24
在实际运用中上传是一个必不可少的功能，所以我们在封装二的基础上加入上传的功能，同时需要附带上传进度，结合rxjava使用；原理和封装方法 http://blog.csdn.net/wzgiceman/article/details/51939574
RxJava + Retrofit2 基本使用实例详解（附源码 效果图）
01-20
效果图：控制台输出 在AndroidManifext.xml 两个地方设置权限 步骤三 File – Settings – Plugins – 右侧 MarketPlace 搜索安装 GsonFormat 插件 如果你网络不太顺畅，先访问网址自己下载：官网GsonFormat插件下载 下载好 Jar 包之后 在原来Android Studio 的 Plugins页面上选择 Install Plugins From Disk , 再选择你下载好的jar包即可 步骤四：项目结构，较简单，下面逐一介绍各个文件 Transalation.java ① 先访问项目用到的翻译 api
Rxjava配合Retrofit
qq_35932326的博客
03-21 786
Rxjava配合Retrofit doOnNext()可以在不订阅的情况下更新UI。 实例 一步实现注册 – 更新UI – 登录 RetrofitClient.createRetrofit().create(ApiService::class.java) .register("6784321dfwed","1234567","1234567") //上游子线程执行下...
Rxjava+Retrofit
weixin_45697390的博客
05-26 1053
Rxjava异步线程 所需依赖 //Rxjava implementation 'io.reactivex.rxjava2:rxjava:2.2.6' implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' //okhttp3 implementation 'com.squareup.okhttp3:okhttp:3.11.0' //日志 implementation 'com.squareup.okhttp3:logging-interceptor:3
Retrofit+Rxjava的完美结合
林枕祥的博客
12-30 2303
前两篇文章给大家讲解了下关于Retrofit的一些基本使用：        Retrofit进阶之路（一）关于网络service      在这篇文章里我们一起来看下Retrofit结合Rxjava后的神奇效果   1、关于Rxjava        Rxjava在 GitHub 主页上的自我介绍是 "a library for composing asynchronous
Retrofit与RxJava的结合使用
灵魂的世界
11-17 712
前面我已经介绍过了RxJava的使用，现在我们来学习Retrofit的简单使用 Retrofit是一个当前很流行的网络请求库, 官网的介绍是: "Type-safe HTTP client for Android and Java". 本文介绍Retrofit的使用. 先介绍单独使用Retrofit进行网络请求, 后面主要介绍和RxJava结合的请求, 有实例代码. 在使用Retrofi
RxJava 与 Retrofit 结合使用，史上最牛搭档
Tomasyb的博客
06-09 716
在这个列子里,只介绍RxJava和Retrofit的简单初级配合使用，最懒，意思就是说，你完全可以看着我的列子，不用管原理，直接套用就行,而这里没有对其封装，原生态的使用方法实现需求 就做一简单的网络请求 。点击请求打印json数据 一、配置 依赖 compile 'com.squareup.retrofit2:retrofit:2.1.0' compile 'io.reactiv
RxJava和Retrofit结合使用
Huang_wen_huan的博客
11-11 673
首先分别对RxJava和Retrofit做一个简单的讲解，让大家有一个初步的印象。  RxJava的最大作用就是异步操作，在很多时候我们需要在不同的线程中来进行操作，最明显的就是加载网络数据然后刷新界面。因为访问网络是耗时的操作，相信大家都回知道要放在子线程里面去做，刷新界面就肯定在主线程里面操作了，这个已经是简单到不能再简单的了。很多人可能会用AsyncTask和Handler和操作，这是完全
使用 RxJava 和 Retrofit 构建网络请求
u012116089的博客
04-27 302
本文介绍了使用Retrofit+RxJava实现网络请求的封装方法。主要包括：1)定义ApiService接口声明请求方法；2)创建HttpManager单例类初始化Retrofit，配置基础URL、超时时间、Gson转换器和RxJava适配器；3)通过CommonInterceptor拦截器实现请求日志打印；4)演示了获取服务器时间的接口调用示例，采用RxJava的线程切换和响应式处理。最后列出了需要引入的相关依赖库，包括Retrofit、RxJava、Gson等组件。该封装方案提供了简洁的API调用方式
RxJava结合Retrofit实战教程
标题中提到的“RxJava与Retrofit 结合”涉及两个流行的Java编程库，它们被广泛应用于Android开发中，用于简化异步编程模型，以及网络请求的处理。下面将详细解释这两个库，以及它们结合使用时的优势。 首先，关于...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值