xJava +retrofit2实现安卓中网络操作

最新推荐文章于 2024-04-23 00:35:39 发布

迷茫_小白

最新推荐文章于 2024-04-23 00:35:39 发布

阅读量236

点赞数

分类专栏：框架 android-studio 青软实训文章标签： android-studio 框架

青软实训同时被 3 个专栏收录

25 篇文章 0 订阅

订阅专栏

android-studio

10 篇文章 0 订阅

订阅专栏

框架

7 篇文章 0 订阅

订阅专栏

RxJava +retrofit2实现安卓中网络操作~

在安卓中想实现网络操作有多种方式，可能许多没有经历过团队开发的安卓工程师，经常使用到的是第三方的云后台，但是其实它们的底层使用的也一定是安卓中网络的通信框架，例如：volley，nohttp，okhttp等。

今天我们要介绍的retrofit2底层就是用的okhttp的通信方式，下面简单介绍一下为什么写这篇文章吧，在开发团队项目以前，我也和我小伙伴交流过，
我说咱们一直采用第三方的云后台，你说咱们怎么和真正的服务器做联系啊，我们那个时候异口同声的说不知道，后来在我做的第一个团队项目“黑大盒子”的时候，
我就学习了okHttp，那个时候感觉很好用啊，代码也挺简洁的，直至后来在一次，和我学长的交流过程中了解了可以用RxJava +retrofit2实现网络的通信，那个时候我真的是下了很大的功夫研究，
结果是毫无头绪，因为那个时候，我对观察者模式，和rxjava的系统的思想就是非常的不够的。在后来我学习了观察者模式，又一直在找rxjava的资料使我对这种网络通信有了一定的了解。

使用RxJava +retrofit2实现网络通信的优势

请求时间和返回时间短（性能上的优势）
代码简介，已经把封装实现到了极致

毫不夸张的说，如果公司没有自己的网络操作的框架，采用这种方式一定是最佳选择之一

RxJava的简介

链接：https://github.com/ReactiveX/RxJava
RxJava采用的思想便是观察者模式，可以异步实现实现我们的需求，简单的说，RxJava并不是轮询去检测被观察的对象，
而是当被观察的对象有任何举动的时候都会告诉我们，我们便可以根据这个消息决定要做什么处理。

retrofit2的简介

链接：https://github.com/square/retrofit
retrofit这个库的功能非常的强大，它可以直接向Gson添加依赖，解析我们返回的json数据非常的轻松，而且我们实现网络操作也非常的便捷，
非常轻松的就可以实现在工作线程请求网络操作，在主线程实现对网络操作结果的处理。

在这里我要非常正式的声明一下，不是笔者懒，用两句话，就把这么传奇的两个第三方开源库就给介绍完了，
而且本文主要的目的是教大家怎么用它们实现网络操作，我接下来的文章会非常认真的介绍，观察者模式、RxJava、retrofit，这三方面的知识。
ps：我始终认为，在你学习一个编程上的知识的时候，你最先要做的不是弄明白它，而是要用明白它，然后跟着代码的逻辑走一遍，看看它是怎么实现的
，然后可以看看人家的官方文档，或者大神们的博客学习一下，最后我们还可以阅读以下源码，这样学起来可能会轻松，也会比较高效。

RxJava +retrofit2的使用！！！

第一步：在build.gradle中添加依赖

// RxJava Android 支持
compile 'io.reactivex:rxjava:1.1.6'
compile 'io.reactivex:rxandroid:1.2.1'
// Retrofit 网络支持
compile 'com.squareup.retrofit2:retrofit:2.1.0'compile 'com.squareup.retrofit2:converter-gson:2.1.0'
// Gson 适配器
compile 'com.squareup.retrofit2:adapter-rxjava:2.1.0'

第二步：添加必要的权限

<uses-permission android:name="android.permission.INTERNET"/>
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>
    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
    <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
    <uses-permission android:name="android.permission.CHANGE_WIFI_STATE"/>
    <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
    <uses-permission android:name="android.permission.CHANGE_CONFIGURATION"/>
    <uses-permission android:name="android.permission.WRITE_SETTINGS"/>

第三步：定义一个接口，实现网络操作
这个类，是在我们主URL后面链上的字段，然后泛型的是要返回数据我要将它解析成什么样子，里面的参数就是post请求需要携带的参数了。

