3、RxJava2 & Retrofit2 封装实践 请求与响应的重度封装

最新推荐文章于 2019-10-08 17:37:17 发布
置顶 最新推荐文章于 2019-10-08 17:37:17 发布
阅读量1.4k 收藏
点赞数 1
分类专栏： Rxjava2&Retrofit2封装实践
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010369338/article/details/70809586
版权

东西不多，甚至说很少，目的并不是把网络请求封装的多么好，功能多么全，而是记录下自己的思路。希望无意中路过的同学看完之后能有些许收获！

请求前驱 HTTPServiceWrapper
响应后驱 HTTPCallbackWrapper

1、HTTPCENTER

因为HTTPServiceWrapper的出现，HTTPCENTER又要增加东西了～

    /**
     * 获取ServiceWrapper单例
     * @return
     */
    public static HTTPServiceWrapper getWrapper() {
        return ServiceWrapperHoler.serviceWrapper;
    }

    private static class ServiceWrapperHoler {
        static HTTPServiceWrapper serviceWrapper = new HTTPServiceWrapper();
    }

2、HTTPServiceWrapper

请求前驱：我乱叫的。

代码

/**
 * @author Lwang
 * @time 2017/4/26.
 */

public class HTTPServiceWrapper {
    public static HTTPService dmService = HTTPCenter.getService(HTTPCenter.SERVICE);
    public static HTTPService toyService = HTTPCenter.getService(HTTPCenter.TOYS_SERVICE);
    public void heart(HTTPCallbackWrapper<Heart,DMResponse> httpCallbackWrapper) {
        dmService.heart().map(new Function<Heart, Heart>() {
            @Override
            public Heart apply(@NonNull Heart heart) throws Exception {
                return heart;
            }
        }).compose(httpCallbackWrapper.transformer()).subscribe(httpCallbackWrapper.get());
    }

    public void toys(int offset,int limit,HTTPCallbackWrapper<TimeLineModel,TOYResponse> httpCallbackWrapper) {
        toyService.requestRecommendTimeLine(offset,limit).map(new Function<TimeLineModel, TimeLineModel>() {
            @Override
            public TimeLineModel apply(@NonNull TimeLineModel timeLineModel) throws Exception {
                /**
                 * 此处还可以取出(例如:登陆信息)另行储存
                 * token
                 * secret
                 */
                return timeLineModel;
            }
        }).compose(httpCallbackWrapper.transformer()).subscribe(httpCallbackWrapper.get());
    }
}

把请求时候需要做的琐碎的操作放在了这个包装类里，发送请求时，只需调用HTTPServiceWrapper中的方法即可。

例如:HTTPCenter.getWrapper().toys(0,20,httpCallbackWrapper);

3、HTTPCallbackWrapper 敲黑板！重点！

响应后驱 : 我乱叫的，同时也是重点！
既然是包装类，那么肯定就会有HTTPCallback，否则包装什么？

/**
 * @author Lwang
 * @time 2017/4/26.
 */

public class HTTPCallBack<T, M> {
    /**
     * 请求开始
     */
    public void onStart() {
    }

    public void onSuccess(T success) {
    }

    /**
     * 处理由服务器发起的错误
     * 401
     * 500 ...
     *
     * @param httpResponse
     */
    public void onFail(M httpResponse) {
    };

    /**
     * 处理异常
     *
     * @param e
     */
    public void onError(Throwable e) {
    };
}
HTTPCallback的泛型

HTTPCallback有两个泛型<T,M>
T为请求成功的泛型。
M为出现错误时的泛型。(为了适应多个Host的情况)

HTTPCallbackWrapper代码

/**
 * @author Lwang
 * @time 2017/4/26.
 */

public class HTTPCallbackWrapper<T, M> {
    private RxAppCompatActivity activity;
    private RxFragment fragment;
    private HTTPCallBack<T, M> callBack;
    private Class clazz;
    protected Gson gson = new Gson();

    public HTTPCallbackWrapper(RxAppCompatActivity activity, HTTPCallBack<T, M> callBack) {
        this.activity = activity;
        this.callBack = callBack;
    }

    public HTTPCallbackWrapper(RxFragment fragment, HTTPCallBack<T, M> callBack) {
        this.fragment = fragment;
        this.callBack = callBack;
    }

