RxJava+Retrofit公用请求二次封装

最新推荐文章于 2023-11-28 10:02:08 发布
最新推荐文章于 2023-11-28 10:02:08 发布
阅读量554 收藏
点赞数
分类专栏： 移动开发
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shu_quan/article/details/79975866
版权

添加jar包

compile 'io.reactivex:rxjava:1.1.0'
compile 'io.reactivex:rxandroid:1.1.0'
compile 'com.squareup.retrofit2:retrofit:2.0.2'

请求完毕数据回调接口

 
public interface HttpRequestCallback {
  /**
     * 获取数据
     *
     * @param sequest
     * @param type
     */
    void onResponse(String sequest, String type);

    /**
     * 获取数据失败
     *
     * @param exp
     */
    void onFailure(String exp);
}

共用http二次封装类

public class OkHttpUtils {

    private static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");//post请求编码
    private static OkHttpClient mOkHttpClient;
    private static final MediaType MEDIA_TYPE_PNG = MediaType.parse("image/png");
    public static List<String> cookies = new ArrayList<>();

    /**
     * 获取数据接口
     *
     * @param context 上下文
     * @param action  服务器方法
     */
    public static Observable<String> postAsynHttp(final Context context, final String action, final FormBody.Builder formBody) {
        CheckConnect(context);
        return Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(final Subscriber<? super String> subscriber) {
                mOkHttpClient = new OkHttpClient().newBuilder().readTimeout(10, TimeUnit.SECONDS)//设置读取超时时间
                        .writeTimeout(10, TimeUnit.SECONDS)//设置写的超时时间
                        .connectTimeout(10, TimeUnit.SECONDS)//设置连接超时时间
                        .build();
                MyLog.e(formBody.toString());
                try {
                    Request request = new Request.Builder().url(action).addHeader("cookie", String.valueOf(cookies)).post(formBody.build()).addHeader("cookie", String.valueOf(cookies)).build();
                    final Call call = mOkHttpClient.newCall(request);
                    //excute
                    call.enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {
                            subscriber.onError(e);
                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            String str = response.body().string();
                            if (action.contains("system_login")) {
                                Headers headers = response.headers();
                                cookies = headers.values("Set-Cookie");
                            }
                            subscriber.onNext(str);
                            subscriber.onCompleted();
                        }
                    });
                } catch (IllegalArgumentException e) {
                    subscriber.onError(e);
                }
            }
        });
    }

    /**
     * 获取数据接口
     * Request request = new Request.Builder().url(action).get().build();
     *
     * @param context 上下文
     * @param action  服务器方法
     */
    public static Observable<String> getAsynHttp(final Context context, final String action) {
        CheckConnect(context);
        return Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(final Subscriber<? super String> subscriber) {
                mOkHttpClient = new OkHttpClient().newBuilder().readTimeout(10, TimeUnit.SECONDS)//设置读取超时时间
                        .writeTimeout(10, TimeUnit.SECONDS)//设置写的超时时间
                        .connectTimeout(10, TimeUnit.SECONDS)//设置连接超时时间
                        .build();
                MyLog.e(action.toString());
                try {
                    Request request = new Request.Builder().url(action).addHeader("cookie", String.valueOf(cookies)).get().build();
                    final Call call = mOkHttpClient.newCall(request);
                    //excute
                    call.enqueue(new Callback() {
                        @Override
                        public void onFailure(Call call, IOException e) {
                            subscriber.onError(e);
                        }

                        @Override
                        public void onResponse(Call call, Response response) throws IOException {
                            String str = response.body().string();
                            if (action.contains("system_login")) {
                                Headers headers = response.headers();
                                cookies = headers.values("Set-Cookie");
                            }
                            subscriber.onNext(str);
                            subscriber.onCompleted();
                        }
                    });
                } catch (IllegalArgumentException e) {
                    subscriber.onError(e);
                }
            }
        });
    }

    /**
     * @param context         上下文
     * @param action          服務器方法
     * @param HttpType        接口類型
     * @param requestCallback 回調接口
     */
    public static void postAsynHttp_File(final Context context, MultipartBody.Builder builder, String action, final HttpRequestCallback requestCallback, final String HttpType) {
        CheckConnect(context);
        mOkHttpClient = new OkHttpClient();
        MultipartBody requestBody = builder.build();
        Request request = new Request.Builder().url(action).post(requestBody).build();
        Call call = mOkHttpClient.newCall(request);
        call.enqueue(new Callback() {
            @Override
            public void onFailure(Call call, IOException e) {
                String exceptionCode = e.getLocalizedMessage();
                if ("java.net.SocketTimeoutException".equals(exceptionCode)) {
                    Toast.makeText(context, "数据获取超时", Toast.LENGTH_SHORT).show();
                } else if (exceptionCode
                        .contains("http.conn.ConnectTimeoutException")) {
                    Toast.makeText(context, "网络连接超时", Toast.LENGTH_SHORT).show();
                }
            }

            @Override
            public void onResponse(Call call, Response response) throws IOException {
                String str = response.body().string();
                try {
                    JSONObject object = new JSONObject(str);
                    if (object.getString("code").equals("200")) {
                        requestCallback.onResponse(str, HttpType);
                    } else {
                        requestCallback.onFailure(object.getString("msg"));
                    }
                } catch (JsonSyntaxException e) {
                    e.printStackTrace();
                    requestCallback.onFailure("数据解析异常!");
                } catch (JSONException e) {
                    requestCallback.onFailure("数据异常!");
                    e.printStackTrace();
                }
            }
        });
    }

    private static void CheckConnect(Context cont) {
        ConnectivityManager cm = (ConnectivityManager) cont.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = cm.getActiveNetworkInfo();
        if (info == null) {
            Toast.makeText(cont, "暂无网络连接，请连接网络!", Toast.LENGTH_SHORT).show();
            return;
        }
    }
}

