Rxjava+Retrofit框架的封装

1. 添加相关的依赖和权限

依赖

implementation 'com.squareup.retrofit2:retrofit:2.5.0'
    //retrofit添加Json解析返回数据
implementation 'com.squareup.retrofit2:converter-gson:2.5.0'
implementation 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0'
//防止rxjava引发的内存泄漏
implementation 'com.trello.rxlifecycle2:rxlifecycle-components:2.1.0'

网络权限

 <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
    <uses-permission android:name="android.permission.INTERNET"/>

2. Retrofit基本使用

创建请求接口

public interface ApiUrl {
    //get请求
    @GET(Constans.retrofit)
    Call<Bean> getRetrofit();
}

进行网络请求，此处就省略bean类和常量的创建了

 Retrofit retrofit = new Retrofit.Builder()
                .baseUrl(Constans.BaseUrl)
                //添加GSON解析
                .addConverterFactory(GsonConverterFactory.create())
                .build();
        ApiUrl api = retrofit.create(ApiUrl.class);
        Call<Bean> demo = api.getRetrofit();
        demo.enqueue(new Callback<Bean>() {
            @Override
            public void onResponse(Call<Bean> call, Response<Bean> response) {
                Log.e(TAG, "请求成功信息: "+response.body().toString());
            }
            @Override
            public void onFailure(Call<Bean> call, Throwable t) {
                Log.e(TAG, "请求失败信息: " +t.getMessage());
            }
        });

3. OkHttpClient的自定义

   OkHttpClient client = new OkHttpClient().newBuilder()
            .readTimeout(Constans.DEFAULT_TIME, TimeUnit.SECONDS)//设置读取超时时间
            .connectTimeout(Constans.DEFAULT_TIME, TimeUnit.SECONDS)//设置请求超时时间
            .writeTimeout(Constans.DEFAULT_TIME,TimeUnit.SECONDS)//设置写入超时时间
            .retryOnConnectionFailure(true)//设置出现错误进行重新连接。
            .build();
    Retrofit retrofit = new Retrofit.Builder()
            //设置自定义okHttp
            .client(client)
            .baseUrl(Constans.BaseUrl)
            //添加GSON解析
            .addConverterFactory(GsonConverterFactory.create())
            .build();

4. 进入正题，Retrofit 与 Rxjava 结合使用

设置Retrofit

Retrofit retrofit = new Retrofit.Builder()
                .client(client)
                .baseUrl(Constans.BaseUrl)
                //添加GSON解析：返回数据转换成GSON类型
                .addConverterFactory(GsonConverterFactory.create())
                //添加Rxjava支持
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();

请求接口不变

@GET(Constans.retrofit)
Observable<Bean> getRetrofit1();

内存泄露问题
当使用RxJava订阅并执行耗时任务后，当Activity被finish时，如果耗时任务还未完成，没有及时取消订阅，就会导致Activity无法被回收，从而引发内存泄漏。为了解决这个问题，就产生了RxLifecycle，让RxJava变得有生命周期感知，使得其能及时取消订阅，避免出现内存泄漏问题
Activity 需继承自 RxAppCompatActivity 或RxFragmentActivity 或 RxActivity，Fragment 需继承 RxFragment

retrofit.create(ApiUrl.class)
                .getRetrofit1()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                //绑定生命周期
                .compose(bindUntilEvent(ActivityEvent.DESTROY))
                .subscribe(new Observer<Bean>() {
                    @Override
                    public void onSubscribe(Disposable d) {
                        Log.e(TAG, "onSubscribe: " );
                    }
                    @Override
                    public void onNext(Bean demo) {
                        Log.e(TAG, "onNext: " +demo.toString());
                    }
                    @Override
                    public void onError(Throwable e) {
                        Log.e(TAG, "Throwable: " + e.getMessage());
                    }
                    @Override
                    public void onComplete() {
                        Log.e(TAG, "onComplete: " );
                    }
                });

好了，基本的使用就到这了，接下来开始进行封装处理

BaseResponse与BaseObserver的封装

BaseResponse就是对基础数据进行封装处理。根据基础数据定义BaseResponse

public class BaseResponse<T> {
    private int res_code;
    private String err_msg;
    private T demo;
    public int getRes_code() {
        return res_code;
    }
    public void setRes_code(int res_code) {
        this.res_code = res_code;
    }
    public String getErr_msg() {
        return err_msg;
    }
    public void setErr_msg(String err_msg) {
        this.err_msg = err_msg;
    }
    public T getDemo() {
        return demo;
    }
    public void setDemo(T demo) {
        this.demo = demo;
    }
}

当然我们需求数据也需重新定义

public class Demo {
    @Override
    public String toString() {
        return "Demo{" + "id='" + id + '\'' +
                ", appid='" + appid + '\'' +
                ", name='" + name + '\'' +
                ", showtype='" + showtype + '\'' +
                '}';
    }
    private String id;
    private String appid;
    private String name;
    private String showtype;
    public String getId() {
        return id;
    }
    public void setId(String id) {
        this.id = id;
    }
    public String getAppid() {
        return appid;
    }
    public void setAppid(String appid) {
        this.appid = appid;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getShowtype() {
        return showtype;
    }
    public void setShowtype(String showtype) {
        this.showtype = showtype;
    }
}

修改API接口返回数据类型

