demo rxandroid_rxandroid demo - CSDN
  • 前言现在RxJava,RxAndroid似乎很火,很多开发群里面都在讨论。因为本人虽然一直在开发Android,但近两年跟系统内置app和framework层打交道更多,没有想到脱离互联网领域这么点时间,这么多新技术就冒出来了。所以...

    前言

    现在RxJava,RxAndroid似乎很火,很多开发群里面都在讨论。因为本人虽然一直在开发Android,但近两年跟系统内置app和framework层打交道更多,没有想到脱离互联网领域这么点时间,这么多新技术就冒出来了。所以想想很有危机感,感觉脱离群众很久了。那么,来吧。打算用一段时间将这个知识点从零开始学起。

    至于RxAndroid其实只是RxJava的一个扩展,它在RxJava的基础上添加了一些针对Android系统的新API。因为我是在Android系统上编写代码测试,所以我就将之称呼为RxAndroid了。其实大多讲得基本上都是RxJava的知识点。这点需要大家注意。

    本人偏向于实用主义,不想开山立作去详尽解释RxAndroid中具体的语法,只想通过自己编写的demo去一个一个验证知识点

    好吧。开始。

    RxJava是用来解决异步工作问题的,在Android中特别恼火的多线程开发问题上游刃有余,所以才深受广大开发者的喜欢。RxAndroid基于RxJava。

    RxAndroid的Github地址是
    link

    如果需要在开发中用到RxAndroid,那么需要在
    Android Studio中添加依赖
    build.gradle中的

    dependencies {
        compile fileTree(dir: 'libs', include: ['*.jar'])
    
        compile 'io.reactivex:rxandroid:1.2.1'
        // Because RxAndroid releases are few and far between, it is recommended you also
        // explicitly depend on RxJava's latest version for bug fixes and new features.
       compile 'io.reactivex:rxjava:1.1.6'
    
    }
    

    Observable,Subscribers

    开发的人都知道监听者模式,订阅模式这些概念。而Observable和Subscribers的英文意思就是如此。我们大概也知道差不多和监听者模式差不多。

    • Observable事件源,被观察者。
    • Subcriblers 观察者,事件订阅者
    • Observer 同Subcribler差不多
    • subscribe() 方法,绑定Observable与Subcribler或者Observabler

    很显然,Observable对象发生动静,然后通信Subcribers,然后Subcribers实现自己的业务逻辑。

    Observable的创建

    Observable

    它没有一个public的构造器,看源码可知它创建的对象的方法原型如下:

    public final static <T> Observable<T> create(OnSubscribe<T> f) {
            return new Observable<T>(hook.onCreate(f));
        }
    

    可以看见,它是静态方法,接受一个OnSubscribe的参数,我们先不管它是什么,我们一步一步来,先创建一个对象再说。

    Observable<String> mObservable = Observable.create(new Observable.OnSubscribe<String>() {
                @Override
                public void call(Subscriber<? super String> subscriber) {
    
                }
            });
    

    当然除了create方法外,还有just()和from()方法也可以创建Observable对象,在这里我们先不管,先从最简单的学起。

    Subscriber的创建

    创建比较简单

    Subscriber<String> mTestSubscriber = new Subscriber<String>() {
                @Override
                public void onCompleted() {
    
                }
    
                @Override
                public void onError(Throwable e) {
    
                }
    
                @Override
                public void onNext(String s) {
    
                }
            };
    

    要注意的是Subsriber是订阅者,它和subscribe不一样,后者是一个订阅关系动作,将Observable与Subscriber绑定起来。

    Observer的创建

    Observer<String> mTestObsever = new Observer<String>() {
                @Override
                public void onCompleted() {
    
                }
    
                @Override
                public void onError(Throwable e) {
    
                }
    
                @Override
                public void onNext(String s) {
    
                }
            };
    

    可以看到Subscriber和Observer很相似。

    而实际上Observer是一个接口,而Subscriber是它的一个抽象实现类。源码如下:

    public interface Observer<T> {}
    
    public abstract class Subscriber<T> implements Observer<T>, Subscription {}
    

    Obersevable与Subscriber的关联

    大家已经知道怎么创建Obeservable与Subscriber了,那么它们怎么联系起来的呢?答案是subsribe方法。

     mObservable.subscribe(mTestSubscriber);
    

    这里有一点迷惑性,一般来说正确的写法似乎是这样

    mTestSubscriber.subscribe(mObservable);

    但RxJava中Api就是如此设计,应该自有它的道理,只是给初学者造成的迷惑,我们需要注意一下。
    但这里我想起当初张孝祥老师的面向对象的视频中说过,人把门打开关闭。代码怎么写?

        person.openDoor();
        person.closeDoor();
    

    还是

        door.open();
        door.close();

    张老师说是后者,具体哪个对象拥有改变自身属性的方法,这个方法就应该在哪个对象上。这样的好处应该在并发环境下更明显。
    比如一个电话,很多人抢着打。

    class Phone{
    
        public synchronized call(){}
    
    }
    

    当调用Phone.call()的时候,如果有人占用,其他人自然要等待。但如果要设计成person.callPhone()的时候,问题就没有这么好办了。

    好了,扯远了。

    回到主题,强调一下

    联系被观察者与观察者是通过subscribe()方法

    Demo实例

    接下来验证的时候到了。写了一个Demo,很简单。
    点击一个按钮,然后弹出一个Toast.这中间的流程就是应用了本文的内容。
    效果如下:
    这里写图片描述

    代码如下:
    xml文件很简单,就是一个简单的布局里面有一个按钮。

    MainActivity.java

    package com.frank.rxandroiddemo;
    
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.View;
    import android.widget.Button;
    import android.widget.Toast;
    
    import rx.Observable;
    import rx.Subscriber;
    
    public class MainActivity extends AppCompatActivity {
    
        Button mBtn;
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            mBtn = (Button) findViewById(R.id.btn_test);
            final Observable<String> mObservable = Observable.create(new Observable.OnSubscribe<String>() {
                @Override
                public void call(Subscriber<? super String> subscriber) {
                    subscriber.onNext("Hello");
                    subscriber.onNext("How are you?");
                    subscriber.onNext("Yes,i\'m fine,thank you!");
                    subscriber.onCompleted();
                }
            });
    
            final Subscriber<String> mTestSubscriber = new Subscriber<String>() {
                @Override
                public void onCompleted() {
    
                }
    
                @Override
                public void onError(Throwable e) {
    
                }
    
                @Override
                public void onNext(String s) {
                    Toast.makeText(MainActivity.this,s,Toast.LENGTH_SHORT).show();
                }
            };
    
    
    
            mBtn.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    mObservable.subscribe(mTestSubscriber);
                }
            });
    
        }
    }
    

    流程如下:
    1. 创建Obsersevable对象与Subscriber对象。
    2. 按钮点击时通过mObservable.subscribe(mTestSubscriber)方法去触发Obsersevable中的OnSubscribe中的call()方法。
    3. 在call方法中会调用subscriber的onNext()方法,而这里的subsriber就是mTestSubscriber。
    4. mTestSubscriber在onNext()方法中处理接收到的字符串,然后进行处理,这里是弹出Toast.

    需要注意的是,当call()中subscriber处理完所有的事件后,需要发送onCompleted()或者onError()方法来终结此次任务

    好了,今天的任何到此为此,没有什么学习量,我们一步一步来,把那些知识要点在未来日子中一个一个地拿下。

    希望初学者跟我一起学得轻松。

    未完待续。。。。

    展开全文
  • RxAndroid学习demo自己写的经过实践的大家一起学习研究
  • RxAndroid 官方demo理解

    千次阅读 2015-12-24 18:25:07
    package com.rxandroid.test1; import android.os.Bundle; import android.os.Handler; import android.os.HandlerThread; import android.os.Process; import android.support.v7.app.AppCompatActivity; import a
    package com.rxandroid.test1;
    
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.HandlerThread;
    import android.os.Process;
    import android.support.v7.app.AppCompatActivity;
    import android.util.Log;
    import android.view.View;
    
    import java.util.concurrent.TimeUnit;
    
    import rx.Observable;
    import rx.Subscriber;
    import rx.android.schedulers.AndroidSchedulers;
    import rx.android.schedulers.HandlerScheduler;
    import rx.exceptions.OnErrorThrowable;
    import rx.functions.Func0;
    
    public class MainActivity extends AppCompatActivity {
        private static final String TAG = "------RxAndroidSamples";
    
        private Handler backgroundHandler;
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
    
            setContentView(R.layout.activity_main);
    
            //创建子线程handler
            BackgroundThread backgroundThread = new BackgroundThread();
            backgroundThread.start();
            backgroundHandler = new Handler(backgroundThread.getLooper());
    
            findViewById(R.id.button_run_scheduler).setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View v) {
                    onRunSchedulerExampleButtonClicked();
                }
            });
        }
    
        /**
         * 整个流程就如同 取款机:
         * 先输入取款数目,(订阅,要钱的需求)
         * 然后取款机自动吐出对应数目的钱(观察输入信号)
         */
        void onRunSchedulerExampleButtonClicked() {
            sampleObservable()
                    // Run on a background thread
                    .subscribeOn(HandlerScheduler.from(backgroundHandler))//订阅在子线程
                    // Be notified on the main thread
                    .observeOn(AndroidSchedulers.mainThread())//观察在主线程,也就是结果会在主线程中执行
                    .subscribe(new Subscriber<String>() {
                        @Override
                        public void onCompleted() {
                            Log.d(TAG, "onCompleted()");
                            Log.d(TAG, "SubscriberThread:" + Thread.currentThread().getName());//Main
                        }
    
                        @Override
                        public void onError(Throwable e) {
                            Log.e(TAG, "onError()", e);
                        }
    
                        @Override
                        public void onNext(String string) {//这将会在主线程中执行
                            Log.d(TAG, "onNext(" + string + ")");
                        }
                    });
        }
    
        static Observable<String> sampleObservable() {
            return Observable.defer(new Func0<Observable<String>>() {//定义一个方法,接口中的方法返回Observable<String>
                @Override
                public Observable<String> call() {
                    try {
                        // Do some long running operation
                        Thread.sleep(TimeUnit.SECONDS.toMillis(5));//睡眠5s
                        Log.d(TAG, "ObservableThread:" + Thread.currentThread().getName());
                    } catch (InterruptedException e) {
                        throw OnErrorThrowable.from(e);
                    }
                    return Observable.just("one", "two", "three", "four", "five");//发布5个字符串,子线程中
                }
            });
        }
    
        /**
         * 创建子线程的handler或者说looper
         */
        static class BackgroundThread extends HandlerThread {
            BackgroundThread() {
                super("SchedulerSample-BackgroundThread", Process.THREAD_PRIORITY_BACKGROUND);
            }
    
        }
    }
    

    展开全文
  • 这是我写的一篇博客:http://blog.csdn.net/adzcsx2/article/details/51333890 中解决Android中RxJava内存泄漏问题的Demo,以及如何封装,加上Retrofit,okhttp搭建好的未完成框架。方便其他人学习。5月13号更新
  • Androidstudio使用RXjava/RxAndroid需要在build.gradle添加引用 compile 'io.reactivex:rxjava:1.3.0' compile 'io.reactivex:rxandroid:1.2.1' 两种写法: 普通写法: Observable.just(getList())....

    Androidstudio使用RXjava/RxAndroid需要在build.gradle添加引用

    compile 'io.reactivex:rxjava:1.3.0'
    compile 'io.reactivex:rxandroid:1.2.1'
    两种写法:
    普通写法:
    Observable.just(getList()).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers
            .mainThread()).subscribe(new Action1<List<String>>() {
        @Override
        public void call(List<String> list) {
            sayHello(list);
        }
    });
    配合jdk1.8的lambdas语法:
    
    
    Observable.just(getList()).subscribeOn(Schedulers.io()).observeOn(AndroidSchedulers
            .mainThread()).subscribe(list -> {
        sayHello(list);
    });
    github地址:https://github.com/hushendian/Rxjava-lambdas.git

    
    

    展开全文
  • RxJava是异步操作的一个库,支持被观察者的扩展。 Schedulers(调度器):解决Android主线程和多线程问题。 观察者四大要素: 1. Observable(被观察者) 2. Observer(观察者) 3. subscribe(订阅) 4.... 1....

    RxJava是异步操作的一个库,支持被观察者的扩展。
    Schedulers(调度器):解决Android主线程和多线程问题。
    观察者四大要素:
    1. Observable(被观察者)
    2. Observer(观察者)
    3. subscribe(订阅)
    4. 事件
    RxJava实战示例
    1. 在AndroidStudio中导入compile ‘io.reactivex:rxjava:1.0.14’
    2.

    public class MainActivity extends AppCompatActivity {
        private String TAG="MainActivity";
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            //1.创建观察者
            Observable myOnservable=Observable.create(new Observable.OnSubscribe<String>() {
                @Override
                public void call(Subscriber<? super String> subscriber) {
                    Log.i(TAG, "call: 回掉");
                    //发送事件
                    subscriber.onNext("你好,世界~");
                    subscriber.onCompleted();
                }
            });
            //2.创建被观察者
            Subscriber subscriber=new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    //执行完成
                    Log.i(TAG, "onCompleted:");
                }
    
                @Override
                public void onError(Throwable e) {
                    //执行过程中发生错误
                }
    
                @Override
                public void onNext(String s) {
                    //获取到传来的值
                    Log.i(TAG, "onNext: "+s);
                }
            };
            //3.订阅事件,被观察者订阅观察者
            myOnservable.subscribe(subscriber);
        }
    }

    执行结果

    12-21 14:16:37.731 2503-2503/demo.com.rxandroiddemo I/MainActivity: call: 回掉
    12-21 14:16:37.731 2503-2503/demo.com.rxandroiddemo I/MainActivity: onNext: 你好,世界~
    12-21 14:16:37.731 2503-2503/demo.com.rxandroiddemo I/MainActivity: onCompleted:

    操作符:
    just
    创建Observable可以用just(),相当于create();just是将create()代码简化了。
    例如

    Observable myOnservable=Observable.create(new Observable.OnSubscribe<String>() {
                @Override
                public void call(Subscriber<? super String> subscriber) {
                    Log.i(TAG, "call: 回掉");
                    //发送事件
                    subscriber.onNext("你好,世界~");
                    subscriber.onCompleted();
                }
            });

    相当于这句代码Observable myOnservable=Observable.just("你好,世界~");

    from
    可以将数组的值或者集合的值传递,例如

     //1.创建观察者
            Observable myOnservable=Observable.from(new Integer[]{1,2,3,4,5,6});
            //2.创建被观察者
            Subscriber subscriber=new Subscriber<Integer>() {
                @Override
                public void onCompleted() {
                    //执行完成
                    Log.i(TAG, "onCompleted:");
                }
    
                @Override
                public void onError(Throwable e) {
                    //执行过程中发生错误
                }
    
                @Override
                public void onNext(Integer s) {
                    //获取到传来的值
                    Log.i(TAG, "onNext: "+s);
                }
            };
            //3.订阅事件,被观察者订阅观察者
            myOnservable.subscribe(subscriber);

    执行结果

    12-21 14:41:46.078 26056-26056/? I/MainActivity: onNext: 1
    12-21 14:41:46.079 26056-26056/? I/MainActivity: onNext: 2
    12-21 14:41:46.080 26056-26056/? I/MainActivity: onNext: 3
    12-21 14:41:46.080 26056-26056/? I/MainActivity: onNext: 4
    12-21 14:41:46.080 26056-26056/? I/MainActivity: onNext: 5
    12-21 14:41:46.080 26056-26056/? I/MainActivity: onNext: 6
    12-21 14:41:46.080 26056-26056/? I/MainActivity: onCompleted:

    还有例如传递集合的值

      List<Integer> lists=new ArrayList<>();
            for (int i = 0; i < 6; i++) {
                lists.add(i);
            }
            //1.创建观察者
            Observable myOnservable=Observable.from(lists);
            //下面的代码和上面一样,省略

    defer:是被订阅者订阅观察者之后执行的,myOnservable.subscribe(subscriber);在这句代码之后执行里面的回掉

    public class MainActivity extends AppCompatActivity {
        private String TAG="MainActivity";
        private String msg="";
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            //1.创建观察者
            Observable myOnservable=Observable.defer(new Func0<Observable<String>>() {
                @Override
                public Observable call() {
                    return Observable.just(msg);
                }
            });
            //2.创建被观察者
            Subscriber subscriber=new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    //执行完成
                    Log.i(TAG, "onCompleted:");
                }
    
                @Override
                public void onError(Throwable e) {
                    //执行过程中发生错误
                }
    
                @Override
                public void onNext(String s) {
                    //获取到传来的值
                    Log.i(TAG, "onNext: "+s);
                }
            };
            msg="练习";
            //3.订阅事件,被观察者订阅观察者
            myOnservable.subscribe(subscriber);
        }
    }

    可以将练习打印出来
    而用just代码则不可以,注:主要是练习赋值的地方不一样

    public class MainActivity extends AppCompatActivity {
        private String TAG="MainActivity";
        private String msg="";
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            //1.创建观察者
            Observable myOnservable=Observable.just(msg);
            //2.创建被观察者
            Subscriber subscriber=new Subscriber<String>() {
                @Override
                public void onCompleted() {
                    //执行完成
                    Log.i(TAG, "onCompleted:");
                }
    
                @Override
                public void onError(Throwable e) {
                    //执行过程中发生错误
                }
    
                @Override
                public void onNext(String s) {
                    //获取到传来的值
                    Log.i(TAG, "onNext: "+s);
                }
            };
            msg="练习";
            //3.订阅事件,被观察者订阅观察者
            myOnservable.subscribe(subscriber);
    
        }
    }

    Interval:相当于一个定时器,可以定间隔的时间发送一个值
    range(int a,int b):从a–>b之间的值依次传递
    Repeat(n):n次重复的发送值
    start:开始发送一个值
    Timer:也相当于一个定时器发送值

    展开全文
  • Retrofit2+Rxjava2+OKHttp3+RxAndroid 实现网络请求的demo案例

    万次阅读 热门讨论 2018-10-11 18:39:51
    在之前的项目中一直都用着比较老的网络框架,比如volly,okgo,okhttp等等,平时写demo 的时候偶尔也会用到新的框架拿来练练手,这两天写了一个关于retrofit2的案例,分享出来。 大牛们恐怕已经写到烂的了,有不足...
  • RxAndroid配合MVP模式,执行网络操作并更新ui的demo
  • 使用OkHttp3(OkHttp) Retrofit2 Rxjava(RxAndroid) Rxlifecycle Rxbus构建的DEMO项目
  • RxAndroid的基础使用

    2019-09-11 19:24:36
    android系统为我们提供了Handler这个类帮助我们进行线程间的通信和切换,但是GitHub上也有很多其他非常优秀的开源框架来帮助我们进行异步处理,比如今天学习的RxAndroid。 简介 GitHub传送门:...
  • 这是一个简单的demo(登陆返回),保存下来,以后时不时的看看而已 MVP分为M层 V层 P层 M->biz,登陆逻辑,登陆返回 V->一个接口,反馈给MainActivity P->连接biz与View的纽带,请求biz获取数据,使用V更改界面先写...
  • 这里就简单的介绍RxJava的 变换 操作map()和flatMap(),RxJava1.0和RxJava2.0 的传进去的参数有点不同,1.0传进去的是一个 Func1 ,而2.0传进去的是一个 Function。变换 有一个相同点:它也是把传入的参数转化之后...
  • android RxJava(RxAndroid)的简单使用

    万次阅读 2018-08-17 12:30:18
    今天,简单讲讲android里如何使用RxJava(RxAndroid)。   Android框架系列: 一.android EventBus的简单使用 二.android Glide简单使用 三.android OKHttp的基本使用详解 四.android RxJava(RxAndroid)的...
  • Android Retrofit + RxAndroid

    2016-08-03 17:03:33
    Android Retrofit+RxAndroid实现网络请求框架
  • 最近retrofit很火,于是写了一个demo,集成retrofit,rxjava,rxandroid。与大家一起分享。参见csdn:http://blog.csdn.net/fesdgasdgasdg/article/details/51873632
  • RxAndroid之简单网络请求,数据操作

    千次阅读 2016-12-09 16:49:21
    先看一下数据操作吧,这里基本讲解都一样,我是按照官网的demo加上看的资料写的package com.fanyafeng.rxandroid.activity;import android.content.Intent; import android.os.Bundle; import android.provider....
  • 首先需要引入类库 /*网络请求*/ implementation 'com.squareup.retrofit2:retrofit:2.2.0' implementation 'com.squareup.retrofit2:retrofit-converters:2.2.0' implementation '...
  • RxJava&RxAndroid使用示例,内附使用说明手册
  • 用RxJava写的一个Android的小Demo

    千次阅读 2015-12-17 09:14:51
    其实有初略地看了一点,但是感觉比较难理解,还是先写一个小Demo来熟悉一下。关于RxJava的有关介绍可以看看这个博客http://blog.csdn.net/lzyzsd/article/details/41833541下面是我摘录的一些有关于RxJava的介绍:...
  • 最近看了retrofit框架,比较新的网络访问请求框架,很多项目都涉及到,所以学习了一下,做个总结。... compile ‘io.reactivex:rxandroid:1.1.0’ compile ‘io.reactivex:rxjava:1.1.0’ compil
1 2 3 4 5 ... 20
收藏数 1,824
精华内容 729
热门标签
关键字:

demo rxandroid