RxJava2+Retrofit2+golang

说在前面 本人能力有限，望高手勿喷。

golang

golang语言又叫go语言，是google公司为了适应高并发，兼顾开发效率而开发的一门语言。go语言的语法非常简单，适合做服务器端开发。所以我准备采用golang来做web后台。因为本节重点不是讲解go语言。所以会比较简单的介绍一下。

RxJava

RxJava也使用了很久，一直想记录一些使用过程，但是由于时间问题，一直没有写。RxJava是一种链接风格的编程体验，保证你使用后一定会非常喜欢。之前一直使用的是RxJava1 不过2016年11月份官方出了RxJava2，而且版本1也不会在更新维护了，所以我这里会使用版本2 。

Retrofit

Retrofit是一个网络请求框架，是对okhttp框架的再次封装。提供跟良好的使用体验。我这里采用的是retrofit2。

服务器端

服务器端我使用了go语言的一个框架 gin ,这个框架是两个外国人写的开源框架，用来写api非常方便。

package main

import (
    "blog/src/enity"
    "fmt"
    "github.com/gin-gonic/gin"
)

func main() {
    gin.SetMode(gin.ReleaseMode)
    router := gin.Default()
    router.POST("/", func(c *gin.Context) {
        start := c.PostForm("start")
        count := c.PostForm("count")
        fmt.Println("start: ", start, "  count:", count)
        c.JSON(200, gin.H{
            "code": "201",
            "msg":  "success",
            "data": gin.H{
                "name":    "aa",
                "age":     25,
                "address": "成都",
                "sex":     1},
        })
    })
    router.Run(":8000")
}

该服务器端的接口非常简单，就是获取一个json数据。

APP端

引入依赖

    //rxjava2 和rxAndroid
    compile 'io.reactivex.rxjava2:rxjava:2.1.1'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'
    //retrofit2
    compile 'com.squareup.retrofit2:retrofit:2.3.0'
   // 自动解析json数据为实体的包 
    compile 'com.squareup.retrofit2:converter-gson:2.3.0'
   //retrofit支持转换为Rxjava的包
    compile 'com.squareup.retrofit2:adapter-rxjava2:2.3.0'

   //okhttp
    compile 'com.squareup.okhttp3:okhttp:3.3.0'
    compile 'com.squareup.okio:okio:1.8.0'
    compile 'com.google.code.gson:gson:2.8.1'

rxjava中有一个 Observer类型这个就是一个观察者，也就是一个处理数据的类。还有一个是Observable类，这个类是被观察者类，改类就是产生数据的类。在apiservice接口类中，方法getUser()返回的就是一个被观察者，改类型使用了泛型，也就是我们可以自动解析json数据为我们的实体对象。

新建一个 apiservice接口类

public interface ApiService {
    @Multipart
    @POST("/")
    Observable<BaseResponseDto<User>> getUser(@Part("start") int start, @Part("count") int count);
}

我们使用了result api风格的接口，一般我们接口返回json数据格式为。

{
    code: "200",
    msg: "success",
    data: {

    }
}

所以我们可以对这个数据进行封装。

public class BaseResponseDto<T> {

    private String code;

    private String msg;

    private T data;

    public String getCode() {
        return code;
    }

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

    public String getMsg() {
        return msg;
    }

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

    public T getData() {
        return data;
    }

    public void setData(T data) {
        this.data = data;
    }

    @Override
    public String toString() {
        return "BaseResponseDto{" +
                "code='" + code + '\'' +
                ", mag='" + msg + '\'' +
                ", data=" + data +
                '}';
    }
}

在app端请求网络数据时我们总会处理各种异常问题，比如网络异常，json解析异常等，为了少些异常处理代码，我们需要对这一部分进行封装。我们使用的是RxJava所以我们需要对观察者进行封装。

public abstract  class DefaultObserver<T extends BaseResponseDto> implements Observer<T> {

    private static String TAG="DefaultObserver";
    private Context context;
    private BaseViewImpl baseView;
    private String message="";
    private Disposable disposable;
    public DefaultObserver(Context context){
        this.context=context;
    }
    public DefaultObserver(Context context,BaseViewImpl baseView){
        this.baseView=baseView;
        this.context=context;
    }
    public DefaultObserver(Context context,BaseViewImpl baseView,String message){
        this.baseView=baseView;
        this.message=message;
        this.context=context;
    }
    @Override
    public void onSubscribe(@NonNull Disposable d) {

        Log.i(TAG,"======onSubscribe======");
        disposable=d;
        if(null!=baseView){
            baseView.addDisposable(d);
            baseView.showProgressDialog(message);
        }
    }

