关于RxJava，Scheduler 调度器，map事件转换的过程与原理

  在这里首先简单的描述一下本文的具体内容；

1，将RxJava的多种使用方法，通过简单案例的形式展示给大家，并且带有备注，

2，之后，在RxJava基本使用方法的基础上，增添以下Scheduler 调度器的使用，来进行线程等的切换，

3，如何将RxJava内部的一些事件进行转换，如何单个转换，如何整个转换；

可能过程案例比较多，各取所需吧》》》》

1,（a）第一种写法（分步的，如果有喜欢连用的可连用）：

/**
 * 演示RxJava的介绍以及基本使用
 *
 * 1.RxJava是什么?
 *    RxJava本质就是一个实现异步操作的库  异步
 *
 * 2.RxJava优点  简洁(随着程序的逻辑变得复杂 可以将复杂的逻辑代码串成一条线)
 *
 * 3.原理 RxJava异步实现 拓展的观察者模式
 *
 *  观察者模式:A对象(观察者)对B(被观察者)对象的某种变化比较敏感  需要在B对象变化的瞬间
 *  作出反应 程序中的观察者模式 采用注册或者订阅方式 告诉被观察者当他变化是通知观察者
 *
 *  android应用中的观察者案例 view视图绑定单击事件
 *  view被观察者－－－onClickListener单击事件的监听器 观察者
 *    注册/订阅 setOnClickListener()
 *  当单击view视图时 通知onClickListener单击事件的监听器观察者对象作出响应(回调onClick方法)
 *
 * RxJava中观察者模式
 * RxJava中四个基本概念 Observable(被观察者) Observer(观察者)
 *  Subscribe(订阅/注册)
 *  Observable(被观察者) Observer(观察者)通过Subscriber()方法实现订阅关系
 *  Observable需要时发出事件通知Observer
 *
 */
public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //1.创建Observer观察者对象 他主要决定事件触发时有怎么样的行为
        Observer<String> observer=new Observer<String>() {
            /**
             * 事件队列操作完毕时回调的寒肃
             * rxjava中事件处理时不仅可以单独处理还可以看作事件队列
             *
             * 作为事件结束的标志
             */
            @Override
            public void onCompleted() {
                Log.i("tag","------onCompleted------");
            }

            /**
             * 事件处理过程中出现异常的时候回调
             * onError()被触发 整个的事件的处理中止
             * 注意:onCompleted()和onError()互斥  正常的事件处理过程中只会调用其中一个函数
             */
            @Override
            public void onError(Throwable e) {
                e.printStackTrace();
            }

            /**
             * 类似与view中 OnClickListener中的onClick方法
             *  主要对被观察者触发的事件处理的方法
             */
            @Override
            public void onNext(String s) {
                Log.i("tag","-------onNext-----"+s);
            }
        };

        //2.创建被观察者对象 他决定什么时候触发事件以及触发怎么样的事件
        /*
        Observable.create() RxJava中创建事件序列的方法
        create()方法中需要传入OnSubscribe对象 OnSubscribe存储到Observable对象中(计划表)
        当Observable被订阅时 OnSubscribe接口中的call()会被回调 事件的序列才会依次执行触发
         */
        Observable observable=Observable.create(new Observable.OnSubscribe<String>() {
            @Override
            public void call(Subscriber<? super String> subscriber) {
                subscriber.onNext("Hello");
                subscriber.onNext("hi");
                subscriber.onNext("how are you");
                subscriber.onCompleted();
            }
        });

        //3. 订阅 注册  view.setOnClicklistener(onClickListener)
        observable.subscribe(observer);
    }
}

1（b）(第二种写法)

/**
 * 演示RxJava中的变换写法
 */