/**
 * Created by lin_sir on 2016/6/29.网络协议
 */

public interface Api {

    @FormUrlEncoded
    @POST("getCode")
    Observable<ResponseModel_nolist> getCode(@Field("tel") String tel);

    @FormUrlEncoded
    @POST("register")
    Observable<ResponseModel_nolist> register(@Field("tel") String tel, @Field("password") String password, @Field("code") String code);

}

第四步：实现刚才泛型的类
为了让大家使用起来毫无难度，我就在这里把这个简单的类也粘出来了

/**
 * Created by lin_sir on 2016/7/7.结果中不带有list的网络返回结果
 */
public class ResponseModel_nolist {

    private int code;
    private String msg;

    private obj obj;

    public int getCode() {
        return code;
    }

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

    public String getMsg() {
        return msg;
    }

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

    public com.example.lin_sir_one.tripbuyer.model.obj getObj() {
        return obj;
    }

    public void setObj(com.example.lin_sir_one.tripbuyer.model.obj obj) {
        this.obj = obj;
    }
}

第五步：实现一个BASE_URL,以后我们的网络操作走的url都是在这些url后面加字段
当然我打星号的，都是我们公司后台暴露出来的接口啦，虽然我们做了负载均衡，也做了防止别人攻击的处理啦，但是在这里暴露出来好像也还是不太好~

/* Created by lin_sir on 2016/6/29.全局常量定义
 */
public class Constant {

    public static final String BASE_URL = "http://xxx.xxx.xxx.xxx:8080/lxms-user/member/api/";

    public static final String BASE_BUY_URL = "http://xxx.xxx.xxx.xxx:8080//lxms-user/buyer/api/";

    public static final String BASE_SELL_URL = "http://xxx.xxx.xxx.xxx:8080/lxms-user/seller/api/";

}

第六步：实现一个Apiservice，这个类的作用就是实现我们的网络操作的直接方式~

/**
 * Created by lin_sir on 2016/7/7.调用api接口,获取验证码和注册采用这个接口
 */
public class ApiService {

    private Api mApi;
    private Context mContext;
    private static ApiService mInstance;

//-------- 存在内存泄漏的写法,如果传入 Activity 的 Context,会导致 Activity 无法被回收-------------------
//    private ApiService(Context mContext) {
//        this.mContext = mContext;
//        mApi = RetrofitClient.getClient(mContext).create(Api.class);
//    }
//
//    public static ApiService getInstance(Context mContext) {
//        if (mInstance == null) {
//            mInstance = new ApiService(mContext);
//        }
//        return mInstance;
//    }
//------------------------------------------------------------------------------------------------

    private ApiService() {
        this.mContext = BaseApplication.get().getAppContext();
        mApi = RetrofitClient.getClient(mContext).create(Api.class);
    }

    public static ApiService getInstance() {
        if (mInstance == null) {
            mInstance = new ApiService();
        }
        return mInstance;
    }

    /**
     * 获取验证码
     */
    public void getCode(HttpResultListener<Boolean> listener, final String tel) {
        mApi.getCode(tel)
                .map(new HttpResultFuncNoList())
                .map(new Func1<String, Boolean>() {
                    @Override
                    public Boolean call(String s) {
                        if (s.equals("ok")) {
                            return true;
                        } else {
                            return false;
                        }
                    }
                })
                .subscribeOn(Schedulers.io())//在工作线程请求网络
                .observeOn(AndroidSchedulers.mainThread())//在主线程处理结果
                .subscribe(new HttpResultSubscriber<>(listener));
    }




    private static class HttpResultSubscriber<T> extends Subscriber<T> {

        private HttpResultListener<T> mListener;

        public HttpResultSubscriber(HttpResultListener<T> listener) {
            mListener = listener;
        }


        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {
            if (mListener != null) {
                mListener.onError(e);
            }
        }

        @Override
        public void onNext(T t) {
            if (mListener != null) {
                mListener.onSuccess(t);
            }
        }
    }

    /**
     * 对返回结果做统一处理,只有当结果码为 100 时,才返回正常,否则返回错误,不带list的
     */
    private class HttpResultFuncNoList implements Func1<ResponseModel_nolist, String> {