处理数据的类共用

public class BigPresenter {
    HttpRequestCallback call;

    private static BigPresenter instance = null;

    private BigPresenter() {
    }

    public static BigPresenter getInstances() {
        if (null == instance) {
            instance = new BigPresenter();
        }
        return instance;
    }

    public void httpPost(final Context ext, final FormBody.Builder formBody, final String type, HttpRequestCallback call, final String action) {
        this.call = call;
        formBody.add("accountId", SPUtils.getString(ext, MyConstaints.ACCOUNTID, ""));//后期全部接口都要添加的参数不要找代码一个一个添加,直接添加就好了
        Observable<String> stringObservable = OkHttpUtils.postAsynHttp(ext, action, formBody).subscribeOn(Schedulers.io());
        MyLog.e(action);
        stringObservable.observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onCompleted() {
                        MyLog.e("onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        onErrer(e.getLocalizedMessage(), ext);
                    }

                    @Override
                    public void onNext(String s) {
                        MyLog.e("onNext" + s);
                        MyLog.e(s);
                        onSuccess(s, type, ext);
                    }
                });
    }

   

    private void onErrer(String parameter, Context context) {
        if ("java.net.SocketTimeoutException".equals(parameter)) {
            call.onFailure(context.getResources().getString(R.string.timeout_exception));
        } else if (parameter.contains("http.conn.ConnectTimeoutException")) {
            call.onFailure(context.getResources().getString(R.string.connecttimeout));
        } else if (parameter.contains("Failed")) {
            call.onFailure("服务端连接失败!");
        } else if (parameter.contains("failed")) {
            call.onFailure("服务端连接失败!");
        } else {
            call.onFailure(parameter);
        }
    }

    private void onSuccess(String parameter, String type, Context context) {
        try {
            JSONObject object = new JSONObject(parameter);
            if (object.getString("status").equals("200")) {
                call.onResponse(parameter, type);
            } else {
                call.onFailure(object.getString("msg"));
            }
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
            call.onFailure(context.getResources().getString(R.string.jsonsyntaxexception));
        } catch (JSONException e) {
            call.onFailure(context.getResources().getString(R.string.jsonexception));
            e.printStackTrace();
        }
    }

    private void onSuccessLogin(String parameter, String type, Context context) {
        try {
            JSONObject object = new JSONObject(parameter);
            if (object.getString("success").equals("true")) {
                call.onResponse(parameter, type);
            } else {
                call.onFailure(object.getString("message"));
            }
        } catch (JsonSyntaxException e) {
            e.printStackTrace();
            call.onFailure(context.getResources().getString(R.string.jsonsyntaxexception));
        } catch (JSONException e) {
            call.onFailure(context.getResources().getString(R.string.jsonexception));
            e.printStackTrace();
        }
    }

    public void httpGet(final Context ext, final String type, HttpRequestCallback call, String action) {
        this.call = call;
        Observable<String> stringObservable = OkHttpUtils.getAsynHttp(ext, action).subscribeOn(Schedulers.io());
        stringObservable.observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onCompleted() {
                        MyLog.e("onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        if (e == null) {
                            onErrer("服务端异常!", ext);
                        } else {
                            onErrer(e.getLocalizedMessage(), ext);
                        }
                    }

                    @Override
                    public void onNext(String s) {
                        MyLog.e("onNext" + s);
                        MyLog.e(s);
                        onSuccess(s, type, ext);
                    }
                });
    }

    public RequestInterface retrofitRequest(String action, Context context, String url) {
        Retrofit retrofit = new Retrofit.Builder().client(genericClient()).baseUrl(url + action).addConverterFactory(ScalarsConverterFactory.create()).build();
        MyLog.e(SPUtils.getString(context, url, "") + action);
        return retrofit.create(RequestInterface.class);
    }

    public static OkHttpClient genericClient() {
        OkHttpClient httpClient = new OkHttpClient.Builder()
                .addInterceptor(new Interceptor() {
                    @Override
                    public okhttp3.Response intercept(Chain chain) throws IOException {
                        Request request = chain.request().newBuilder().addHeader("cookie", String.valueOf(OkHttpUtils.cookies)).build();
                        return chain.proceed(request);
                    }
                })
                .build();
        return httpClient;
    }


    public void httpRetrofit(final Context ext, final String type, HttpRequestCallback call, Call<String> Responsecall) {
        this.call = call;
        Observable<String> stringObservable = OkHttpUtilsRetrofit.postAsynHttp(ext, Responsecall).subscribeOn(Schedulers.io());
        if (stringObservable == null) {
            return;
        }
        stringObservable.observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<String>() {
                    @Override
                    public void onCompleted() {
                        MyLog.e("onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        onErrer(e.getLocalizedMessage(), ext);
                    }

                    @Override
                    public void onNext(String s) {
                        MyLog.e("onNext" + s);
                        onSuccess(s, type, ext);
                    }
                });
    }
}
 