public class MainActivity02 extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        /**
         * RxJava中有一个具体实现Observer抽象类的类 Subscriber
         * Subscriber是Observer观察者类的具体子类 对Observer观察者进行了拓展
         * 如果只是使用基本功能 Subscriber、Observer基本一样
         * 区别：
         * 1.Subscriber类中增加了onStart()方法
         * 2.unSubscribe()取消订阅 当该方法被调用后 Subscriber将不再接收事件
         */
        Subscriber<String> subscriber=new Subscriber<String>() {
            @Override
            public void onCompleted() {
                Log.i("tag","------onCompleted------");
            }

            @Override
            public void onError(Throwable e) {
                 e.printStackTrace();
            }

            @Override
            public void onNext(String s) {
                Log.i("tag","-------onNext-----"+s);
            }

            /**
             * Subscriber中添加的方法  表示在事件发送之前被调用 准备工作  数据清零重置操作
             */
            @Override
            public void onStart() {
                super.onStart();
            }
        };



        //2.创建被观察者对象 他决定什么时候触发事件以及触发怎么样的事件
//        Observable observable=Observable.create(new Observable.OnSubscribe<String>() {
//            @Override
//            public void call(Subscriber<? super String> subscriber) {
//                subscriber.onNext("Hello");
//                subscriber.onNext("hi");
//                subscriber.onNext("how are you");
//                subscriber.onCompleted();
//            }
//        });

        //just() 将传入的参数作为onNext()方法的参数进行使用
//        Observable observable=Observable.just("Hello","Hi","how are you");


        String[] array={"Hello","Hi","how are you"};
        Observable observable=Observable.from(array);


        //3. 订阅 注册  view.setOnClicklistener(onClickListener)
//        observable.subscribe(observer);
        observable.subscribe(subscriber);
    }
}

1（c）第三种写法，使用的action的封装方法：这里的call其实就是，next(),complete()等的拆分，都
被叫做call,大家不要混乱
<pre name="code" class="java">/**
 * 演示RXJava中Action1 Action0对Observer封装的写法
 */
public class ActionActivity extends AppCompatActivity{
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        /**
         * Action0是RxJava中的接口 具有一个方法call()  该方法无参数 无返回值
         * Observer观察者类中onCompleted()也是无参数无返回值  Action0当作
         * 一个包装对象  将onCompleted()的内容打包作为参数进行提供给subscribe()
         * 进行使用  不完整定义的回调
         */
        Action0 completed=new Action0() {
            @Override
            public void call() {
                Log.i("tag","--------onComplted----");
            }
        };

        /**
         *  Action1 也是一个接口 具有一个call(T t) 该方法具有一个参数无返回值
         *  对onNext()方法的封装作为不完整定义的回调
         */
        Action1<String> nextAction=new Action1<String>() {
            @Override
            public void call(String s) {
                Log.i("tag","-------onNext----"+s);
            }
        };

        Action1<Throwable> errorAction=new Action1<Throwable>() {
            @Override
            public void call(Throwable throwable) {
                throwable.printStackTrace();
            }
        };


        Observable observable=Observable.just("Hello","Hi");
        observable.subscribe(nextAction,errorAction,completed);
    }
}
/*
 Observer<String> observer=new Observer<String>() {
            @Override
            public void onCompleted() {}

            @Override
            public void onError(Throwable e) {}

            @Override
            public void onNext(String s) {}
        }
 */
三种写法都写了，下面我通过整体的写法展示给大家，然后将其中加上一些调度和事件转换的使用

<pre name="code" class="java">/**
 * RxJava出现就是为了实现异步操作 后台处理[工作线程处理耗时操作] 前台调用[UI线程调用显示]
 * Scheduler 调度器  线程的控制器   RxJava中通过该对象指定每一段代码运行在哪个线程中
 *  RxJava中内置的调度器
 *  Schedulers.immediate()  默认scheduler 直接在当前线程中执行
 *  Schedulers.newThread() 表示启动新的线程 并且代码在新线程中执行操作
 *  Schedulers.io() io操作线程（读写文件 读写数据库 网络信息交互等）
 *    io()与newThread()行为模式类似  区别:io()内部无数量上限的线程池
 *    比newThread()更高效
 *  Schedulers.computation() 复杂的计算使用调度器
 *
 * RxAndroid中专门的AndroidSchedulers.mainThread()将操作放到android的主线程/ui线程中执行
 */