        @Override
        public String call(ResponseModel_nolist responseModel) {

            if (responseModel.getCode() == NetworkException.REQUEST_OK) {
                Log.i("lin", "---lin--->  目前没发生错误：  " + responseModel.getCode());
                return responseModel.getMsg();
            } else {
                Log.i("lin", "---lin--->  错误代码：  " + responseModel.getCode());
                throw new NetworkException(responseModel.getCode());
            }
        }
    }

}

第七步：实现网络操作的回调接口

/**
 * Created by lin_sir on 2016/7/7.网络操作的回调接口
 */
public interface HttpResultListener<T> {

    void onSuccess(T t);

    void onError(Throwable e);

}

第八步：实现retrifit2客户端
在这个客户端里面，我们不仅实现了Gson的适配器，也实现了Rxjava的适配器，还为我们的操作添加了主URL就可以了。

public class RetrofitClient {

    /**
     * 采用base_url
     */
    public static Retrofit getClient(Context context) {
        return new Retrofit.Builder()
                .baseUrl(Constant.BASE_URL)
                //.client(httpClient(context))
                .addConverterFactory(GsonConverterFactory.create())//Gson 适配器
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())// RxJava 适配器
                .build();
    }
}



其实我们的网络操作就已经实现完了，如果我们代码习惯比较好的话，可以把所有的服务器返回的状态吗放在一起进行统一的处理。

统一处理后台返回状态码的代码：

/**
 * Created by tc on 6/21/16. 网络操作错误
 */
public class NetworkException extends RuntimeException {

    public static final int REQUEST_OK = 100;
    public static final int REQUEST_FAIL = 101;
    public static final int METHOD_NOT_ALLOWED = 102;
    public static final int PARAMETER_ERROR = 103;
    public static final int UID_OR_PWD_ERROR = 104;
    public static final int SERVER_INTERNAL_ERROR = 105;
    public static final int REQUEST_TIMEOUT = 106;
    public static final int CONNECTION_ERROR = 107;
    public static final int VERIFY_EXPIRED = 108;
    public static final int NO_DATA = 109;


    public NetworkException(int resultCode) {
        this(getNetworkExceptionMessage(resultCode));
    }

    public NetworkException(String detailMessage) {
        super(detailMessage);
    }

    /**
     * 将结果码转换成对应的文本信息
     */
    private static String getNetworkExceptionMessage(int code) {
        String message = "";
        switch (code) {
            case REQUEST_OK:
                message = "请求成功";
                break;
            case REQUEST_FAIL:
                message = "请求失败";
                break;

            case METHOD_NOT_ALLOWED:
                message = "请求方式不允许";
                break;
            case PARAMETER_ERROR:
                message = "用户不存在";
                break;
            case UID_OR_PWD_ERROR:
                message = "用户名或密码错误";
                break;
            case SERVER_INTERNAL_ERROR:
                message = "服务器内部错误";
                break;
            case REQUEST_TIMEOUT:
                message = "请求超时";
                break;
            case CONNECTION_ERROR:
                message = "连接错误";
                break;
            case VERIFY_EXPIRED:
                message = "验证过期";
                break;
            case NO_DATA:
                message = "没有数据";
                break;
            case 110:
                message = "该用户已存在";
                break;
            default:
                message = "未知错误";
        }
        return message;
    }
}

好了，我们已经可以使用RxJava +retrofit2实现网络操作了：

HttpResultListener<List<JourneyModel>> listener = new HttpResultListener<List<JourneyModel>>() {
            @Override
            public void onSuccess(List<JourneyModel> journeyModels) {
                KLog.d("----lin---->  成功");
            }

            @Override
            public void onError(Throwable e) {
                KLog.d("----lin---->  失败" + e.toString());
            }
        };
        ApiService6.getInstance().route2(listener, "1");

到这里我们就已经把网络通信彻底的研究了一遍啦，虽然看起来稍微有一点点小复杂，但是我们要想的是，整个工程的网络通信，我这点代码就已经都写完了啊，以后用起来可就非常的方便啦。

在这里，我们对RxJava，Retrofit2已经有了一个了解了，初步我们已经会使用了这些知识，在接下来的文章里，我不会再这么详细的介绍它们的使用，而是要介绍它们的实现的原理，和它们思想上的一些东西。