Retrofit注解方式拼接数据

 
public interface RequestInterface {
    /**
     * @param LineCode
     * @param ClientCode
     * @return
     */
    @GET("{LineCode}/{ClientCode}")
    Call<String> getOrderByLine(@Path("LineCode") String LineCode, @Path("ClientCode") String ClientCode);

    /**
     * @param Order
     * @param Id
     * @param Quantity
     * @param ClientCode
     * @param UpdateBy
     * @return
     */
    @POST("{MaterialDeliveryOrder}/{Id}/{Quantity}/{UpdateBy}/{ClientCode}")
    Call<String> editNumber(@Path("MaterialDeliveryOrder") String Order, @Path("Id") String Id, @Path("Quantity") String Quantity, @Path("UpdateBy") String UpdateBy, @Path("ClientCode") String ClientCode);

    /**
     * @param Order
     * @param Id
     * @param UpdateBy
     * @param ClientCode
     * @return
     */
    @POST("{MaterialDeliveryOrder}/{Id}/{UpdateBy}/{ClientCode}")
    Call<String> delete(@Path("MaterialDeliveryOrder") String Order, @Path("Id") String Id, @Path("UpdateBy") String UpdateBy, @Path("ClientCode") String ClientCode);

    /**
     * 获取菜单
     *
     * @param accountId
     * @param parentId
     * @param language
     * @param clientCode
     * @return
     */
    @GET("{accountId}/{parentId}/{language}/{clientCode}")
    Call<String> getMenu(@Path("accountId") String accountId, @Path("parentId") String parentId, @Path("language") String language, @Path("clientCode") String clientCode);

}

调起接口

private final String GETMEN = "GETMEN";
private final String LOGIN = "LOGIN";

//根据后台的方式二者选其一
//请求方式二
private void initMenu() {
    RequestInterface edit = BigPresenter.getInstances().retrofitRequest("findResourceByParentId/", this, url);
    BigPresenter.getInstances().httpRetrofit(this, GETMEN, this, edit.getMenu(accountid, "0", language, clientcode));
}

