RxAndroid简单入门。

最新推荐文章于 2024-05-20 10:00:49 发布

Hoyn

最新推荐文章于 2024-05-20 10:00:49 发布

阅读量873

点赞数 1

分类专栏： Android 文章标签： android rxjava rxAndroid

本文链接：https://blog.csdn.net/adzcsx2/article/details/51302318

版权

Android 专栏收录该内容

27 篇文章 1 订阅

订阅专栏

这段时间研究了一下rxJava，rxAndroid。对于刚接触RxJava的人来说，完全是迷茫状态。相信看了大神的博文之后，心里有这样一个疑问，我只是想学rxJava，lambda和Retrofit又是什么鬼，完全看不懂了。.

所以这篇博文主要是单独讲RxJava在Android中的运用。

一、RxJava是什么？
二、RxJava感觉很牛B，但是又有什么用？
三、我要怎么才能利用RxJava的反应式编程减少在Android中的代码量?

一、RxJava是什么？

一个词：异步。

把这个看作异步的另外一种方式就很好理解了。它是跟AsyncTask，Handler放在一起作比较的。
举一个例：通过天气API获取结果。

需导入RxJava.jar，RxAndroid.jar或者依赖

首先有一个方法：根据API同步获得请求结果

//控件
TextView tv;
public static final String url_weatherApi = "http://wthrcdn.etouch.cn/weather_mini?city=北京";
// okhttp 同步的get请求
private String requestGet(String url)

Handler:

new Thread(new Runnable() {

            @Override
            public void run() {
                final String requestGet = requestGet(url_weatherApi);
                tv.post(new Runnable() {

                    @Override
                    public void run() {
                        tv.setText(requestGet);
                    }
                });
            }
        }).start();

AsyncTask:

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        new MyTask().execute(url_weatherApi);
    }
    private class MyTask extends AsyncTask<String, String, String>{

        @Override
        protected String doInBackground(String... params) {

            String result = requestGet(params[0]);

            return result;
        }

        @Override
        protected void onPostExecute(String result) {
            super.onPostExecute(result);
            tv.setText(result);
        }

    }