public class SchedulerActivity extends AppCompatActivity{
    private ImageView iv;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        iv= (ImageView) findViewById(R.id.iv_show);
        Observable.create(new Observable.OnSubscribe<Drawable>() {
            @Override
            public void call(Subscriber<? super Drawable> subscriber) {
                Drawable drawable=getResources().getDrawable(R.mipmap.cat);
                subscriber.onNext(drawable);
                subscriber.onCompleted();
            }
        })      /**
         subscribeOn()指定事件发生的线程 就是Observable.OnSubscribe被调用时所处的线程
         表示Observable被观察者对象中的call方法执行的线程
                */
                .subscribeOn(Schedulers.io())
                /**
                 * observeOn() 表示Observer观察者运行的线程 事件的消费线程
                 */
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Observer<Drawable>() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Drawable drawable) {
                iv.setImageDrawable(drawable);
            }
        });
    }
}

事件转换：案例一：

<pre name="code" class="java">/**
 * 演示 RxJava中对事件的转换
 * 事件转换:将事件序列中对象或者是整个事件序列进行加工处理 转换成不同的事件序列
 */
public class MapActivity extends AppCompatActivity {
    private ImageView imageView;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        imageView = (ImageView) findViewById(R.id.iv_show);
        //图片的路径(字符串)--bitmap图片的对象进行展示
        final String filePath = Environment.getExternalStorageDirectory().getAbsolutePath() +
                File.separator + "dog.jpg";
        Observable.just(filePath)

                /**
                 * map()对事件转换的方法  参数Func1
                 * Func1也是RxJava中的接口 与Action1类似 用于包装具有一个参数的函数
                 *
                 * Func1和Action1的区别
                 * Func1 包装具有返回值的方法
                 * Action1 包装无返回值的方法
                 *
                 * Func1<需要转换的事件的类型,转换后的结果类型>
                 *   Func1底层对create()方法的封装 将String字符串转换成bitmap封装到
                 *   Observable被观察者对象中
                 */
                .map(new Func1<String, Bitmap>() {
                    @Override
                    public Bitmap call(String s) {
                        return BitmapFactory.decodeFile(s);
                    }
                })
                .subscribe(new Action1<Bitmap>() {
                    @Override
                    public void call(Bitmap bitmap) {
                        imageView.setImageBitmap(bitmap);
                    }
                });
    }
}

案例二：

<pre name="code" class="java">/**
 * 演示RxJava中对整个事件序列的转换
 */
public class FlatMapActivity extends AppCompatActivity{
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);


       //2.需求:Student类中加入需要学习的课程名称 区别:每个学生只有一个名字 但是可以学习多门课程
        List<Course> list01=new ArrayList<>();
        list01.add(new Course(1,"语文"));
        list01.add(new Course(2,"数学"));
        final Student stu01=new Student(1,"张三",list01);
        List<Course> list02=new ArrayList<>();
        list02.add(new Course(1,"Android"));
        list02.add(new Course(2,"Java"));
        Student stu02=new Student(2,"李斯",list02);
        Student[] stus={stu01,stu02};

        /**
         * flatMap()和map()共同点 都是对传入的参数转换返回另一个对象
         * 不同点:flatMap()转换后返回是Observable对象
         */
        Observable.from(stus)
                .flatMap(new Func1<Student, Observable<Course>>() {

                    @Override
                    public Observable<Course> call(Student student) {
                        return Observable.from(student.getCourses());
                    }
                })
                .subscribe(new Observer<Course>() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(Course course) {
                        Log.i("tag","----course-----"+course.getCourseName());
                    }
                });
    }
}