RxJava系列教程之介绍篇（一）

RxJava系列教程：
RxJava系列教程之介绍篇（一）
RxJava系列教程之创建篇（二）
RxJava系列教程之变换篇（三）
RxJava系列教程之过滤篇（四）
RxJava系列教程之线程篇（五）

---

序言

RxJava是目前很火的开源框架之一，主要能够让你的代码逻辑变的很清晰，而且使用起来很方便，现在我们就来开始学习这个框架究竟牛逼在什么地方。

介绍之外貌协会

rxjava通过链式操作给人使用方便的感觉，我们来看看一个rxjava的长相：

 Observable
        .just("1","2","3","4")
        .map(new Func1<String, Integer>()
        {

            @Override
            public Integer call(String str)
            {
                return Integer.parseInt(str);
            }
        })
        .subscribeOn(Schedulers.io())
        .observeOn(Schedulers.newThread())
        .subscribe(new Action1<Integer>()
        {

            @Override
            public void call(Integer i)
            {
                System.out.println("打印结果" + i);
            }
        });

嗯？平平无奇，看不出有什么特别的，但是这东西一直点下去貌似又些许牛逼的感觉。有人说，这有什么牛逼的，一直点下去的这种代码我也会写，于是有人写了一个这样的实体类：

public class Student
{
    private String id;
    private String name;
    private String gender;
    private int age;
    private String tel;

    public String getId()
    {
        return id;
    }
    public Student setId(String id)
    {
        this.id = id;
        return this;
    }
    public String getName()
    {
        return name;
    }
    public Student setName(String name)
    {
        this.name = name;
        return this;
    }
    public String getGender()
    {
        return gender;
    }
    public Student setGender(String gender)
    {
        this.gender = gender;
        return this;
    }
    public int getAge()
    {
        return age;
    }
    public Student setAge(int age)
    {
        this.age = age;
        return this;
    }
    public String getTel()
    {
        return tel;
    }
    public Student setTel(String tel)
    {
        this.tel = tel;
        return this;
    }
}

使用：

 new Student()
 .setId("001")
 .setName("张三")
 .setAge(18)
 .setGender("男")
 .setTel("110");          

但是RxJava会只是那么简单吗[贱笑]，我们还是先来看看他的正常介绍。

介绍-观察者模式

上面介绍了他的长相，下面我们来看看他的内在。
我知道我必须先把RxJava的核心东西说出来，观察者模式，可能有小伙伴不是很清楚观察者模式是个什么东西，我先说个概念，就是被观察者的一举一动都在观察者的眼中，但是观察者只观察被观察者的其中一个行为，当被观察者做出了这个行为之后，观察者会做出相应的行为。当然，在此之前，被观察者需要给观察者观察的权利，也就是需要和观察者一个订阅关系。
我来做个比喻，假设有一个灯和一个开关，灯和开关用线连着(订阅关系)，当开关被打开的时候，灯也就跟着亮了，就这么一个小小的场景，我们来将观察者模式硬塞进去。
灵魂画师登场！

根据一个东西做出一个行为，另一个东西就会做出另一个行为，我们来对以上2个东西定义，谁是观察者，谁是被观察者。那么结果就很明显了，必须开关是被观察者，灯是观察者，因为灯一直盯着开关，当开关被打开的时候，灯就会亮起来！

使用方式

大家大概明白了rxjava的内在，我们就开始使用吧，至于如何使用，传送门-RxJava，在gradle配置一句话：

compile "io.reactivex.rxjava2:rxjava:2.x.y"

我们继续吧！
首先既然是观察者模式，那么被观察者和观察者一定是要有的了。那么在RxJava中怎么创建一个基本的被观察者呢？
上代码！

// 被观察者
Observable<String> observable = Observable.create(new OnSubscribe<String>(){
            @Override
            public void call(Subscriber<? super String> sub)
            {

            }
        });

