Retrofit2+Rxjava2请求WebService（修订版）

前言

之前写了一篇文章 Retrofit2+Okhttp3+Rxjava通过SOAP协议请求WebService 通过整合Retrofit，Okhttp，Rxjava来实现WebService的网络访问，但其中还有许多地方不够完善，并没有发挥出Rxjava的强大之处，因此在这里通过完善封装，加入网络请求的取消，避免内存泄漏，使之更加简洁，方便使用。
这里只呈现出修改变动的部分，不太明白的话可以先看之前的文章。

依赖

Rxjava使用2.0的（之前使用1.0）

    compile 'io.reactivex.rxjava2:rxjava:2.1.0'
    compile 'io.reactivex.rxjava2:rxandroid:2.0.1'

新增Rxjava与Retrofit的适配器（Square官方提供的适配器目前仅支持Rxjava1）

compile 'com.jakewharton.retrofit:retrofit2-rxjava2-adapter:1.0.0'

内容

1.ServiceStore请求接口
使用了Rxjava与Retrofit的适配器，因此，返回类型变为Observable

public interface ServiceStore {
    
    @Headers({
            "Content-Type: text/xml; charset=utf-8",
            "SOAPAction: http://tempuri.org/NewsInquiry"
    })
    @POST("WebServices/EhomeWebservice.asmx")
    Observable getNews(@retrofit2.http.Body String str);

    @GET
    Observable download(@Url String fileUrl);

    @GET("http://gank.io/api/data/{type}/{pageSize}/{pageIndex}")
    Observable getInfo(@Path("type") String type, @Path("pageSize") String pageSize, @Path("pageIndex") String pageIndex);
}

2.RequestManager请求管理者
移除execute()和doRequest()方法，对Retrofit进行初始化配置，ServiceStore的创建移到RequestManager初始化，这就意味着所有的请求接口都要写在ServiceStore内。

public class RequestManager {
    public final static int CONNECT_TIMEOUT = 10;
    public final static int READ_TIMEOUT = 20;
    public final static int WRITE_TIMEOUT = 10;
    public Retrofit mRetrofit;
    private static RequestManager mRequestManager;//管理者实例
    public OkHttpClient mClient;//OkHttpClient实例
    public ServiceStore mServiceStore;//请求接口
    private RequestManager() {
        init();
    }
    //单例模式，对提供管理者实例
    public static RequestManager getInstance() {
        if (mRequestManager == null) {
            synchronized (RequestManager.class) {
                if (mRequestManager == null) {
                    mRequestManager = new RequestManager();
                }
            }
        }
        return mRequestManager;
    }
    private void init(){
        Strategy strategy = new AnnotationStrategy();
        Serializer serializer = new Persister(strategy);
        OkHttpClient.Builder builder = new OkHttpClient.Builder();
        builder.readTimeout(READ_TIMEOUT, TimeUnit.SECONDS);
        builder.writeTimeout(WRITE_TIMEOUT, TimeUnit.SECONDS);
        builder.connectTimeout(CONNECT_TIMEOUT, TimeUnit.SECONDS);
        builder.retryOnConnectionFailure(true);
        mClient = builder.build();
        mRetrofit = new Retrofit.Builder()
                .baseUrl(Constans.WEBSERVICE_URL)
                .addConverterFactory(ScalarsConverterFactory.create())
                .addConverterFactory(GsonConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .addConverterFactory(SimpleXmlConverterFactory.create(serializer))
                .client(mClient)
                .build();
        mServiceStore=mRetrofit.create(ServiceStore.class);
    }

    public interface onRequestCallBack{
        void onSuccess(String msg);
        void onError(String msg);
    }

}

3.新增ResultObserver类
该类实现Observer接口，对上游事件（请求结果）进行解析，然后通过自定义接口进行数据回调

public class ResultObserver implements Observer {
    private RequestManager.onRequestCallBack callBack;
    public ResultObserver( RequestManager.onRequestCallBack callBack){
        this.callBack=callBack;
    }
    @Override
    public void onSubscribe(@NonNull Disposable d) {

    }
    @Override
    public void onNext(@NonNull ResponseBody responseBody) {

        try {
            String res = responseBody.string();
            if (res == null) {
                callBack.onError("请求发生未知错误");
                return;
            }

            if (res.contains("{") && res.contains("}")) {
                int startIndex = res.indexOf("{");
                int endIndex = res.lastIndexOf("}") + 1;
                String json = res.substring(startIndex, endIndex);
                callBack.onSuccess(json);
            }
        } catch (IOException e) {
            e.printStackTrace();
            callBack.onError(e.toString());
        }
    }

    @Override
    public void onError(@NonNull Throwable e) {
        callBack.onError(e.toString());
    }
    @Override
    public void onComplete() {

    }
}

4.请求参数拼装

public class Node {
    //"<"节点转义
    private static String toStart(String name){
        return "<"+name+">";
    }
    //">"节点转义
    private static String toEnd(String name){
        return "";
    }
    //请求参数拼接
    public static String getRequestParams(String namespace, Map map){
        if(map==null){
            map=new HashMap<>();
        }
        StringBuffer sbf=new StringBuffer();
        sbf.append(Node.toStart("Request"));
        for(Map.Entry entry:map.entrySet()){
            sbf.append(Node.toStart(entry.getKey()));
            sbf.append(entry.getValue());
            sbf.append(Node.toEnd(entry.getKey()));
        }
        sbf.append(Node.toEnd("Request"));
        String str="\n" +
                "  \n" +
                "    \n" +
                "      "+ Constans.USERNAME+"\n" +
                "      "+Constans.PASSWORD+"\n" +
                "    \n" +
                "  \n" +
                "  \n" +
                "    <"+namespace+" xmlns=\"http://tempuri.org/\">\n" +
                "      "+sbf.toString()+"\n" +
                "    \n" +
                "  \n" +
                "";
        return str;
    }
}

5.请求示例
Rxjava2会返回一个 Disposable，它是观察者与被观察者之间的一个开关，调用它的dispose()方法，下游将不会收到发送事件，可以在页面销毁时调用，避免执行更新UI。
CompositeDisposable是Rxjava内置的一个容器，用于保存 Disposable，在页面销毁时候调用它的clear方法即可

CompositeDisposable mCompositeDisposable= new CompositeDisposable();

private void getNews() {
        Map map=new HashMap<>();
        map.put("PageSize",10+"");
        map.put("PageIndex",1+"");
        String request= Node.getRequestParams("NewsInquiry",map);
        Disposable disposable = RequestManager.getInstance()
                .mServiceStore
                .getNews(request)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new ResultObserver(new RequestManager.onRequestCallBack() {
                    @Override
                    public void onSuccess(String msg) {
                        tv_msg.setText(msg);
                    }
                    @Override
                    public void onError(String msg) {
                        tv_msg.setText(msg);
                    }
                }));
        mCompositeDisposable.add(imageDisposable);
}
    @Override
    protected void onDestroy() {
        super.onDestroy();
        mCompositeDisposable.clear();
    }

6.点击“网络请求”按钮，结果如图

请求结果