   // 把原先的Bean类分成BaseResponse基础数据与Demo需求数据两个类
    @GET(Constans.retrofit)
    Observable<BaseResponse<Demo>> getRetrofit2();

对基础数据统一处理

/**
 * 创建Base抽象类实现Observer
 */
public abstract class BaseObserver<T> implements Observer<BaseResponse<T>> {
    private static final String TAG = "BaseObserver";
    @Override
    public void onSubscribe(Disposable d) {
        Log.e(TAG, "onSubscribe: " );
    }
    @Override
    public void onNext(BaseResponse<T> response) {
        //在这边对 基础数据 进行统一处理  举个例子：
        if(response.getRes_code()==200){
            onSuccess(response.getDemo());
        }else{
            onFailure(null,response.getErr_msg());
        }
    }
    @Override
    public void onError(Throwable e) {
        Log.e(TAG, "Throwable: " + e.getMessage());
    }

    @Override
    public void onComplete() {
        Log.e(TAG, "onComplete: " );
    }
    public abstract void onSuccess(T demo);
    public abstract void onFailure(Throwable e,String errorMsg);
}

请求网络数据

 retrofit.create(ApiUrl.class)
                .getRetrofit2()
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                //绑定生命周期
                .compose(bindUntilEvent(ActivityEvent.DESTROY))
                .subscribe(new BaseObserver<Demo>(){
                    @Override
                    public void onSuccess(Demo demo) {
                        Log.e(TAG, "onSuccess: "+demo);
                    }
                    @Override
                    public void onFailure(Throwable e, String errorMsg) {
                        Log.e(TAG, "onFailure: "+errorMsg);
                    }
                });

RxHelper调度类封装
RxHelper主要是对执行线程和绑定生命周期几个方法进行封装
大致实现如下：
app builde配置

android {
    .......
    compileOptions {
        targetCompatibility 1.8
        sourceCompatibility 1.8
    }
}

/**
 * 调度类
 */
public class RxHelper {

    public static <T> ObservableTransformer<T, T> observableIO2Main(final Context context) {
        return upstream -> {
            Observable<T> observable = upstream.subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread());
            return composeContext(context, observable);
        };
    }

    public static <T> ObservableTransformer<T, T> observableIO2Main(final RxFragment fragment) {
        return upstream -> upstream.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread()).compose(fragment.<T>bindToLifecycle());
    }

    public static <T> FlowableTransformer<T, T> flowableIO2Main() {
        return upstream -> upstream
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread());
    }

    private static <T> ObservableSource<T> composeContext(Context context, Observable<T> observable) {
        if(context instanceof RxActivity) {
            return observable.compose(((RxActivity) context).bindUntilEvent(ActivityEvent.DESTROY));
        } else if(context instanceof RxFragmentActivity){
            return observable.compose(((RxFragmentActivity) context).bindUntilEvent(ActivityEvent.DESTROY));
        }else if(context instanceof RxAppCompatActivity){
            return observable.compose(((RxAppCompatActivity) context).bindUntilEvent(ActivityEvent.DESTROY));
        }else {
            return observable;
        }
    }
}

使用方式：

对Retrofit进行单例封装

import android.support.annotation.NonNull;
import com.jakewharton.retrofit2.adapter.rxjava2.RxJava2CallAdapterFactory;
import java.util.concurrent.TimeUnit;
import okhttp3.OkHttpClient;
import retrofit2.Retrofit;
import retrofit2.converter.gson.GsonConverterFactory;
/**
 * Retrofit封装
 */
public class RetrofitUtils {
    private static final String TAG = "RetrofitUtils";
    private static ApiUrl mApiUrl;
    /**
     * 单例模式
     */
    public static ApiUrl getApiUrl() {
        if (mApiUrl == null) {
            synchronized (RetrofitUtils.class) {
                if (mApiUrl == null) {
                    mApiUrl = new RetrofitUtils().getRetrofit();
                }
            }
        }
        return mApiUrl;
    }
    private RetrofitUtils(){}

    public ApiUrl getRetrofit() {
        // 初始化Retrofit
        ApiUrl apiUrl = initRetrofit(initOkHttp()) .create(ApiUrl.class);
        return apiUrl;
    }

    /**
     * 初始化Retrofit
     */
    @NonNull
    private Retrofit initRetrofit(OkHttpClient client) {
        return new Retrofit.Builder()
                    .client(client)
                    .baseUrl(Constans.BaseUrl)
                    .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                    .addConverterFactory(GsonConverterFactory.create())
                    .build();
    }

    /**
     * 初始化okhttp
     */
    @NonNull
    private OkHttpClient initOkHttp() {
        return new OkHttpClient().newBuilder()
                    .readTimeout(Constans.DEFAULT_TIME, TimeUnit.SECONDS)//设置读取超时时间
                    .connectTimeout(Constans.DEFAULT_TIME, TimeUnit.SECONDS)//设置请求超时时间
                    .writeTimeout(Constans.DEFAULT_TIME,TimeUnit.SECONDS)//设置写入超时时间
                    .addInterceptor(new LogInterceptor())//添加打印拦截器
                    .retryOnConnectionFailure(true)//设置出现错误进行重新连接。
                    .build();
    }
}

请求接口类

调用

RetrofitUtils.getApiUrl().getDemo()
                .compose(RxHelper.observableIO2Main(this))
                .subscribe(new BaseOberver<Demo>(){
                    @Override
                    public void onSuccess(Demo demo) {
                        Log.e(TAG, "onSuccess: "+demo);
                    }
                    @Override
                    public void onFailure(Throwable e, String errorMsg) {
                        Log.e(TAG, "onFailure: "+errorMsg);
                    }
                });