//请求方式一
private void spandTimeMethod(String serverURL, String accountIds, String password, String clientCode) {
    FormBody.Builder formBody = new FormBody.Builder();
    formBody.add("passWord", tool.md5(password));
    formBody.add("appType", "MS");
    formBody.add("clientCode", clientCode);
    BigPresenter.getInstances().httpPostLogin(LoginActivity.this, formBody, LOGIN, this, "http://" + serverURL + "/system_login", accountIds);
}

 

//访问服务器回调接口(列:200成功-300失败)
//200返回成功回调接口
@Override
public void onResponse(String sequest, String type) {

    switch (type) {
        case GETMEN:
            Gson gson = new Gson();'
            break;
    }
}
//返回300回调接口
@Override
public void onFailure(String exp) {
    alertNoTitle(R.drawable.err, exp, null, null, true);
}

 

 

回调参数在同一接口处理,阅读性会好一点,维护起来比较简单

 

 

 

 

 

杨淑全
关注
专栏目录
Retrofit 分析 - 经典设计模式案例
...
08-31 798
原文链接：http://www.jianshu.com/p/fb8d21978e38 本篇是 retrofit 番外篇。只讲 retrofit 中的设计模式以及我个人的理解与延伸。 —— 由 Stay 分享 如果你还不知道Retrofit，没关系，okhttp你总知道吧。retrofit就是对okhttp再做了一层封装。你只需要通过简单的配置就能顺利使用retrofit来做
Retrofit + GSON处理JSON模板
HaveFerrair的博客
05-25 6418
动机 首先封装了Retrofit的一些操作，也就是回调的时候不必去为每个javabean的每个操作去写一个Callback，所有的bean公用一个Callback。 使用了MVP的设计思想，加上公用的Callback，使得每个bean的Presenter层只需要极少的方法，就可以实现原来的功能。 然后封装GSON,定义了公用的Holder容器，存储从服务器直接返回的JSON数据，然后分发给每个bea
Retrofit的二次封装
06-05
添加 以JSON形式上传参数，自定义使用的Retrofit的二次封装的module，可直接导入项目使用，包含有无token两种情况，以及支持后台证书校验等。部分代码需根据项目需要修改后使用
retrofit的简单二次封装
SimpleCoder's Blog
09-01 807
retrofit的简单二次封装基于上次的retrofit初探后，可以对retrofit简单的二次封装public interface HttpURL { String baseUrl = "http://127.0.0.1:32001/"; }public class RequestUtils { private static OkHttpClient client; priv
【知识必备】RxJava+Retrofit二次封装最佳结合体验，打造懒人封装框架~
weixin_34346099的博客
12-12 151
一、写在前面 　　相信各位看官对retrofit和rxjava已经耳熟能详了，最近一直在学习retrofit+rxjava的各种封装姿势，也结合自己的理解，一步一步的做起来。 　　骚年，如果你还没有掌握retrofit和rx两大框架，那你是真的out了！ 　　如果你对Rxjava不熟悉，请先看扔物线的给 Android 开发者的 RxJava 详解，超详细； 　　如果你只是想了解retro...
Retrofit +rxjava的二次封装
sinat_30066291的博客
12-06 310
1.依赖  implementation 'com.squareup.okhttp3:logging-interceptor:3.10.0' implementation'com.github.valdio:SerializableCookieJar:1.0.0' implementation'io.reactivex.rxjava2:rxjava:2.2.4' impleme...
Retrofit和OkHttp简单的二次封装
Arrogant——玖零
12-03 338
ServiceApi 这里创建网络请求类型public interface ServiceApi { @GET(Api.URL) Call<Bean>bean(); }创建RetrofitHelper public class RetrofitHelper { private static OkHttpClient okHttpClient; private static
RxJava+Retrofit+OkHttp深入浅出-终极封装四（多文件下载之断点续传）
热门推荐
wzgiceman
10-24 2万+
Rxjava+ReTrofit+okHttp深入浅出-终极封装三（多文件下载之断点续传）背景断点续传下载一直是移动开发中必不可少的一项重要的技术，同样的Rxjava和Retrofit的结合让这个技术解决起来更加的灵活，我们完全可以封装一个适合自的下载框架，简单而且安全！效果实现下载和之前的http请求可以相互独立，所以我们单独给download建立一个工程moudel处理1.创建service接口和
Kotlin语言基于Mvp+Retrofit+RxJava封装的Android项目的基础依赖库
一个人的旅行的博客
02-27 873
主要针对使用 Kotlin 语言开发Android项目，使用 MVP+Retrofit+RxJava 架构封装的一些基础类（Activity/ListActivity,Fragment/ListFragment,Adapter），供开发时依赖使用，缩短项目准备时间。
OkHttp+Retrofit实现原理
最新发布
2301_76766616的博客
11-28 1402
HttpEngine 在发起请求之前，会先调用nextConnection()来获取一个Connection对象，如果可以从ConnectionPool中获取一个Connection对象，就不会新建，如果无法获取，就会调用createnextConnection()来新建一个Connection对象，这就是 Okhttp 多路复用的核心，不像之前的网络框架，无论有没有，都会新建Connection对象。最后，从使用场景看，应用拦截器因为只会调用一次，通常用于统计客户端的网络请求发起情况；
9步实现Retrofit的二次封装
03-28
9步实现Retrofit的二次封装
Android-Retrofit-RxJava-OkHttp二次封装
08-13
Retrofit-RxJava-OkHttp二次封装
Android-基于OKhttpRxjava2Retrofit进行二次封装
08-13
基于OKhttp Rxjava2 Retrofit进行二次封装，优雅的okhttpclient retrofit初始化设置，完整的拦截器配置，基于OKhttp缓存，封装无网络和其他所有场景的缓存策略支持
详解RxJava2 Retrofit2 网络框架简洁轻便封装
01-05
前言 RxJava2、Retrofit2火了有一段时间了，前段时间给公司的项目引入了这方面相关的技术，在此记录一下相关封装的思路。 需求 封装之前要先明白需要满足哪些需求。 RxJava2衔接Retrofit2 Retrofit2网络框架异常的统一处理 兼容fastjson（可选） RxJava2内存泄漏的处理 异步请求加入Loading Dialog 依赖 implementation 'io.reactivex.rxjava2:rxandroid:2.0.1' implementation 'io.reactivex.rxjava2:rxjava:2.1.3' i
okhttp3.0+retrofit2.0 二次封装demo代码内有详细注解
06-29
这是一个demo 使用androidstudio开发，采用了okhttp3.0+retrofit2.0来二次封装的框架，内部有接口管理，自动解析，等功能，开发者可以通过修改AppConfig内部的URL和@POST内部的参数就可以直接使用，当然Call内部的接受类型需要自己定义
Android网络请求Retrofit进行二次封装,拿过来就能用
qq_40015237的博客
11-05 1123
在Andrroid开发中，网络请求十分常用而在Android网络请求库中，Retrofit是当下最热的一个网络请求库 这里对Retrofit进行了一下二次封装,把一些固定的代码摘出来了, import android.util.Log; import java.util.concurrent.TimeUnit; import okhttp3.OkHttpClient; import ok
Retrofit网络加载库二次封装支持RxJava与Flow-HttpUtils
DL-ZhangTeng的博客
09-15 813
HttpUtils是Retrofit网络加载库二次封装支持RxJava与Flow，包含网络加载动画、activity销毁自动取消请求、网络缓存、公共参数、RSA+AES加密等。
android 二次封装,Retrofit 二次封装实战
weixin_35625324的博客
05-27 631
首先这篇文章是面向对Retrofit有了解的朋友，如果您对Retrofit并不了解，请自行查阅其用法，本文不会讲解Retrofit的基础用法。写这篇文章的目的很简单：1.为了让自己回忆一下(代码半年前就完成了)，看是否有改进的地方。2.如果能帮到有同样需求的朋友，那是再好不过的。3.如果大家对文章有不同意见之处，本人表示200%的欢迎提议。这次封装实现的功能：1.抽离网络层为module，实现即插...
强化自动化构建Retrofit实例的二次封装
andyj2ee2008的专栏
08-13 333
一、接口声明 package com.chenliang.account typealias Data<T> = Call<BaseResponse<T>> typealias Datas<T> = Call<BaseResponse<ArrayList<T>>> @MyApiService(mName = "API", mPath = "http://www.test.com/app/") interface
RxJava+Retrofit+OkHttp深度解析与封装实践
"深入浅出RxJava+Retrofit+OkHttp网络请求" 在移动开发领域，尤其是在Android平台上，网络请求是应用程序不可或缺的一部分。本文将详细探讨如何利用RxJava、Retrofit和OkHttp这三个强大的库进行高效的网络请求。...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值