RxJava:

    Observable.just(url_weatherApi)

        .map(new Func1<String, String>() {
//第一个String是参数，即params = url_wetherApi,第二个String是返回结果（用法详见其他博文）
                @Override
                public String call(String params) {
                    return requestGet(params);
                }
        .subscribeOn(Schedulers.io()) //在io线程(子线程)中操作map转换操作
        .observeOn(AndroidSchedulers.mainThread())//在主线程中运行->subscribe里面的
        .subscribe(new Action1<String>() {

                    @Override
                    public void call(String result) {
                    //上面return的String
                        tv.setText(result);
                    }
                });

第一眼看起来RxJava似乎更复杂了，对于初学的确是这样。但是当你用习惯了之后，你会发现这个比handler好用很多(ps.可能吧，博主现在也用的不是很习惯，但我从来不用AsyncTask，总感觉这个太重了=。=)。

二、RxJava感觉很牛B，但是又有什么用？

rxJava比其他好用之处就在于当你会了之后，看rxJava写的代码条理清晰。

比如

{
    "desc": "OK",
    "status": 1000,
    "data": {
        "wendu": "25",
        "ganmao": "各项气象条件适宜，无明显降温过程，发生感冒机率较低。",
        "forecast": [
            {
                "fengxiang": "无持续风向",
                "fengli": "微风级",
                "high": "高温 28℃",
                "type": "多云",
                "low": "低温 15℃",
                "date": "29日星期五"
            },
            {
                "fengxiang": "无持续风向",
                "fengli": "微风级",
                "high": "高温 31℃",
                "type": "晴",
                "low": "低温 15℃",
                "date": "30日星期六"
            },
            {
                "fengxiang": "无持续风向",
                "fengli": "微风级",
                "high": "高温 32℃",
                "type": "多云",
                "low": "低温 19℃",
                "date": "1日星期天"
            },
            {
                "fengxiang": "北风",
                "fengli": "4-5级",
                "high": "高温 23℃",
                "type": "阵雨",
                "low": "低温 13℃",
                "date": "2日星期一"
            },
            {
                "fengxiang": "北风",
                "fengli": "4-5级",
                "high": "高温 27℃",
                "type": "晴",
                "low": "低温 13℃",
                "date": "3日星期二"
            }
        ],
        "yesterday": {
            "fl": "3-4级",
            "fx": "南风",
            "high": "高温 26℃",
            "type": "多云",
            "low": "低温 13℃",
            "date": "28日星期四"
        },
        "aqi": "219",
        "city": "北京"
    }
}

现在我想取json中yesterday的date。那么在thread中是这样的：

new Thread(new Runnable() {

            @Override
            public void run() {
                final String requestGet = requestGet(url_weatherApi);
                JSONObject data=null;
                try {
                    JSONObject json = new JSONObject(requestGet);
                    data = json.getJSONObject("data");
                } catch (JSONException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                Gson gson = new Gson();
                final DataBean dataBean = gson.fromJson(data.toString(), DataBean.class);
                tv.post(new Runnable() {

                    @Override
                    public void run() {
                        tv.setText(dataBean.getYesterday().getDate());
                    }
                });
            }
        }).start();

在rxJava:

Observable.just(url_weatherApi)
        //把url转成json
        .map(new Func1<String, String>() {
                    @Override
                    public String call(String params) {
                        return requestGet(params);
                    }})
        //把json转为DataBean对象
        .map(new Func1<String, DataBean>() {
                @Override
                public DataBean call(String arg0) {
                    JSONObject data=null;
                    try {
                        JSONObject json = new JSONObject(arg0);
                        data = json.getJSONObject("data");
                    } catch (JSONException e) {

                    e.printStackTrace();
                }
                Gson gson = new Gson();
                DataBean dataBean = gson.fromJson(data.toString(), DataBean.class);
                return dataBean;
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Action1<DataBean>() {
                @Override
                public void call(DataBean arg0) {
                        tv.setText(arg0.getYesterday().getDate());
                }});
    }

先不管代码量如何。至少我的思路很清晰，我以后需要改什么东西，直接可以很清楚的知道哪里我需要改。而不需要像Thread那样到处去找代码。

现在我有一个需求，在获取了北京的天气后，再获取深圳的天气。并分别给TextView赋值。

    public static final String url_weatherApi = "http://wthrcdn.etouch.cn/weather_mini?city=北京";
    public static final String url_weatherApi_sz = "http://wthrcdn.etouch.cn/weather_mini?city=深圳";

看一下常规方法。

    new Thread(new Runnable() {

            @Override
            public void run() {
                final String requestGet = requestGet(url_weatherApi);
                tv.post(new Runnable() {

                    @Override
                    public void run() {
                        Log.e("first", requestGet);
                        tv.setText(requestGet);
                        new Thread(new Runnable() {

                            @Override
                            public void run() {
                                final String requestGet = requestGet(url_weatherApi_sz);
                                tv.post(new Runnable() {

                                    @Override
                                    public void run() {
                                        Log.e("second", requestGet);
                                        tv.setText(requestGet);
                                    }
                                });
                            }
                        }).start();
                    }
                });
            }
        }).start();

这就是所谓的callback hell。

接下来看看RxJava

Observable.just(url_weatherApi)
        //子线程取北京天气
        .subscribeOn(Schedulers.io())
        .observeOn(Schedulers.io())
        .map(new Func1<String, String>() {

            @Override
            public String call(String arg0) {
                return requestGet(arg0);
            }
        }) 
        //主线程赋值
        .observeOn(AndroidSchedulers.mainThread())
        .map(new Func1<String,String>() {

            @Override
            public String call(String arg0) {
                Log.e("first", arg0);
                tv.setText(arg0);
                //返回深圳天气的url
                return url_weatherApi_sz;
            }
        })
        //子线程取深圳天气
        .observeOn(Schedulers.io())
        .map(new Func1<String, String>() {

            @Override
            public String call(String arg0) {
                return requestGet(arg0);
            }
        .observeOn(AndroidSchedulers.mainThread())
        //主线程赋值
        .subscribe(new Action1<String>() {

            @Override
            public void call(String arg0) {
                Log.e("second", arg0);
                tv.setText(arg0);
            }
        });

好处就不多说了，大家自己体会。

三、我要怎么才能利用RxJava的反应式编程减少在Android中的代码量?

利用java 8的新特性lambda
android studio中用retrolambda这个插件。
详见深入浅出RxJava（一：基础篇）

好了，rxJava在Android中使用基本使用就到这里了。

接下来是RxAndroid在Android中的使用。
RxBinding(需导入RxBinding.jar)。

@Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tv = (TextView) findViewById(R.id.tv);
        iv = (ImageView) findViewById(R.id.imageView);
        ev1 = (EditText) findViewById(R.id.editText1);
        ev2 = (EditText) findViewById(R.id.editText2);
        cb = (CheckBox) findViewById(R.id.checkBox1);

        //ev1的内容状态监听，相当于ev1.addTextChangedListener(watcher)，只不过比他好用。
        RxTextView.textChanges(ev1).subscribe(new Action1<CharSequence>() {

            @Override
            public void call(CharSequence arg0) {
                tv.setText(arg0);
            }
        });

    }

//监听checkBox的状态
RxCompoundButton.checkedChanges(cb).subscribe(new Action1<Boolean>() {

            @Override
            public void call(Boolean arg0) {
                if(arg0){
                    iv.setVisibility(View.VISIBLE);
                }else{
                    iv.setVisibility(View.GONE);
                }
            }
        });

ps：RxAndroid实际就是RxJava，在Android中，RxAndroid.jar只有一个用处，就是

.observeOn(AndroidSchedulers.mainThread())

在主线程中运行。而RxBinding只是RxAndroid的衍生品。

以上只是RxAndroid简单入门，想要提升还得多看大神写的文章。

参考文献：

给 Android 开发者的 RxJava 详解
 深入浅出RxJava
RxJava入门指南

我是用Eclipse的，所以Demo也是eclipse的Demo，里面包含了jar包。

附上Demo:

Hoyn

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
RxAndroid简单入门。

这段时间研究了一下rxJava，rxAndroid。对于刚接触RxJava的人来说，完全是迷茫状态。相信看了大神的博文之后，心里有这样一个疑问，我只是想学rxJava，lambda和Retrofit又是什么鬼，完全看不懂了。所以这篇博文主要是单独讲RxJava在Android中的运用。一、RxJava是什么？二、RxJava感觉很牛B，但是又有什么用？三、我要怎么才能利用RxJava的反应式
复制链接

扫一扫

专栏目录