    @Override
    public void onNext(@NonNull T response) {
        Log.i(TAG,"======onNext======");
        mainThread();

        if(null!=baseView){
            baseView.removeDisposable(disposable);
            baseView.dismissProgressDialog();
        }else {
            disposable.dispose();
        }
        if(response.getCode().equals("200")){
            onSuccess(response);
        }else{
            onFail(response);
        }

    }

    @Override
    public void onError(@NonNull Throwable e) {
        Log.i(TAG,"======onError======"+e.getMessage());
        if(null !=baseView){
            baseView.removeDisposable(disposable);
            baseView.dismissProgressDialog();
        }else {
            disposable.dispose();
        }

        if (e instanceof HttpException) {     //   HTTP错误
            ToastUtil.showShort(context,"http错误");
        } else if (e instanceof ConnectException
                || e instanceof UnknownHostException) {   //   连接错误
            ToastUtil.showShort(context,"连接错误");
        } else if (e instanceof InterruptedIOException) {   //  连接超时
            ToastUtil.showShort(context,"连接超时");
        } else if (e instanceof JsonParseException
                || e instanceof JSONException
                || e instanceof ParseException) {   //  解析错误
            ToastUtil.showShort(context,"解析错误");
        } else if(e instanceof IOException){
            ToastUtil.showShort(context,"IO错误");
        }else {
            ToastUtil.showShort(context,"未知错误");
        }

    }

    @Override
    public void onComplete() {

    }

    /**
     * 请求成功
     * @param response
     */
    abstract public  void onSuccess(T response);

    /**
     * 请求成功后返回的数据错误
     * @param response
     */
     public void onFail(T response){
         ToastUtil.showShort(context,response.getMsg());
     }

}

这样封装后我们只需要子类实现 onSuccess()方法就可以了，我们只关注成功获取数据。如果想自己根据失败进行相关的操作也可以复写onFail()方法。

最后我们需要把之前封装的这几个类弄到一个网络请求类中，方便外面统一调用。使用创建了一个Htpp类。

public class Http {

    private static final String TAG="Http";

    private static final String BASE_URL="http://127.0.0.1:8000/";

    private static final int DEFAULT_TIMEOUT=5;

    private static Retrofit retrofit;

    private ApiService apiService;

    private Http(){

        Gson gson = new GsonBuilder()
                .setDateFormat("yyyy-MM-dd'T'HH:mm:ssZ")
                .create();//使用 gson coverter，统一日期请求格式

        OkHttpClient.Builder builder=new OkHttpClient.Builder()
                .addInterceptor(new LoggingInterceptor())
                .connectTimeout(DEFAULT_TIMEOUT, TimeUnit.SECONDS);

        retrofit=new Retrofit.Builder()
                     .baseUrl(BASE_URL)
                     .client(builder.build())
                     .addConverterFactory(GsonConverterFactory.create(gson))
                     .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                     .build();
        apiService=retrofit.create(ApiService.class);
    }

    private static  class SignleHolder{
        private static final Http INSTANCE=new Http();
    }

    public static  Http getInstance(){
       return SignleHolder.INSTANCE;
    }


    private class LoggingInterceptor implements Interceptor{

        @Override
        public Response intercept(Chain chain) throws IOException {

            Request request=chain.request();

            Log.i(TAG,String.format("\n request: %s on %s \n %s %s",request.url(),chain.connection(),request.headers(),request.body().contentType()));

            Response response=chain.proceed(request);

            Log.i(TAG,String.format("\n response: %s \n body: %s \n",response.request().url(),""));

            return response;
        }
    }

    public void getUser(DefaultObserver<BaseResponseDto<User>> observer){
        apiService.getUser(0,10)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(observer);
    }
}

这样封装后 外部就可以直接使用htpp类进行调用。

public void testDefaultRxJava(){

        Http.getInstance().getUser(new DefaultObserver<BaseResponseDto<User>>(MainActivity.this,this) {
            @Override
            public void onSuccess(BaseResponseDto<User> response) {
                  Log.i(TAG,"=====onSuccess======"+response.toString());
            }
            @Override
            public void onFail(BaseResponseDto<User> response) {
                super.onFail(response);
            }
        });
    }

这样就轻松实现了RxJava2+Retrofit2 的封装。

小结

参考链接 http://www.jianshu.com/p/9674f6df910d

有疑问加站长微信联系（非本文作者）