Retrofit2+Rxjava2网络请求框架的封装

基于Retrofit和Rxjava2的联网框架,建造者模式构建RestClient,请求方法的封装,支持配置加载动画，链式调用。统一请求拿到后台返回的原始数据。

先来看网络请求示例代码

链式调用,简洁明了

     * 请求网络
     *
     * @param view
     */
    public void request(View view) {
        RestClient restClient = RestClient.builder()
                .url("data/Android/10/1")
                .load(this)
//                .params(new WeakHashMap<String, Object>())
                .success(new ISuccess() {
                    @Override
                    public void onSuccess(String response) {

                    }
                })
                .error(new IError() {
                    @Override
                    public void onError(int code, String msg) {

                    }
                })
                .build();
        restClient.request(HttpMethod.GET);
    }
这里写代码片

添加依赖这里用了依赖的统一管理

--------------------
dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    compile rootProject.ext.dependencies.appcompatV7
    implementation rootProject.ext.dependencies.constraintLayout
    compile rootProject.ext.dependencies.design
    compile rootProject.ext.dependencies.cardView
    compile rootProject.ext.dependencies.systembartint
    //Retrofit和Rxjava
    compile rootProject.ext.dependencies.rxjava2
    compile rootProject.ext.dependencies.rxandroid2
    compile rootProject.ext.dependencies.retrofit2
    compile rootProject.ext.dependencies.converterGson
    compile rootProject.ext.dependencies.converterScalars
    compile rootProject.ext.dependencies.adapterRxjava2
    //加载动画
    compile rootProject.ext.dependencies.aviloader
    //okhttp3拦截器
    compile rootProject.ext.dependencies.loggerinterceptor
    testImplementation rootProject.ext.dependencies.junit
    androidTestImplementation rootProject.ext.dependencies.runner
    androidTestImplementation rootProject.ext.dependencies.espresso
}

---

HttpMethod 枚举类定义请求方法

 * Created by kevin321vip on 2017/12/14.
 * 请求方法,枚举类
 */

public enum HttpMethod {
    GET,
    POST,
    POST_RAW,
    PUT,
    PUT_RAW,
    DELETE,
    UPLOAD

这里写代码片

RestService 定义统一的ApiService接口

 * Created by kevin321vip on 2017/12/14.
 * Api接口
 */

public interface RestService {
    @GET
    Observable<String> get(@Url String url, @QueryMap WeakHashMap<String, Object> params);

    @FormUrlEncoded
    @POST
    Observable<String> post(@Url String url, @QueryMap WeakHashMap<String, Object> params);

    @POST
    Observable<String> post(@Url String url, ResponseBody body);

    @FormUrlEncoded
    @PUT
    Observable<String> put(@Url String url, @FieldMap WeakHashMap<String, Object> params);

    @PUT
    Observable<String> putRaw(@Url String url, @Body RequestBody body);

    @DELETE
    Observable<String> delete(@Url String url, @QueryMap WeakHashMap<String, Object> params);

    @Streaming
    @GET
    Observable<ResponseBody> download(@Url String url, @QueryMap WeakHashMap<String, Object> params);
    @Multipart
    @POST
    Observable<String> upload(@Url String url, @Part MultipartBody.Part file);

}
这里写代码片

RestCreatorh（关键类）

**主要的Retroft的初始化配置,以及返回ApiService对象
1、主要是静态内部类Hodler的方式的单例对象获取**
2、.addConverterFactory(ScalarsConverterFactory.create())保证返回的是原始请求数据，方便根据状态等自行做过滤校验相关处理
3、ParamsHodler 单例管理Params多处使用不用重复new对象**

    /**
     * 构建全局的Retrofit客户端
     * .baseUrl(UrlConstance.BaseUrl)
     * .addConverterFactory(GsonConverterFactory.create())
     * http://gank.io/api/data/Android/10/1
     */
    private static final class RetrofitHodler {
        private static final Retrofit RETROFIT_CLIENT = new Retrofit.Builder()
                .client(OkHttpHodler.OK_HTTP_CLIENT)
                .baseUrl("http://gank.io/api/")
                .addConverterFactory(ScalarsConverterFactory.create())
                .addCallAdapterFactory(RxJava2CallAdapterFactory.create())
                .build();
    }

    /**
     * OkhttpHodler
     */
    private static final class OkHttpHodler {
        private static final OkHttpClient OK_HTTP_CLIENT = new OkHttpClient.Builder()
                .connectTimeout(UrlConstance.TimeOut, TimeUnit.SECONDS)
                .build();
    }

    /**
     * RestService
     */
    private static final class RestServiceHodler {
        private static final RestService REST_SERVICE = RetrofitHodler.RETROFIT_CLIENT.create(RestService.class);
    }

    /**
     * Params的Hodler
     */
    private static final class ParamsHodler {
        private static final WeakHashMap<String, Object> PARAMS = new WeakHashMap<>();
    }

    /**
     * 获取参数
     *
     * @return
     */
    public static WeakHashMap<String, Object> getParams() {
        return ParamsHodler.PARAMS;
    }

    /**
     * 获取Service
     */
    public static RestService getService() {
        return RestServiceHodler.REST_SERVICE;
    }
}

这里写代码片

*

RestClient 关键类*