    public Observer get() {
        return new Observer<T>() {

            @Override
            public void onError(Throwable e) {
                try {
                    if (callBack != null && e != null) {
                        if (e instanceof HttpException) {
                            int errorCode = ((HttpException) e).response().code();
                            switch (errorCode) {
                                case 401:
                                    M response = gson.fromJson("",getClz());
                                    callBack.onFail(response);
                                    break;
                                case 500:
                                    break;
                                default:
                            }
                        } else {
                            //error
                            callBack.onError(e);
                        }
                    } else {
                        //error
                        if (callBack != null)
                            callBack.onError(e);
                    }
                } catch (Exception e1) {
                    //error
                    if (callBack != null)
                        callBack.onError(e);
                }
            }

            @Override
            public void onComplete() {

            }


            @Override
            public void onSubscribe(Disposable d) {
                if (callBack != null)
                    callBack.onStart();
            }

            @Override
            public void onNext(T o) {
                if (callBack != null)
                    callBack.onSuccess(o);
            }
        };
    }

    public <T> ObservableTransformer<T, T> transformer() {
        do {

            if (activity != null) {
                return getObservableTransformer(activity);
            }
            if (fragment != null) {
                return getObservableTransformer(fragment);
            }

        } while (false);
        return null;
    }

    @android.support.annotation.NonNull
    private <T> ObservableTransformer<T, T> getObservableTransformer(RxAppCompatActivity rxAct) {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(@NonNull Observable<T> upstream) {
                return upstream.subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .compose(rxAct.bindToLifecycle());
            }
        };
    }

    @android.support.annotation.NonNull
    private <T> ObservableTransformer<T, T> getObservableTransformer(RxFragment rxFragment) {
        return new ObservableTransformer<T, T>() {
            @Override
            public ObservableSource<T> apply(@NonNull Observable<T> upstream) {
                return upstream.subscribeOn(Schedulers.io())
                        .observeOn(AndroidSchedulers.mainThread())
                        .compose(rxFragment.bindToLifecycle());
            }
        };
    }

    /**
     * 通过反射拿到泛型 class
     */
    @SuppressWarnings("unchecked")
    public Class<M> getClz() {
        if (clazz == null) {
            clazz = (Class<M>) (((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
        }
        return clazz;
    }

}
构造函数中的RxAppCompatActivity和RxFragment
为了支持绑定`RxLifecycle`所以在初始化的时候必须传递进来。
get函数
    封装了`RxJava`中的被观察者，在`onError`中处理了服务器发出的错误，和`RxJava`抛出的`Throwable`；

前面说到了`HTTPCallbackWrapper`的两个泛型。重点在`M`。 

```
M response = gson.fromJson("", getClz());
```
怎么让onFail返回多种对象呢？
    之前我想多个类实现一个接口，之后让`onFail`的参数为此接口，后来想到，如果这样做，调用`onFail`的时候得到的是接口对象，还需要根据`host`来确定对象类型，这样就违背了我的初衷。

所以我想到了继续用泛型，用泛型就涉及到一个问题。
怎么得到泛型的class？
完美解决问题，感兴趣的同学可以查一下反射相关的。

    /**
     * 通过反射拿到泛型 class
     */
    @SuppressWarnings("unchecked")
    public Class<M> getClz() {
        if (clazz == null) {
            clazz = (Class<M>) (((ParameterizedType) this.getClass().getGenericSuperclass()).getActualTypeArguments()[0]);
        }
        return clazz;
    }
封装RxJava的转换ObservableTransformer（transformer函数）

线程切换和RxLifecycle的绑定生命周期每次都会出镜，当然要封装起来啦，我还能怎么办。。。

配合MVP食用,口感更佳哦～

深成
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Retrofit单例封装工具类
BOKE1的博客
11-06 1263
import android.util.Log; import java.util.concurrent.TimeUnit; import okhttp3.OkHttpClient; import okhttp3.logging.HttpLoggingInterceptor; import retrofit2.Retrofit; import retrofit2.converter.gson.
Retrofit2的简单应用与封装
03-20
介绍Retrofit2的使用方法并进行了封装，代码包括客户端和服务器两部分，博客地址：http://blog.csdn.net/gesanri/article/details/50938275
Android RxJava2+Retrofit2搭建网络请求框架
丶巴黎塔、上的星空╮
09-19 1038
前言 之前做网络请求，用的是android-async-http，基于HttpClient 的，虽然早已淘汰，但一直懒得换，前一段时间看了stormzhang的《2016 Android Top 10 Library》文章，提到RxJava+Retrofit 是完美搭配，所以下定决定重构一下现在的项目 网上查了一些资料，遇到了一些小坎坷，终于搞定了，因为网上查到的一些文章大多都是半年以前的，而
Android实战——Retrofit2的使用和封装
点击置顶文章查看博客目录（全站式导航）
11-08 9015
Retrofit2的使用和封装 本篇文章包含以下内容： Retrofit2是什么 Retrofit2工具类的演示（基于Retrofit2工具类的封装） Retrofit2工具类的封装 Retrofit2是什么使用项目的原话：Android和Java中类型安全的HTTP客户端 项目地址：https://github.com/square/retrofitRetrof
RxJava2+Retrofit2网络请求框架封装及使用
Yyongchao的博客
08-11 1140
最近把RxJava2和Retrofit2学习了一下，并做了一个简单的封装，算是对学习的总结,以及以后的做项目时可以，可以拿来及用。 注意：本篇不说RxJava2 和 Retrofit2的基础使用，只梳理一下封装的步骤，所以适合对RxJava2 和 Retrofit2有一定的了解的 Coder. 先上封装后使用网络请求的代码： ServiceFactory.getService(LoginSe
RxJava+Retrofit2+Okhttp3经典封装demo
08-04
通过研究这个demo，开发者不仅可以学习到如何将RxJava、Retrofit2和Okhttp3集成，还能了解到如何进行网络请求的封装，提升代码的复用性和可读性。这对于理解和掌握现代Android网络编程是非常有帮助的。
RxJava2+Retrofit2实现简单易用的网络请求框架
07-12
在Android开发中，Retrofit2和RxJava2的结合使用已经成为构建高效、可测试和易于管理的网络请求框架的首选方案。本项目"RxJava2+Retrofit2实现简单易用的网络请求框架"（RxEasyHttp）旨在提供一个简洁、强大的网络层...
RxHttp:对RxJava2+Retrofit2+OkHttp3的封装
05-28
RxHttp对RxJava2+Retrofit2+OkHttp3的封装，优雅实现接口请求和文件下载功能简介网络请求（RxRequest）支持监听请求声明周期，如开始结束和网络错误支持多BaseUrl，可针对不同请求重定向支持针对不同请求设置不同...
RxJava2和Retrofit2封装教程（整洁、简单、实用）
08-26
RxJava2和Retrofit2封装教程 RxJava2是 Reactive Extensions 库的第二个版本，提供了对异步编程的支持，使开发者可以更方便地处理异步任务。Retrofit2是一个基于OkHttp的 RESTful API 客户端，提供了简洁、灵活的...
retrofit2、RxJava简单使用总结
Briup-z.changhai
05-21 705
需要引入的依赖包括: compile 'com.squareup.retrofit2:retrofit:2.0.0' compile 'com.squareup.retrofit2:converter-gson:2.0.0' compile 'com.squareup.okhttp3:okhttp:3.2.0' compile 'com.squareup.okio:okio:1.6.0'
基于Retrofit2+OkHttp封装的Android网络操作库RetrofitClient
三七的博客
06-27 2881
基于Retrofit2+OkHttp封装的Android网络操作库RetrofitClient 本文主要介绍网络库RetrofitClient的使用方法，这个库封装基本的GET、POST、PUT、DELET请求和文件上传下载方法，只需三步，快速集成。
Transformer 在RxJava中的使用
weixin_34009794的博客
07-15 268
Transformer.jpeg Transformer 用途 Transformer，顾名思义是转换器的意思。早在 RxJava1.x 版本就有了Observable.Transformer、Single.Transformer和Completable.Transformer，在2.x版本中变成了ObservableTransformer、SingleTransformer、Completabl...
RxJava1.X升级到RxJava2.X笔记
續寫經典
11-08 7102
简书地址 http://www.jianshu.com/p/2badfbb3a33blibrary依赖变化//1.X compile 'io.reactivex:rxjava:1.2.1' compile 'io.reactivex:rxandroid:1.2.1'//2.X compile 'io.reactivex.rxjava2:rxjava:2.0.0' compile 'io.reacti
rxjava ： compose 与 ObservableTransformer、lift 与 ObservableOperator
火星男孩的分享空间
10-08 2628
compose 与 ObservableTransformer ： //操作被观察者（abstract class Observable<T> implements ObservableSource<T> ） //将源ObservableSource整体转换 //通过对它应用特定的Transformer函数来转换ObservableSource。 //此方法在Obs...
不要打断链式结构：使用 RxJava的 compose() 操作符
Briup-z.changhai
05-19 2309
编辑推荐：稀土掘金，这是一个针对技术开发者的一个应用，你可以在掘金上获取最新最优质的技术干货，不仅仅是Android知识、前端、后端以至于产品和设计都有涉猎，想成为全栈工程师的朋友不要错过！ 原文链接： Don't break the chain: use RxJava's compose() operator 原文作者： Dan Lew 译文出自： 小鄧子的简书
简单上手的Retrofit2+Rxjava2网络请求框架
苹果香蕉哩
11-23 400
一.简单上手的Retrofit网络请求框架Retrofit是Square公司的一个高效率HTTP网络请求开源库,使用它方便简洁 能够更好的帮助我们提高写代码的质量retrofit gitHub项目地址:https://github.com/square/retrofit retrofit 官网地址：http://square.github.io/retrofit/文件配置使用 <uses-pe
RxJava2和Retrofit封装的RetrofitClient2终于来了！
Tamic （大白）
07-17 7289
Tamic : http://blog.csdn.net/sk719887916/article/details/51958010 RxJava1和Retrofit2组合的好用的RetrofitClient笔者去年写了一篇，后续有朋友私信要求升级第二版本，本打算 不维护了，但是很多人要用Rxjava2，所以便进行了支持Rxjava2的升级.
RxJava + Retrofit2.0的项目实战完美封装
07-12 3775
Retrofit 和RxJava已经出来很久了，从去年开始rxjava和retrofit就开始火，所以之前在做项目的时候也用了rxjava和retrofit，今天就介绍一下在项目中如何封装rxjava和retrofit。对于 RxJava 不是很了解的同学推荐你们看这篇文章给 Android 开发者的 RxJava 详解。Retrofit的使用可以看看Android Retrofit 2.0使用。首
java 在观察者模式中使用泛型T
Dream It Possible
05-20 1721
被观察者public class Observable<T> { List<Observer> observers = new ArrayList<Observer>(); boolean changed = false; /** * Adds the specified observer to the list of observers. If it is alrea
RxJava2 + Retrofit2 + OKHttp post请求
最新发布
06-12
使用RxJava2 + Retrofit2 + OKHttp进行POST请求，可以按照以下步骤进行： 1. 添加依赖 在项目的build.gradle文件中添加以下依赖： ``` dependencies { implementation 'io.reactivex.rxjava2:rxjava:2.2.19' implementation 'io.reactivex.rxjava2:rxandroid:2.1.1' implementation 'com.squareup.retrofit2:retrofit:2.9.0' implementation 'com.squareup.retrofit2:converter-gson:2.9.0' implementation 'com.squareup.okhttp3:okhttp:4.9.1' } ``` 2. 创建Service接口 创建一个接口，用于定义POST请求的方法。例如： ``` public interface ApiService { @POST("login") Observable<LoginResponse> login(@Body LoginRequest request); } ``` 3. 创建Retrofit对象 在Application类或其他初始化类中，创建Retrofit对象： ``` public class MyApp extends Application { private static ApiService apiService; @Override public void onCreate() { super.onCreate(); // 创建OkHttpClient对象 OkHttpClient client = new OkHttpClient.Builder() .connectTimeout(10, TimeUnit.SECONDS) .readTimeout(10, TimeUnit.SECONDS) .writeTimeout(10, TimeUnit.SECONDS) .build(); // 创建Retrofit对象 Retrofit retrofit = new Retrofit.Builder() .baseUrl("http://example.com/api/") .client(client) .addConverterFactory(GsonConverterFactory.create()) .addCallAdapterFactory(RxJava2CallAdapterFactory.create()) .build(); apiService = retrofit.create(ApiService.class); } public static ApiService getApiService() { return apiService; } } ``` 4. 发起POST请求 在需要发起POST请求的地方，可以使用以下代码： ``` LoginRequest request = new LoginRequest(); request.setUsername("admin"); request.setPassword("123456"); MyApp.getApiService().login(request) .subscribeOn(Schedulers.io()) .observeOn(AndroidSchedulers.mainThread()) .subscribe(new Observer<LoginResponse>() { @Override public void onSubscribe(Disposable d) { } @Override public void onNext(LoginResponse response) { // 处理响应数据 } @Override public void onError(Throwable e) { // 处理异常 } @Override public void onComplete() { } }); ``` 上述代码中，我们首先创建了一个LoginRequest对象，用于存储要发送的数据。然后调用MyApp.getApiService().login(request)方法，发起POST请求。在这里，我们使用了RxJava2的Observable对象，将请求结果封装为一个可观察对象。使用subscribeOn(Schedulers.io())指定在IO线程中进行网络请求，使用observeOn(AndroidSchedulers.mainThread())指定在主线程中处理响应。最后通过subscribe方法订阅请求结果，处理响应数据或异常。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值