长的像接口一样的东西出现了！这是什么鬼，等等，话说观察者模式是有点接口回调机制的样子，看来是这样没跑了。不懂接口回调的可以看看这篇文章——一个例子让你彻底理解java接口回调。
回到正题。
这个就是被观察者了，至于里面的这个接口是什么，这大括号里面又该填什么东西，听我细细道来。
首先，这个被观察者本身是不作出任何行为的，也是为了代码的耦合性，我们用里面的Subscriber来做出行为，先不管Subscriber这个是干嘛的，你只需要知道这个东西可以让被观察者表达他的行为就可以了。

Observable<String> observable = Observable.create(new OnSubscribe<String>()
        {
            @Override
            public void call(Subscriber<? super String> sub)
            {
                sub.onNext("1");
                sub.onNext("2");
                sub.onNext("3");
                sub.onCompleted();
            }
        });

于是这个被观察者做了4次行为，我们可以看到onNext这个行为做了3次，为了让行为有区别，我们在里面传递了不同的数据，既然被观察者已经行动了，那么观察者也不能闲着，召唤观察者的方式如下：

// 观察者
Observer<String> observer = new Observer<String>()
        {

            @Override
            public void onNext(String str)
            {
            }

            @Override
            public void onError(Throwable e)
            {
            }

            @Override
            public void onCompleted()
            {
            }
        };

我擦嘞，居然又是接口，还有3个重写方法，等等，第一个onNext()方法有点熟悉啊，没错，被观察者里面我们使用了sub.onNext()这个，被观察者里面我们传进来了一次参数，观察者这里的onNext又给我们了一个String类型的参数，难道。。。
没错！这就是被观察者传给我们的参数，被观察者做了onNext这个行为并传了一个参数后，观察者的onNext方法将会捕获到，并且得到行为的参数。
那么onError和onCompleted有什么用，是这样的，这就相当于一个异常捕获了对不对，你可以在被观察者里面做一个网络异常捕获啊，比如：

Observable<String> observable = Observable.create(new OnSubscribe<String>()
        {
            @Override
            public void call(Subscriber<? super String> sub)
            {

                 try
                {
                    URL url = new URL(url);
                    sub.onNext("1");
                    sub.onNext("2");
                    sub.onNext("3");
                }
                catch (MalformedURLException e)
                {
                    sub.onError(e);
                }finally {
                    sub.onCompleted();
                }

            }
        });

这样，观察者就知道被观察者什么时候会发生错误的行为了，然后就可以做出相应操作了，在最后调用下onCompleted，完美收官！

先别扯远了，我们来试着打印下被观察者传递给观察者的参数

 Observer<String> observer = new Observer<String>()
        {

            @Override
            public void onNext(String str)
            {
                System.out.println(str);
            }

            @Override
            public void onError(Throwable e)
            {
            }

            @Override
            public void onCompleted()
            {
                System.out.println("完成！");
            }
        };

那么这两个东西要怎么联系起来，订阅！没错让这2个东西关联起来的方式就是让他们相互关联！
被观察者要赋予观察者观察的权利，所以顺序是代码长这个样子：

// 被观察者订阅观察者
observable.subscribe(observer);

运行结果：

1
2
3
完成！

没错，当被观察者发送完所有的事件后，就会自动调用onCompleted方法，这就像是异常捕获中的finally一样。

看到这里，有看官要吐槽了，这。。有毛用啊！敲那么多代码，就打印个123，浪费老子时间，老子不用这个了，老子走了！
等等，您老先别走，这只是rxjava的基础形态，再多感受一点东西，你就会知道rxjava的强大之处。

总结

rxjava中：
我们从本篇文章能够学习到的东西有：
1.如何创建一个链式设置的实体[偷笑]
2.什么是观察者模式
3.如何创建一个被观察者和观察者
4.如何实现他们之间的订阅关系
注：
被观察者和观察者形成订阅关系后，当被观察者做出onNext的行为时，会让观察者捕获到，观察者也可以做出相应的事情，这里要注意的是，我们所说的行为是指onNext、onError、onCompleted这些行为。

下集预告：本篇我们创建了被观察者，但是这种看这好复杂啊，有没有什么简单点的方式创建呢，答案当然是有的！下篇我们会介绍被观察者的花式创建方法！敬请期待！