用来发起网络请求,通过Build模式传入请求参数和构建请求体

     * 通过建造者模式传参
     */
    public static RestClientBuilder builder() {
        return new RestClientBuilder();
    }

    /**
     * 发起网络请求
     */
    public void request(HttpMethod method) {
    //得到ApiService对象,通过相应的请求方法给observable实例化 发起请求
        final RestService service = RestCreator.getService();
        Observable<String> observable = null;
        if (REQUEST != null) {
            REQUEST.onRequestStart();
        }
        if (LOADER_STYLE != null) {
            LyonLoader.showLoading(CONTEXT, LOADER_STYLE);
        }
        switch (method) {
            case GET:
                observable = service.get(URL, PARAMS);
                break;
            case POST:
                service.post(URL, PARAMS);
                observable = service.post(URL, PARAMS);
                break;
            case POST_RAW:
//                observable = service.postRaw(URL, BODY);
                break;
            case PUT:
                observable = service.post(URL, PARAMS);
                break;
            case PUT_RAW:
                service.putRaw(URL, BODY);
                break;
            case DELETE:
                observable = service.delete(URL, PARAMS);
                break;
            case UPLOAD:
                final RequestBody requestBody =
        RequestBody.create(MediaType.parse(MultipartBody.FORM.toString()), FILE);
                final MultipartBody.Part body =
                        MultipartBody.Part.createFormData("file", FILE.getName(), requestBody);
                observable = service.upload(URL, body);
                break;
            default:
                break;
        }
        //发起网络请求,并在回调中将请求的数据回调出去
        if (observable != null) {
            observable.subscribeOn(Schedulers.io())
                    .observeOn(AndroidSchedulers.mainThread())
                    .subscribe(new Observer<String>() {
                        @Override
                        public void onSubscribe(Disposable d) {

                        }
                        @Override
                        public void onNext(String s) {
                            if (SUCCESS != null) {
                                SUCCESS.onSuccess(s);
                            }
                            LyonLoader.stopLoading();
                            ToastUtils.show("请求成功" + s);
                        }

                        @Override
                        public void onError(Throwable e) {
                            LyonLoader.stopLoading();
                            if (ERROR != null) {
                                ERROR.onError(0, e.getMessage());
                            }
                            ToastUtils.show("请求失败" + e.getMessage());

                        }

                        @Override
                        public void onComplete() {

                        }
                    });


        }
    }

    /**
     * get方法
     */
    public void get() {
        request(HttpMethod.GET);
    }

    /**
     * post方法
     */
    public void post() {
        request(HttpMethod.POST);
    }
}
**在Retrofit 的联网回调中将请求结果根据传入的回调接口相应的回调出去**

RestClientBuilder 构造器

RestClient的构造器,用于传入联网请求的配置信息,构造Reclient对象

* Created by kevin321vip on 2017/12/14.
* RestClient的构建者
*/

public class RestClientBuilder {
private final WeakHashMap<String, Object> PARAMS = RestCreator.getParams();
private String URL = null;
private IRequest REQUEST = null;
private String DOWNLOAD_DIR = null;
private String EXTENSION = null;
private String NAME = null;
private ISuccess SUCCESS = null;
private IFailure FAILURE = null;
private IError ERROR = null;
private RequestBody BODY = null;
private LoadStyle LOADER_STYLE = null;
private File FILE = null;
private Context CONTEXT = null;

public final RestClientBuilder params(WeakHashMap<String, Object> params) {
PARAMS.putAll(params);
return this;
}

public final RestClientBuilder params(String key, Object value) {
PARAMS.put(key, value);
return this;
}

public final RestClientBuilder url(String url) {
this.URL = url;
return this;
}

public final RestClientBuilder request(IRequest iRequest) {
this.REQUEST = iRequest;
return this;
}

public final RestClientBuilder failure(IFailure iFailure) {
this.FAILURE = iFailure;
return this;
}

public final RestClientBuilder success(ISuccess iSuccess) {
this.SUCCESS = iSuccess;
return this;
}

public final RestClientBuilder error(IError iError) {
this.ERROR = iError;
return this;
}

public final RestClientBuilder dir(String downloaddir) {
this.DOWNLOAD_DIR = downloaddir;
return this;
}

public final RestClientBuilder extension(String extension) {
this.EXTENSION = extension;
return this;
}

public final RestClientBuilder name(String name) {
this.NAME = name;
return this;
}

public final RestClientBuilder body(RequestBody body) {
this.BODY = body;
return this;
}

public final RestClientBuilder LoadStyle(LoadStyle loadStyle) {
this.LOADER_STYLE = loadStyle;
return this;
}

public final RestClientBuilder file(File file) {
this.FILE = file;
return this;
}

public final RestClientBuilder load(Context context, LoadStyle loadStyle) {
this.CONTEXT = context;
this.LOADER_STYLE = loadStyle;
return this;
}

public final RestClientBuilder load(Context context) {
this.CONTEXT = context;
this.LOADER_STYLE = LoadStyle.BallClipRotatePulseIndicator;
return this;
}

public final RestClient build() {
return new RestClient(URL, REQUEST, DOWNLOAD_DIR
, EXTENSION, NAME, SUCCESS, FAILURE, ERROR, BODY, LOADER_STYLE
, FILE, CONTEXT);
}
}

这里写代码片

关于Loader就不介绍了,用了大神的：*com.wang.avi:library:2.1.3 做了一定的封装*
查看完整的代码请移步本人的github：
代码实现
。