JC_Mobile
JC_Mobile

RxJava从今以后你就会了

RxJava技术分享

京金所—时光

2016.9.22

这里我拿出来给 Android 开发者的 RxJava 详解中的例子

假设有这样一个需求：界面上有一个自定义的视图 imageCollectorView ，它的作用是显示多张图片，并能使用 addImage(Bitmap) 方法来任意增加显示的图片。现在需要程序将一个给出的目录数组 File[] folders 中每个目录下的 png 图片都加载出来并显示在 imageCollectorView 中。需要注意的是，由于读取图片的这一过程较为耗时，需要放在后台执行，而图片的显示则必须在 UI 线程执行。常用的实现方式有多种，我这里贴出其中一种：

`

//开启一条子线程
new Thread() {
@Override
public void run() {
    super.run();
    //遍历给出的目录数组，获取每一个目录里面的文件的数组
    for (File folder : folders) {
        File[] files = folder.listFiles();
        //遍历这个文件数组，筛选出来png图片
        for (File file : files) {
            if (file.getName().endsWith(".png")) {
                //将路径转换成Bitmap图片
                final Bitmap bitmap = getBitmapFromFile(file);
                //切换到主线程更新UI。
                getActivity().runOnUiThread(new Runnable() {
                    @Override
                    public void run() {
                        imageCollectorView.addImage(bitmap);
                    }
                });
            }
        }
    }
}

}.start();

`

而如果使用 RxJava ，实现方式是这样的：

`
//将文件夹目录创建成一个可观测的序列

Observable.from(folders)

//遍历目录数组中的每一个文件对象，并将这每一个文件对象转换成可观测序列
.flatMap(new Func1>() {
    @Override
    public Observable call(File file) {
        return Observable.from(file.listFiles());
    }
})
//对这每一个文件对象进行过滤，选出png图片
.filter(new Func1() {
    @Override
    public Boolean call(File file) {
        return file.getName().endsWith(".png");
    }
})
//将这每一个png文件都转成Bitmap传递
.map(new Func1() {
    @Override
    public Bitmap call(File file) {
        return getBitmapFromFile(file);
    }
})
//耗时操作运行在子线程
.subscribeOn(Schedulers.io())
//修改UI的操作放在主线程
.observeOn(AndroidSchedulers.mainThread())
//订阅，展示
.subscribe(new Action1() {
    @Override
    public void call(Bitmap bitmap) {
        imageCollectorView.addImage(bitmap);
    }
});

`

今天主要从以下几个方面来着重介绍RxJava

  • RxJava的重要概念
  • RxJava的操作符
  • RxJava的应用场景

一：RxJava的重要概念

1.1 什么是RxJava？

RxJava 在 GitHub 主页上的自我介绍是 "a library for composing asynchronous and event-based programs using observable sequences for the Java VM"（一个在 Java VM 上使用可观测的序列来组成异步的、基于事件的程序的库）。

到底什么是RxJava，一个词，就是异步。两个词就是异步+链式操作。

1.2 RxJava难吗？

RxJava其实一点也不难。RxJava能做到的东西，别人也一样可以做到。但是，如果使用RxJava，那么可以比他们逻辑更简洁。有人说Rx太好用了，也有人说RxJava太难用了。好用是因为RxJava使用操作符（函数式编程）极大的简化了我们代码编写的逻辑，难用可能就是对操作符用的还不习惯，对命令式编程的思想有些固话。

1.3 但是很多人说学习RxJava起点高啊？

高在哪里。我认为是几个重要的思想。在我刚学习Java语言的时候，我认识了面向对象的编程思想。简单来说就是指挥对象帮我们做事。通过一个点.即可。同样，我认为学习RxJava也是学习一个编程思想。就是函数式编程，和响应式编程。我不知道这算不算是编程思想，但我知道一旦明白这两个东东，对我们学习Rx有着意想不到的好处。

今天，今天通过介绍 Rx里面的概念(这部分我觉得才是最重要的一点)，Rx里面的操作符，Rx里面的常用场景，还有Rx的扩展，将读者带入Rx的大门，了解他，触摸它，使用它，掌握它。

1.4 响应式编程：

什么是响应式编程(Reactive programming)？ RxJava ==>ReactiveX Java

百度百科的定义：

响应式编程是一种==面向数据流和变化传播==的==编程范式==。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。

例如，在命令式编程环境中(面向过程和面向对象的语言中)，a=b+c表示将表达式的结果赋给a，而之后改变b或c的值不会影响a。但在响应式编程中，a的值会随着b或c的更新而更新。响应式编程最初是为了简化交互式用户界面的创建和实时系统动画的绘制而提出来的一种方法，但它本质上是一种通用的编程范式。

这里什么是编程范式呢？说白了就是一种编码的风格和模式。

此时，我们不免会疑惑，数据我们知道，那么数据流呢？

在RxJava Essentials一书中，是这么说的。

响应式编程是一种基于异步数据流概念的编程模式。数据流就像一条河：它可以被观测，被过滤，被操作，或者为新的消费者与另外一条流合并为一条新的流。

响应式编程的一个关键概念是事件。事件可以被等待，可以触发过程，也可以触发其它事件。

我相信看到这里大部分人已经晕了。
不过我是越来越清晰，一字一句的多读几遍。

在那些年我们错过的响应式编程中是这么介绍的：

响应式编程就是与异步数据流交互的编程方式。（和上面基本一样）

一方面，这已经不是什么新事物了。事件总线(Event Buses)或一些典型的点击事件本质上就是一个异步事件流(asynchronous event stream)，这样你就可以观察它的变化并使其做出一些反应(do some side effects)。响应式是这样的一个思路：除了点击和悬停(hover)的事件外，你可以给任何事物创建数据流。数据流无处不在，任何东西都可以成为一个数据流，例如变量、用户输入、属性、缓存、数据结构等等。举个栗子，你可以把你的微博订阅功能想象成跟点击事件一样的数据流，你可以监听这样的数据流，并做出相应的反应。

最重要的是，你会拥有一些令人惊艳的函数去结合、创建和过滤任何一组数据流。 这就是”函数式编程”的魔力所在。一个数据流可以作为另一个数据流的输入，甚至多个数据流也可以作为另一个数据流的输入。你可以合并两个数据流，也可以过滤一个数据流得到另一个只包含你感兴趣的事件的数据流，还可以映射一个数据流的值到一个新的数据流里。

最后我说一下我的理解:

首先响应式编程仅仅是一种编程的模式，风格，并不具有特殊的含义和操作，响应式编程他是用来对数据流进行操作的，所有对数据流进行异步操作，观测等行为，我们都可以管这种操作行为叫做响应式编程。那么什么又是数据流呢？

1.4 数据流的概念：

数据流是整个响应式编程体系中的核心，要想学习响应式编程，首先我们就需要搞明白什么是数据流。其实，一个数据流是一个按时间排序的即将发生的事件(Ongoing events ordered in time)的序列。就比如我们警察抓小偷，小偷偷东西的时候，警察抓住他了吗，小偷偷东西之前做了什么，之后做了什么，警察抓他之前做了什么，抓住他做了什么或者没抓住又该怎么去做。这一系列事件组成的序列就是数据流。数据流就像一条河：它可以被观测，被过滤，被操作，或者为新的消费者与另外一条流合并为一条新的流。

也就是说我们的响应式编程，就是对这一系列异步事件进行处理的一种编程模式。其实，你会发现，看了一大圈，又回到了第一句话，但是我相信，你现在应该不会在迷糊了。

1.5 函数式编程:

其实我一直搞不明白函数式编程和响应式编程。但是现在我明白了，而且他俩根本就不一样。

1.5.1 什么是函数式编程:

应该有至少三种编程思想：

  • 命令式编程 Imperative programming
  • 逻辑式编程 Object-oriented Programming
  • 函数式编程 Functional Programming

命令式编程关心解决问题的步骤，面向对象编程是也是一种命令式编程，面向过程的C语言必然也是了。
而函数式编程关心数据的映射，即一种东西和另一种东西之间的对应关系。它的主要思想是把运算过程尽量写成一系列嵌套的函数调用。

比如这种运算：(1 + 2) * 3 - 4 ;
之前我们写是这样：

```
int a = 1 + 2; int b = a * 3; int result = b - 4;
System.out.println(b);
```

然而用函数式编程思想写就是这样：

```
System.out.print(subtract( multiply(add(1,2)，3),4) );
```

全部变为了函数调用，这样看起来也简洁、见名之意。(示例来自阮一峰博客)

看到这，想一下，使用RxJava时是不是全部调用各种操作符进行处理，这就是对事件流进行运算啊，全部调用函数进行处理。

在这里我们来对比一下函数式编程和响应式编程。函数式编程是对数据关系进行==映射==，比如说y=ax;这个一元函数。函数式编程我们只需要定义处来这个映射关系即参数a的算法，我们就可以得到y。而响应式编程的重点则不在于这个参数a，而是当我的x发生改变的时候（就是我们注册的x的状态改变）的时候，我要做出一个什么样反应。这和我大学学到的激励和响应是差不多的。我给你一个什么样的激励，你能反馈我一个什么样的响应。

1.6 观察者模式

在今天，观察者模式是出现的最常用的软件设计模式之一。它基于subject这个概念。subject是一种特殊对象，当它改变时，那些由它保存的一系列对象将会得到通知。而这一系列对象被称作Observers(观察者),它们会对外暴漏了一个通知方法,当subject状态发生变化时会调用的这个方法。

就比如说，当A的某状态发生改变或者接收到某种激励的时候，B需要对这种激励做出一个反馈，那么我们只需要让A持有B的引用，同时去调用B的方法即可（我们最终的目的是将发生改变的状态传递出去，通过方法传递，我们的B需要这个状态）。但是通常，我们的A不知道自己什么时候能获取到这个激励（什么时候状态会发生改变），这个时候我们的B呢就可以通过注册，来处理这个响应。同时，我们也可以不用拿到B的引用，我们可以通过一个中间接口，将发生改变的状态（或者是B需要的状态）通过接口传递过去，同时B只需要拿到这个接口的实例对象即可，这就是B的注册过程。也是最简单的回调。而回调也是观察者模式的一种简化形式，1-1的关系，当然我们平时不仅setOnClickListener()也addOnXxxListener()，这种一对多的关系就是观察者模式。

1.7 扩展的观察者模式

与传统观察者模式不同， RxJava的事件回调方法除了普通事件 onNext() （相当于 onClick() / onEvent()）之外，还定义了两个特殊的事件：onCompleted() 和 onError()。

1.8 几个常见的类

在RxJava的世界里，我们有四种角色：

Observable

Observer

Subscriber

Subjects

Observables和Subjects是两个“生产”实体，Observers和Subscribers是两个“消费”实体

```
public class Observable {
    final OnSubscribe onSubscribe;
    }
public interface Observer{
    onComplete();onError;onNext();
    }
public abstract class Subscriber implements Observer, Subscription 
public abstract class Subject extends Observable implements Observer 
*/
```

总览：

Creating Observables
Operators that originate new Observables.

  • Create — create an Observable ++from scratch（从头）++ by calling observer methods ++programmatically（以编程的方式）++
  • ++Defer（延迟创建）++ — do not create the Observable until the observer subscribes, and create a fresh Observable for each observer
  • Empty/Never/Throw — create Observables that have very ++precise（精确的）++ and limited behavior
  • From — ++convert（转换）++ some other object or data structure into an Observable
  • ++Interval（间隔）++ — create an Observable that ++emits（发射）++ a sequence of integers spaced by a particular time interval
  • Just — convert an object or a set of objects into an Observable that emits that or those objects
  • Range — create an Observable that emits a range of sequential integers
  • Repeat — create an Observable that emits a particular item or sequence of items repeatedly
  • Start — create an Observable that emits the return value of a function
  • Timer — create an Observable that emits a single item after a given delay

一：Create的使用

可以通过create操作去创建一个被观察者Observable。Create是最基本的创建Observable的操作符。
RxJava从今以后你就会了_第1张图片
image

创建一个Observable（被观察者）最重要的就是要和合适的时机调用Subscriber（观察者）的onNext/onComplete/onError方法。onNext就是发射处理好的数据给Subscriber; onComplete用来告诉Subscriber所有的数据都已发射完毕；onError是在发生错误的时候发射一个Throwable对象给Subscriber。需要注意的一点就是Observable必须调用所有的Subscriber的onComplete方法并且只能调用一次，出错的时候调用onError方法也是一样的，并且一旦调用后就不能调用Subscriber的任何其他方法了。

介绍完毕。

我再详细介绍一下。

我们可以看到Observable.create(这里经常会传入一个OnSubscribe接口);

OnSubscribe接口又是什么呢？它继承自Action1这个接口，他的call（ subscriber）方法里只有一个参数，它传入了一个观察者！！！也就是说我们在使用create的时候，我们将观察者包裹在了被观察者内部。并且在被观察这订阅观察者的时候，我们通过一个hook对象将观察者Subscriber的对象传入到OnSubscribe.call(传到这里面)。这样就实现了由被观察者在订阅的时候调用观察者的方法。并且在事件完成的时候自动取消订阅。

    Observable observable = Observable.create(new Observable.OnSubscribe() {
        @Override
        public void call(Subscriber subscriber) {
            //将依次发射3次onNext ，之后发射onComplete(发射完这个将不会再有输出，同时自动取消注册)
            subscriber.onNext("Hello第一次发射");
            subscriber.onNext("World第二次发射");
            subscriber.onNext("Over 第三次发射");
            subscriber.onCompleted();
            subscriber.onError(new Throwable());
        }
    })

2.Just、From的使用

为了简化创建操作，我们平时最常使用的一般是这两个操作符。just(T...):from(T[])。

Just操作符将某个对象转化为Observable对象，并且将其发射出去，可以使一个数字、一个字符串、数组、Iterate对象等。其实当just传入一个参数的时候，就是调用create()方法，传入多参数的时候，就是调用from()方法。从而做到将参数依次发射出去

From操作符用来将某个对象转化为Observable对象，并且依次将其内容发射出去。这个类似于just，但是just会将这个对象整个发射出去。比如说一个含有10个数字的数组，使用from就会发射10次，每次发射一个数字，而使用just会发射一次来将整个的数组发射出去。


RxJava从今以后你就会了_第2张图片
image

3.Defer

Defer操作符只有当有Subscriber来订阅的时候才会创建一个新的Observable对象,也就是说每次订阅都会得到一个刚创建的最新的Observable对象，这可以确保Observable对象里的数据是最新的


RxJava从今以后你就会了_第3张图片
image

4.Interval

Interval所创建的Observable对象会从0开始，每隔固定的时间发射一个数字。需要注意的是这个对象是运行在computation Scheduler,基本上和时间有关系的都是运行在computation Scheduler 中,所以如果需要在view中显示结果，要在主线程中订阅。


RxJava从今以后你就会了_第4张图片
image

5.Range

这个应该好理解一点，看图依次发射区间（n,n+m-1）里面的数字，左闭右开


RxJava从今以后你就会了_第5张图片
image

6.Repeat、Timer

Repeat会将一个Observable对象重复发射，我们可以指定其发射的次数


RxJava从今以后你就会了_第6张图片
image

Timer会在指定时间后发射一个数字0，注意其也是运行在computation Scheduler


RxJava从今以后你就会了_第7张图片
image

总览：

Transforming Observables
Operators that transform items that are emitted by an Observable.

  • Buffer — ++periodically（定期的）++ gather items from an Observable into bundles and emit these bundles rather than emitting the items ++one at a time（一次一个）++
  • FlatMap — transform the items emitted by an Observable into Observables, then flatten the emissions from those into a single Observable
  • GroupBy — divide an Observable into a set of Observables that each emit a different group of items from the original Observable, organized by key
  • Map— transform the items emitted by an Observable by applying a function to each item
  • Scan — apply a function to each item emitted by an Observable, sequentially, and emit each successive value
  • Window — periodically subdivide items from an Observable into Observable windows and emit these windows rather than emitting the items one at a time

RxJava 提供了对事件序列进行变换的支持，这是它的核心功能之一，也是大多数人说『RxJava 真是太好用了』的最大原因。所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。

1.Buffer

Buffer操作符所要做的事情就是将数据按照规定的大小、或者时间做一下缓存，然后将缓存的数据作为一个集合发射出去。

RxJava从今以后你就会了_第8张图片
image

在上图中，按照规定的大小（count = 3）来收集数据，之后将他们整合成一个集合发射出去。
RxJava从今以后你就会了_第9张图片
image

在上图中，加入了一个skip参数用来指定 每次发射一个集合需要跳过几个数据，图中指定（count = 2,skip = 3)，就会每3个数据发射一个包含两个数据的集合，如果count==skip的话，我们就会发现其等效于第一种情况了。这里还是很好理解的。

2.flatMap & concatMap

Flatmap是一个用处特别多的操作符。它可以将数据根据你想要的规则进行转化后再发射出去。其原理就是将这个Observable转化为多个以原Observable发射的数据作为源数据的Observable，然后再将这多个Observable发射的数据整合发射出来，需要注意的是最后的顺序可能会交错地发射出来，如果对顺序有严格的要求的话可以使用concatmap操作符。


RxJava从今以后你就会了_第10张图片
image

如上图，我们按照一个圆对应两个菱形的规则，将一个Observable<圆>转换成两个Observable<菱形>。并将两个Observable<菱形>发射出去。

3.Map

Map操作符的功能类似于FlatMap，不同之处在于它对数据的转化是直接进行的，而FlatMap需要通过一些中间的Observables来进行。


RxJava从今以后你就会了_第11张图片
image

4.GroupBy

GroupBy操作符将原始Observable发射的数据按照key来拆分成一些小的Observable，然后这些小的Observable分别发射其所包含的的数据，类似于sql里面的groupBy。在使用中，我们需要提供一个生成key的规则，所有key相同的数据会包含在同一个小的Observable种。


RxJava从今以后你就会了_第12张图片
image

5.Scan

Scan操作符对一个序列的数据应用一个函数，并将这个函数的结果发射出去作为下个数据应用这个函数时候的第一个参数使用，有点类似于递归操作


RxJava从今以后你就会了_第13张图片
image

总览：过滤

Filtering Observables
Operators that selectively emit items from a source Observable.

  • Debounce — only emit an item from an Observable if a particular timespan has passed without it emitting another item
  • Distinct — suppress duplicate items emitted by an Observable
  • ElementAt — emit only item n emitted by an Observable
  • Filter — emit only those items from an Observable that pass a predicate test
  • First — emit only the first item, or the first item that meets a condition, from an Observable
  • IgnoreElements — do not emit any items from an Observable but mirror its termination notification
  • Last — emit only the last item emitted by an Observable
  • Sample — emit the most recent item emitted by an Observable within periodic time intervals
  • Skip — suppress the first n items emitted by an Observable
  • SkipLast — suppress the last n items emitted by an Observable
  • Take — emit only the first n items emitted by an Observable
  • TakeLast — emit only the last n items emitted by an Observable

1.Filter

Filter只会返回满足过滤条件的数据.比如说，我们想让数据{a1,a2,b1,v1,c1}中以v开头的数据排除掉，或者我们经常用到的AppInfo中数据为null的过滤掉，我们可以使用filter轻松实现。

RxJava从今以后你就会了_第14张图片
image

如上图，我们应该filter(东西 == 圆)

2.take/takelast

当我们不需要整个序列时，而是只想取开头或结尾的几个元素，我们可以用take()或takeLast()。


RxJava从今以后你就会了_第15张图片
image 
```
//太简单了，我就不写demo了，take（3）从前面取3个，takeLast(3)从后面取3个
 Observable.from(apps).take(3)
```

3.Distinct 有且仅有一次

我们可以对我们的序列使用distinct()函数去掉重复的。就像takeLast()一样，distinct()作用于一个完整的序列，然后得到重复的过滤项，它需要记录每一个发射的值。如果你在处理一大堆序列或者大的数据记得关注内存使用情况。
Distinct操作符的用处就是用来去重，非常好理解。如下图所示，所有重复的数据都会被过滤掉。还有一个操作符distinctUntilChanged,是用来过滤掉连续的重复数据。


RxJava从今以后你就会了_第16张图片
image

RxJava从今以后你就会了_第17张图片
image

4.First and last

first()方法和last()方法很容易弄明白。它们从Observable中只发射第一个元素或者最后一个元素。连图我都不上了。
firstOrDefault()和lastOrDefault().这两个函数当可观测序列完成时不再发射任何值时用得上。在这种场景下，如果Observable不再发射任何值时我们可以指定发射一个默认的值

5.Skip and SkipLast

skip()和skipLast()函数与take()和takeLast()相对应。它们用整数N作参数，从本质上来说，它们不让Observable发射前N个或者后N个值。如果我们知道一个序列以没有太多用的“可控”元素开头或结尾时我们可以使用它。


image

6.ElementAt

如果我们只想要可观测序列发射的第五个元素该怎么办？elementAt()函数仅从一个序列中发射第n个元素然后就完成了。+

如果我们想查找第五个元素但是可观测序列只有三个元素可供发射时该怎么办？我们可以使用elementAtOrDefault()。下图展示了如何通过使用elementAt(2)从一个序列中选择第三个元素以及如何创建一个只发射指定元素的新的Observable。


image

7.Sample

在Observable后面加一个sample()，我们将创建一个新的可观测序列，它将在一个指定的时间间隔里由Observable发射最近一次的数值：
如果我们想让它定时发射第一个元素而不是最近的一个元素，我们可以使用throttleFirst()。


RxJava从今以后你就会了_第18张图片
image

RxJava从今以后你就会了_第19张图片
image

8.Debounce

debounce()函数过滤掉由Observable发射的速率过快的数据；如果在一个指定的时间间隔过去了仍旧没有发射一个，那么它将发射最后的那个。
下图展示了多久从Observable发射一次新的数据，debounce()函数开启一个内部定时器，如果在这个时间间隔内没有新的数据发射，则新的Observable发射出最后一个数据：


RxJava从今以后你就会了_第20张图片
image

Combining Observables

1.Zip

Zip操作符将多个Observable发射的数据按顺序组合起来，每个数据只能组合一次，而且都是有序的。最终组合的数据的数量由发射数据最少的Observable来决定。


RxJava从今以后你就会了_第21张图片
image

2.Merege

Merge操作符将多个Observable发射的数据整合起来发射，就如同是一个Observable发射的数据一样。但是其发射的数据有可能是交错的，如果想要没有交错，可以使用concat操作符。当某一个Observable发出onError的时候，merge的过程会被停止并将错误分发给Subscriber，如果不想让错误终止merge的过程，可以使用MeregeDelayError操作符，会将错误在merge结束后再分发。


RxJava从今以后你就会了_第22张图片
image

1.使用Scheduler进行线程的切换

在不指定线程的情况下， RxJava 遵循的是线程不变的原则，即：在哪个线程调用订阅方法 subscribe()，就在哪个线程生产事件；在哪个线程生产事件，就在哪个线程消费事件。如果需要切换线程，就需要用到 Scheduler （调度器）。

几个常用的Api:
  • Schedulers.immediate(): 直接在当前线程运行，相当于不指定线程。这是默认的 Scheduler。
  • Schedulers.newThread(): 总是启用新线程，并在新线程执行操作。
  • Schedulers.io(): I/O 操作（读写文件、读写数据库、网络信息交互等）所使用的 Scheduler。行为模式和 newThread() 差不多，区别在于 io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 比 newThread() 更有效率。不要把计算工作放在 io() 中，可以避免创建不必要的线程。
  • Schedulers.computation(): 计算所使用的 Scheduler。这个计算指的是 CPU 密集型计算，即不会被 I/O 等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU。
  • Android 还有一个专用的 AndroidSchedulers.mainThread()，它指定的操作将在 Android 主线程运行。

有了这几个 Scheduler ，就可以使用 subscribeOn() 和 observeOn() 两个方法来对线程进行控制了。

  • subscribeOn(): 指定 subscribe() 所发生的线程，即 Observable.OnSubscribe 被激活时所处的线程。或者叫做事件产生的线程。

  • observeOn(): 指定 Subscriber 所运行在的线程。或者叫做事件消费的线程。

精简代码：（教简单就不放全部代码了）

```
 mSubscription = getObservable()//创建一个被观察者
   .subscribeOn(Schedulers.io())//指定订阅事件发生的线程
   .doOnSubscribe(new Action0() {//事件发生之前做什么事
//onStart() 也可以用作流程开始前的初始化。但是 onStart() 由于在 subscribe() 发生时就被调用了，因此不能指定线程，而是只能执行在 subscribe() 被调用时的线程。
//doOnSubscribe同样是在 subscribe() 调用后而且在事件发送前执行，但区别在于它可以指定线程。
//默认情况下， doOnSubscribe() 执行在 subscribe() 发生的线程；而如果在 doOnSubscribe() 之后有 subscribeOn() 的话，它将执行在离它最近的 subscribeOn() 所指定的线程。
                            @Override
                            public void call() {
                                mProgressBar.setVisibility(View.VISIBLE);
                                _log("按钮被点击了");
                            }
                        })
                        .observeOn(AndroidSchedulers.mainThread())//指定事件消费在那个线程里面
                        .subscribe(getSubscriber());//订阅观察者
```

### 2.使用Buffer收集数据流后在发射

Buffer顾名思义，就相当一个缓冲区，我们可以指定一个时间或者数量来收集这些数据，满足了这个事件或者数量之后，在统一发射出去。在这里我们举个例子，来学习Buffer,同时更深入的理解一个更重要的操作符map

//观察在两秒的时间内，按钮被点击的次数
 public Subscription getClickNumInTime(){
 //这里需要引入compile 'com.jakewharton.rxbinding:rxbinding:0.4.0'依赖，这样我们可以观测操作这些控件的数据流
    return RxView
    //将点击事件包装成数据（创建一个可观测的序列）流发射出去
           .clicks(tapButton)
           //这里我们可以很清楚，很明了的看到，我们将点击事件map成了Integer类型的数据
           .map(new Func1() {
               @Override
               public Integer call(Void aVoid) {
                   _log("得到了一个点击");
                   return 1;
               }
           })
           //通过Buffer指定2秒钟发射一次收集的数据
            .buffer(2, TimeUnit.SECONDS)
            //Buffer指定的线程是computation线程，我们修改UI要改变线程
            .observeOn(AndroidSchedulers.mainThread())
            .subscribe(new Subscriber>() {
                @Override
                public void onCompleted() {
                    _log("你永远不会走到这里，我不信这句话能打印处来");
                }

                @Override
                public void onError(Throwable e) {
                    _log("出错了"+e.getMessage());
                }
//一旦订阅之后，除非取消订阅，或者彻底杀死进程，否则会一直走下去，造成内存泄露
                @Override
                public void onNext(List integers) {
                    if(integers.size() > 0)
                    _log("你在两秒内一共点击了："+integers.size()+"次");
                }
            });
}


### 3.使用Debounce做TextSearch
比如说当我们输入的内容发生改变的时候，我们需要实时的去异步请求网络/数据库来提示用户某样东西也需要改变。就比如，当我输入金额的时候，没当我EditText内容发生改变的时候我去请求服务器，将得到的京金币展示在桌面上。有些时候，用户连续几个数字输入的过快，没必要去请求网络，这个时候，我们可以使用Debounce来做限流操作，一定时间内，我们只要最后一次得到的数据。

    ```
    mSubscription = RxTextView
    //将EditText的内容改变事件转换成一组可观测的序列（数据流）
                .textChangeEvents(inputTxtDebounce)
                //开启限流操作，在400毫秒内，我们只要最后一次改变的结果
                .debounce(400, TimeUnit.MILLISECONDS)
                //过滤掉空字符串，只有满足条件的能留下
                .filter(new Func1() {
                    @Override
                    public Boolean call(TextViewTextChangeEvent textViewTextChangeEvent) {
                        return !inputTxtDebounce.getText().toString().trim().isEmpty();
                    }
                })
                //和Buffer一样，生产事件运行在computation线程
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(getSubscriber());
    ```
很多时候我们都需要给订阅事件来一个返回值，来方便我们在离开页面的时候取消订阅。

### 4.Retrofit+RxJava
目前最火的网络请求就是Retrofit了，而目前最火的框架，二者也有一合之地，而二者的无缝结合，完全使我们的网络请求随心所欲。
Retrofit我就不多做介绍了。

    ```
    //先来看一个最简单的。
    //首先我们用一个装订阅set集合，将这一个网络请求的订阅装进来
    mSubscriptions.add(
    //通过Retrofit创建网络请求
    mGithubApi
        .contributors(_username.getText().toString(),_repo.getText().toString())
        //指定网络请求（生产事件）运行的线程
        .subscribeOn(Schedulers.io())
        //指定响应的线程（消费事件）
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber>() {
             @Override
             public void onCompleted() {
                 _adapter.add("完毕");
              }

              @Override
              public void onError(Throwable e) {
                _adapter.add("加载失败"+e.getMessage());
              }

            @Override
             public void onNext(List contributors) {
             //网络请求得到了一组集合，我们对这一组集合遍历拿到我们想要的数据
                for (int i = 0; i < contributors.size(); i++) {
                    _adapter.add(format("%s 为 %s 库做出了 %d 个贡献",contributors.get(i).login,_repo.getText().toString(),contributors.get(i).contributions));
            }
        }
      })
    );
    ```
如果！我在拿到List响应数据的时候，我要根据里面的作者，去搜索每一个作者的详细信息，怎么办？我想一想就觉得头疼，先把这些作者收集起来，遍历，再去挨个请求，再将得到的数据和刚才的数据整合起来，显示到桌面？
不，RxJava的优点就是，你的需求越复杂，我的逻辑越简单！！！！！！

    ```
    mSubscriptions.add(
    //先创建网络请求
    mGithubApi.contributors(_username.getText().toString(),_repo.getText().toString())
    //我们先将得到的数据，遍历发射并观测其中的每一个元素
    .flatMap(new Func1, Observable>() {
        @Override
        public Observable call(List contributors) {
            return Observable.from(contributors);
        }
    })
    //这里，重点来了，先说一下Pair，他就是一个包含了两个对象的容器。在这里我们用它来装User和Contributor
    .flatMap(new Func1>>() {
        @Override
        public Observable> call(Contributor contributor) {
        //在这里，我们在根据longin参数再去请求user的详细信息
        Observable userObservable = mGithubApi.user(contributor.login)
            //过滤掉非空数据
            .filter(new Func1() {
                @Override
                public Boolean call(User user) {
                    return !isEmpty(user.name) && !isEmpty(user.email);
                }
            });
            //到了整合的时候了。我们将user的详细信息的数据流，同时将contributor这个值再次包装成数据流发整合之后
            //怎么整合呢，这时候就要看Func2这个函数了
            return Observable.zip(userObservable, Observable.just(contributor), new Func2>() {
                @Override
                public Pair call(User user, Contributor contributor) {
                //它将我们的user用户信息和contributor整合在Pair容器中返回回去
                     return new Pair(user,contributor);
                }
            });
        }
    })
    //下面的不用多说了，我只想说，这个代码写的真的很精彩
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Subscriber>() {
                            @Override
                            public void onCompleted() {
                                _adapter.add("完毕");
                            }

                            @Override
                            public void onError(Throwable e) {
                                _adapter.add("加载失败");
                            }

                            @Override
                            public void onNext(Pair pair) {
                                User user = pair.first;
                                Contributor contributor = pair.second;

                                _adapter.add(format("%s(%s) 为 %s 库做出了 %d 个贡献",
                                        user.name,
                                        user.email,
                                        _repo.getText().toString()
                                        ,contributor.contributions));

                                _adapter.notifyDataSetChanged();
                            }
                        })
                );

5.使用combineLatest做登录注册模块

CombineLatest操作符可以将2~9个Observable发射的数据组装起来然后再发射出来。不过还有两个前提：
1.所有的Observable都发射过数据。（用户操作APP可以感觉到，只有当我三个EditText全部输入过内容，才会触发combineLatest的发射事件）
2.满足条件1的时候任何一个Observable发射一个数据，就将所有Observable最新发射的数据按照提供的函数组装起来发射出去。(每当我任何一个EditText发生改变的时候都会重新走一遍combineLatest的发射事件)
这里我们看着例子，来解释这些话语


RxJava从今以后你就会了_第23张图片
image

这个也是挺常用的，他可以将我们需要的数据流整合在一起。比如：
注册的时候所有输入信息（邮箱、密码、电话号码等）合法才点亮注册按钮。

```
//这里我们分别将3个EditText的内容变化的事件转换成数据流
_emailChangeObservable = RxTextView.textChanges(_email).skip(1);
_passwordChangeObservable = RxTextView.textChanges(_password).skip(1);
_numberChangeObservable = RxTextView.textChanges(_number).skip(1);

private void _combineLatestEvents() {
//我们将三个数据流整合起来，并加入整合的规则（这里可以将规则看成返回值Boolean，满足规则我返回True，否则返回false）
    _subscription = Observable.combineLatest(_emailChangeObservable,
            _passwordChangeObservable, _numberChangeObservable, new Func3() {
                @Override
                public Boolean call(CharSequence email, CharSequence psw, CharSequence num) {
                    boolean emailB = "123456".equals(email.toString());
                    if(!emailB){
                        _email.setError("必须是123456");
                    }
                    boolean pswB = "654321".equals(psw.toString());
                    if(!pswB){
                        _password.setError("必须是654321");
                    }
                    boolean numB = "521".equals(num.toString());
                    if(!numB){
                        _number.setError("必须是521");
                    }
                    return emailB && pswB && numB;
                }
            })
            .subscribe(new Subscriber() {
                @Override
                public void onCompleted() {

                }

                @Override
                public void onError(Throwable e) {

                }

                @Override
                public void onNext(Boolean aBoolean) {
                    if (aBoolean) {
                        _btnValidIndicator.setBackgroundColor(Color.BLUE);
                    } else {
                        _btnValidIndicator.setBackgroundColor(Color.parseColor("#888888"));
                    }
                }
            });
}


### 6.使用timer做定时操作。当有“x秒后执行y操作”类似的需求的时候想到使用timer
我们一般做APP会用到定时器，当用到定时器的。比如说再按一次退出程序，我们可以这么做。我们通过Timer计时，如果退出了的话会造成不到两秒的内存泄露，当然也可以先取消订阅在finish()页面。这里使用Timer来记录用户点击的次数，如果时间不足两秒，复原count

    `    int count = 1 ;
    onBackPressed(){
    if(count != 2){
        Toast.makeText(this, "再按一次退出应用", Toast.LENGTH_SHORT).show();
    }else{ finish();
    }
    count = 2;
    Observable.timer(2, TimeUnit.SECONDS)
        .subscribe(new Action1() {
            @Override
            public void call(Long aLong) {
                count = 1;
            }
        });
    }`

### 7.使用interval做周期性操作。当有“每隔xx秒后执行yy操作”类似的需求的时候，想到使用interval.
这也是我们经常用到的，就比如首页的轮播图就可以通过Interval来实现，我们每3秒让ViewPager当前显示的页面+1即可。具体代码可以见我的另一篇。

### 8.防抖点击
这里我使用的Fragmention也做了防抖点击，而且思想特别好，简单。他的做法是当我开启一个Fragmention的时候，我禁用掉Activity全屏的触摸事件,在开启之后在恢复。
这里呢，我们使用RxJava的限流操作符，在1秒内只允许流出来一个点击事件。

    ```
    RxView.clicks(button)  
              .throttleFirst(1, TimeUnit.SECONDS)  
              .subscribe(new Observer() {  
                  @Override  
                  public void onCompleted() {  
                        log.d ("completed");  
                  }  
  
                  @Override  
                  public void onError(Throwable e) {  
                        log.e("error");  
                  }  
  
                  @Override  
                  public void onNext(Object o) {  
                       log.d("button clicked");  
                  }  
              });  
    ```

RxJava的使用场景很多，遇到自己没见到过得操作符，可以看看图片和文档介绍，很详细，加油。

最后感谢awesome-Rxjava;你想要就的都在这里=>https://github.com/lzyzsd/Awesome-RxJava

附上本文的Demo：https://github.com/SshiGguang/Kits 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(RxJava从今以后你就会了)

        

            

                
    
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 想家
                        爆米花机

                        
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • swagger访问路径
                        igotyback
swagger
                        
    Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
    
                    
    • 
                    
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update
                        iBaoxing
github
                        
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么
                        测评君高省

                        
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
    
                    
    • 
                    
  • 那个抄袭的大张伟
                        猫小努

                        
    最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 我的烦恼
                        余建梅

                        
    我的烦恼。女儿问我：“你给学生布置什么作文题目？”“《我的烦恼》。”“他们都这么大了，你觉得他们还有烦恼吗？”“有啊！每个人都会有自己烦恼。”“我不相信，大人是没有烦恼的，如果说一定有的话，你的烦恼和我写作业有关，而且是小烦恼。不像我，天天被你说，有这样的妈妈，烦恼是没完没了。”女儿愤愤不平。每个人都会有自己的烦恼，处在上有老下有小的年纪，烦恼多的数不完。想干好工作带好孩子，想孝顺父母又想经营好自
    
                    
    • 
                    
  • 放下是一段成长的修行
                        小莳玥

                        
    人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
    
                    
    • 
                    
  • 活给自己看，笑容才灿烂
                        听着了么

                        
    白岩松说“有时候，我们活得很累，并非生活过于刻薄，而是我们太容易被外界的氛围所感染，被他人的情绪所左右。”心情是自己的。若只是活在别人的眼里、嘴里，便掌握不了让自己开心的主动权。人活着，不是为了活给别人看的，唯有做最真实的自己，活给自己看，笑容才灿烂。诚然，世事纷繁复杂，人人都有一张嘴，管也管不了。永远有人欣赏你，也永远有人批评你，不可能做到让所有人都满意，开心做自己才是最重要的。人生苦短，有太多
    
                    
    • 
                    
  • 2019-12-22-22:30
                        涓涓1016

                        
    今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
    
                    
    • 
                    
  • linux sdl windows.h,Windows下的SDL安装
                        奔跑吧linux内核
linuxsdlwindows.h
                        
    首先你要下载并安装SDL开发包。如果装在C盘下，路径为C:\SDL1.2.5如果在WINDOWS下。你可以按以下步骤：1.打开VC++，点击"Tools",Options2,点击directories选项3.选择"Includefiles"增加一个新的路径。"C:\SDL1.2.5\include"4，现在选择"Libaryfiles“增加"C:\SDL1.2.5\lib"现在你可以开始编写你的第
    
                    
    • 
                    
  • 相信相信的力量
                        孙丽_cdb3

                        
    孙丽中级十期坚持分享第345天有一个特别有哲理的故事：有一只老鹰下了蛋，这个蛋，不知怎的就滚到了鸡窝里去了，鸡也下了一窝蛋，然后鸡妈妈把这些蛋全都浮出来了，孵出来之后等小鸡长大一点了，就觉得鹰蛋孵出来的那只小鹰怪模怪样，这些小鸡都嘲笑它，真难看，真笨，丑死了，那只小鹰觉得自己真是谁也不像，真是不好看，后来鸡妈妈也不喜欢他，我怎么生出你这样的孩子来了？真烦人，后来这群小鸡和小鹰一起生活，有一天，老鹰
    
                    
    • 
                    
  • 从鸡肉高汤到记忆的魔法再到有效提示的艺术
                        步子哥
人工智能
                        
    还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
    
                    
    • 
                    
  • 今日囧事
                        唯愿岁月可回首

                        
    今天晚上，房东打来电话说晚上过来取个东西。晚上到家后，洗了一下水果，把卧室的空调打开，在卧室的阳台叠衣服。不一会儿，听见了敲门声，老公和丫头出去开门，果然是房东来了。由于我在叠衣服，床上比较乱，老公随手就把卧室门带上了。我赶紧把衣服收在柜子里，一拧门，好吧，打不开。听见外面热热闹闹的，我喊老公帮我开门，开了几次都开不开。丫头说：妈妈，你先在里面休息一会，我们正在找钥匙。听见外面房东拿了自己东西，老
    
                    
    • 
                    
  • 谁家酒器最绝唱，藏在酒厂人未知？景阳冈酒厂先秦藏品大揭秘
                        李虓酒评论

                        
    文/王赛时中国的酒器酒具历史久远，举世闻名。从北京的故宫博物院、中国国家博物馆，到世界各国的大型博物馆，都以能够收藏中国古代酒具而夸耀。但很少有人知道，在山东阳谷景阳冈酒厂，默默地收藏了两千件中国酒器。这些酒器，就封藏在景阳冈的酒道馆里。其中有一些青铜酒器，一睡就是三、四千年，堪称无声国宝，堪作无字史书！今天，我将引领诸位首先窥视一下景阳冈酒道馆的9件先秦藏品，你自己来说震撼不震撼。提示：这只是景
    
                    
    • 
                    
  • 将cmd中命令输出保存为txt文本文件
                        落难Coder
Windowscmdwindow
                        
    最近深度学习本地的训练中我们常常要在命令行中运行自己的代码，无可厚非，我们有必要保存我们的炼丹结果，但是复制命令行输出到txt是非常麻烦的，其实Windows下的命令行为我们提供了相应的操作。其基本的调用格式就是：运行指令>输出到的文件名称或者具体保存路径测试下，我打开cmd并且ping一下百度：pingwww.baidu.com>./data.txt看下相同目录下data.txt的输出：如果你再
    
                    
    • 
                    
  • 我的黑历史
                        袖手围观有来有去

                        
    孩子同学与我们一起共进晚餐，俩孩子加我三个人。小同学是一个大方率性礼貌的小孩，我们也都非常喜欢。好了，回到正题上来让我把这个故事讲完。俩孩子都喜欢吃鱼，所以就发生了小孩子之间常会发生的事。我狠狠的盯了我家孩子，孩子表情有些狼狈。和孩子单独一起的时候，见她尚未释怀，并谴责我不该狠盯她，让她没面子。也许是她触动了我的童年往事吧。由此，一狠心，给她讲了一段埋藏心里极深的黑历史：我奶奶有四个儿子，四个儿子
    
                    
    • 
                    
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
                        成长时间线

                        
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    
                    
    • 
                    
  • 【夜读】提升生活品质的8个建议
                        茳淮秀水

                        
    停止攀比很多人之所以感觉疲惫，部分原因是来自于跟别人攀比。殊不知，攀比得到的满足只是片刻的，过后往往会感到空虚。过分在意别人的评价，丢失的是自己原有的审美，扰乱的是自己最初的节奏。不妨活得洒脱些，自己内心丰盈了，快乐就能更持久。停止自责想改变自己，先从接纳自己开始。越是过分自责，就越难改变现状，因为如果把精力全耗在自责上，就没有精力用来改变了。遇到问题，我们要用正确的心态去面对。与其一味自责，不如
    
                    
    • 
                    
  • 我在意的
                        Yuexiaofeng

                        
    我所在意的，往往是你最容易忽略的，这让我感到为难。我所感动的，你却无动于衷，这使我感到惭愧。我所做的，你却视而不见，这让我不知如何是好。
    
                    
    • 
                                
  • tomcat基础与部署发布
                                    暗黑小菠萝
Tomcat java web
                                    
    从51cto搬家了，以后会更新在这里方便自己查看。 
做项目一直用tomcat，都是配置到eclipse中使用，这几天有时间整理一下使用心得，有一些自己配置遇到的细节问题。 
Tomcat：一个Servlets和JSP页面的容器，以提供网站服务。 
一、Tomcat安装 
    安装方式：①运行.exe安装包 
     &n
    
                                
    • 
                                
  • 网站架构发展的过程
                                    ayaoxinchao
数据库应用服务器网站架构
                                    
    1.初始阶段网站架构：应用程序、数据库、文件等资源在同一个服务器上 
2.应用服务和数据服务分离：应用服务器、数据库服务器、文件服务器 
3.使用缓存改善网站性能：为应用服务器提供本地缓存，但受限于应用服务器的内存容量，可以使用专门的缓存服务器，提供分布式缓存服务器架构 
4.使用应用服务器集群改善网站的并发处理能力：使用负载均衡调度服务器，将来自客户端浏览器的访问请求分发到应用服务器集群中的任何
    
                                
    • 
                                
  • [信息与安全]数据库的备份问题
                                    comsci
数据库
                                    
     
 
      如果你们建设的信息系统是采用中心-分支的模式,那么这里有一个问题 
  
 如果你的数据来自中心数据库,那么中心数据库如果出现故障,你的分支机构的数据如何保证安全呢? 
 
   是否应该在这种信息系统结构的基础上进行改造,容许分支机构的信息系统也备份一个中心数据库的文件呢? 
 
 &n
    
                                
    • 
                                
  • 使用maven tomcat plugin插件debug关联源代码
                                    商人shang
mavendebug查看源码tomcat-plugin
                                    
    *首先需要配置好'''maven-tomcat7-plugin'''，参见[[Maven开发Web项目]]的'''Tomcat'''部分。 
*配置好后，在[[Eclipse]]中打开'''Debug Configurations'''界面，在'''Maven Build'''项下新建当前工程的调试。在'''Main'''选项卡中点击'''Browse Workspace...'''选择需要开发的
    
                                
    • 
                                
  • 大访问量高并发
                                    oloz
大访问量高并发
                                    
    大访问量高并发的网站主要压力还是在于数据库的操作上，尽量避免频繁的请求数据库。下面简 
 
要列出几点解决方案： 
 
01、优化你的代码和查询语句，合理使用索引 
 
02、使用缓存技术例如memcache、ecache将不经常变化的数据放入缓存之中 
 
03、采用服务器集群、负载均衡分担大访问量高并发压力 
 
04、数据读写分离 
 
05、合理选用框架，合理架构(推荐分布式架构)。 
 
    
                                
    • 
                                
  • cache 服务器
                                    小猪猪08
cache
                                    
    Cache   即高速缓存.那么cache是怎么样提高系统性能与运行速度呢？是不是在任何情况下用cache都能提高性能？是不是cache用的越多就越好呢？我在近期开发的项目中有所体会，写下来当作总结也希望能跟大家一起探讨探讨，有错误的地方希望大家批评指正。 
　　1.Cache   是怎么样工作的? 
　　Cache   是分配在服务器上
    
                                
    • 
                                
  • mysql存储过程
                                    香水浓
mysql
                                    
    Description:插入大量测试数据 
 
use xmpl;

drop procedure if exists mockup_test_data_sp;

create procedure mockup_test_data_sp(
	in number_of_records int
)
begin
	declare cnt int;
	declare name varch
    
                                
    • 
                                
  • CSS的class、id、css文件名的常用命名规则
                                    agevs
JavaScriptUI框架Ajaxcss
                                    
      CSS的class、id、css文件名的常用命名规则 
    (一)常用的CSS命名规则 
　　头：header 
　　内容：content/container 
　　尾：footer 
　　导航：nav 
　　侧栏：sidebar 
　　栏目：column 
　　页面外围控制整体布局宽度：wrapper 
　　左右中：left right 
    
                                
    • 
                                
  • 全局数据源
                                    AILIKES
javatomcatmysqljdbcJNDI
                                    
    实验目的：为了研究两个项目同时访问一个全局数据源的时候是创建了一个数据源对象，还是创建了两个数据源对象。 
1：将diuid和mysql驱动包（druid-1.0.2.jar和mysql-connector-java-5.1.15.jar）copy至%TOMCAT_HOME%/lib下；2：配置数据源，将JNDI在%TOMCAT_HOME%/conf/context.xml中配置好,格式如下：&l
    
                                
    • 
                                
  • MYSQL的随机查询的实现方法
                                    baalwolf
mysql
                                    
    MYSQL的随机抽取实现方法。举个例子，要从tablename表中随机提取一条记录，大家一般的写法就是：SELECT * FROM tablename ORDER BY RAND() LIMIT 1。但是，后来我查了一下MYSQL的官方手册，里面针对RAND()的提示大概意思就是，在ORDER BY从句里面不能使用RAND()函数，因为这样会导致数据列被多次扫描。但是在MYSQL 3.23版本中，
    
                                
    • 
                                
  • JAVA的getBytes()方法
                                    bijian1013
javaeclipseunixOS
                                    
        在Java中，String的getBytes()方法是得到一个操作系统默认的编码格式的字节数组。这个表示在不同OS下，返回的东西不一样！  
    String.getBytes(String decode)方法会根据指定的decode编码返回某字符串在该编码下的byte数组表示，如： 
    byte[] b_gbk = "
    
                                
    • 
                                
  • AngularJS中操作Cookies
                                    bijian1013
JavaScriptAngularJSCookies
                                    
            如果你的应用足够大、足够复杂，那么你很快就会遇到这样一咱种情况：你需要在客户端存储一些状态信息，这些状态信息是跨session(会话)的。你可能还记得利用document.cookie接口直接操作纯文本cookie的痛苦经历。 
        幸运的是，这种方式已经一去不复返了，在所有现代浏览器中几乎
    
                                
    • 
                                
  • [Maven学习笔记五]Maven聚合和继承特性
                                    bit1129
maven
                                    
    Maven聚合 
  
在实际的项目中，一个项目通常会划分为多个模块，为了说明问题，以用户登陆这个小web应用为例。通常一个web应用分为三个模块：   
1. 模型和数据持久化层user-core, 
2. 业务逻辑层user-service以 
3. web展现层user-web， 
user-service依赖于user-core 
user-web依赖于user-core和use
    
                                
    • 
                                
  • 【JVM七】JVM知识点总结
                                    bit1129
jvm
                                    
      1. JVM运行模式 
1.1 JVM运行时分为-server和-client两种模式，在32位机器上只有client模式的JVM。通常，64位的JVM默认都是使用server模式，因为server模式的JVM虽然启动慢点，但是，在运行过程，JVM会尽可能的进行优化 
1.2 JVM分为三种字节码解释执行方式：mixed mode, interpret mode以及compiler 
    
                                
    • 
                                
  • linux下查看nginx、apache、mysql、php的编译参数
                                    ronin47

                                    
    在linux平台下的应用，最流行的莫过于nginx、apache、mysql、php几个。而这几个常用的应用，在手工编译完以后，在其他一些情况下（如：新增模块），往往想要查看当初都使用了那些参数进行的编译。这时候就可以利用以下方法查看。 
1、nginx 
[root@361way ~]# /App/nginx/sbin/nginx -V
nginx: nginx version: nginx/
    
                                
    • 
                                
  • unity中运用Resources.Load的方法？
                                    brotherlamp
unity视频unity资料unity自学unityunity教程
                                    
    问：unity中运用Resources.Load的方法？ 
答：Resources.Load是unity本地动态加载资本所用的方法,也即是你想动态加载的时分才用到它,比方枪弹,特效,某些实时替换的图像什么的,主张此文件夹不要放太多东西,在打包的时分,它会独自把里边的一切东西都会集打包到一同,不论里边有没有你用的东西,所以大多数资本应该是自个建文件放置 
1、unity实时替换的物体即是依据环境条件
    
                                
    • 
                                
  • 线段树-入门
                                    bylijinnan
java算法线段树
                                    
    


/**
 * 线段树入门
 * 问题：已知线段[2,5] [4,6] [0,7]；求点2,4,7分别出现了多少次
 * 以下代码建立的线段树用链表来保存，且树的叶子结点类似[i,i]
 * 
 * 参考链接：http://hi.baidu.com/semluhiigubbqvq/item/be736a33a8864789f4e4ad18
 * @author lijinna
    
                                
    • 
                                
  • 全选与反选
                                    chicony
全选
                                    
      
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>全选与反选</title>

    
                                
    • 
                                
  • vim一些简单记录
                                    chenchao051
vim
                                    
    mac在/usr/share/vim/vimrc linux在/etc/vimrc 
  
1、问：后退键不能删除数据，不能往后退怎么办？ 
      答：在vimrc中加入set backspace=2 
  
2、问：如何控制tab键的缩进？ 
      答：在vimrc中加入set tabstop=4 (任何
    
                                
    • 
                                
  • Sublime Text 快捷键
                                    daizj
快捷键sublime
                                    
    [size=large][/size]Sublime Text快捷键：Ctrl+Shift+P：打开命令面板Ctrl+P：搜索项目中的文件Ctrl+G：跳转到第几行Ctrl+W：关闭当前打开文件Ctrl+Shift+W：关闭所有打开文件Ctrl+Shift+V：粘贴并格式化Ctrl+D：选择单词，重复可增加选择下一个相同的单词Ctrl+L：选择行，重复可依次增加选择下一行Ctrl+Shift+L：
    
                                
    • 
                                
  • php 引用(&)详解
                                    dcj3sjt126com
PHP
                                    
    在PHP 中引用的意思是：不同的名字访问同一个变量内容. 与Ｃ语言中的指针是有差别的．Ｃ语言中的指针里面存储的是变量的内容在内存中存放的地址 变量的引用 PHP 的引用允许你用两个变量来指向同一个内容   复制代码代码如下:   
<?  
$a="ABC";  
$b =&$a;  
echo
    
                                
    • 
                                
  • SVN中trunk,branches,tags用法详解
                                    dcj3sjt126com
SVN
                                    
    Subversion有一个很标准的目录结构，是这样的。比如项目是proj，svn地址为svn://proj/，那么标准的svn布局是svn://proj/|+-trunk+-branches+-tags这是一个标准的布局，trunk为主开发目录，branches为分支开发目录，tags为tag存档目录（不允许修改）。但是具体这几个目录应该如何使用，svn并没有明确的规范，更多的还是用户自己的习惯。
    
                                
    • 
                                
  • 对软件设计的思考
                                    e200702084
设计模式数据结构算法ssh活动
                                    
    软件设计的宏观与微观  
 
   软件开发是一种高智商的开发活动。一个优秀的软件设计人员不仅要从宏观上把握软件之间的开发，也要从微观上把握软件之间的开发。宏观上，可以应用面向对象设计，采用流行的SSH架构，采用web层，业务逻辑层，持久层分层架构。采用设计模式提供系统的健壮性和可维护性。微观上，对于一个类，甚至方法的调用，从计算机的角度模拟程序的运行情况。了解内存分配，参数传
    
                                
    • 
                                
  • 同步、异步、阻塞、非阻塞
                                    geeksun
非阻塞
                                    
    同步、异步、阻塞、非阻塞这几个概念有时有点混淆，在此文试图解释一下。 
  
同步：发出方法调用后，当没有返回结果，当前线程会一直在等待（阻塞）状态。 
场景：打电话，营业厅窗口办业务、B/S架构的http请求-响应模式。 
  
异步：方法调用后不立即返回结果，调用结果通过状态、通知或回调通知方法调用者或接收者。异步方法调用后，当前线程不会阻塞，会继续执行其他任务。 
实现：
    
                                
    • 
                                
  • Reverse SSH Tunnel 反向打洞實錄
                                    hongtoushizi
ssh
                                    
    實際的操作步驟：  
# 首先，在客戶那理的機器下指令連回我們自己的 Server，並設定自己 Server 上的 12345 port 會對應到幾器上的 SSH port
ssh -NfR 12345:localhost:22 [email protected]

# 然後在 myhost 的機器上連自己的 12345 port，就可以連回在客戶那的機器
ssh localhost -p 1
    
                                
    • 
                                
  • Hibernate中的缓存
                                    Josh_Persistence
一级缓存Hiberante缓存查询缓存二级缓存
                                    
    Hibernate中的缓存 
  
一、Hiberante中常见的三大缓存：一级缓存，二级缓存和查询缓存。 
Hibernate中提供了两级Cache，第一级别的缓存是Session级别的缓存，它是属于事务范围的缓存。这一级别的缓存是由hibernate管理的，一般情况下无需进行干预；第二级别的缓存是SessionFactory级别的缓存，它是属于进程范围或群集范围的缓存。这一级别的缓存
    
                                
    • 
                                
  • 对象关系行为模式之延迟加载
                                    home198979
PHP架构延迟加载
                                    
    形象化设计模式实战     HELLO!架构 
  
一、概念 
Lazy Load：一个对象，它虽然不包含所需要的所有数据，但是知道怎么获取这些数据。 
延迟加载貌似很简单，就是在数据需要时再从数据库获取，减少数据库的消耗。但这其中还是有不少技巧的。 
  
  
二、实现延迟加载 
实现Lazy Load主要有四种方法：延迟初始化、虚
    
                                
    • 
                                
  • xml 验证
                                    pengfeicao521
xmlxml解析
                                    
    有些字符，xml不能识别，用jdom或者dom4j解析的时候就报错 
 
public static void testPattern() { 
 
 // 含有非法字符的串 
 String str =       "Jamey&#52828;&#01;&#02;&#209;&#1282
    
                                
    • 
                                
  • div设置半透明效果
                                    spjich
css半透明
                                    
    为div设置如下样式： 
  
div{filter:alpha(Opacity=80);-moz-opacity:0.5;opacity: 0.5;}  
  
  
  
 说明： 
1、filter：对win IE设置半透明滤镜效果，filter:alpha(Opacity=80)代表该对象80%半透明，火狐浏览器不认2、-moz-opaci
    
                                
    • 
                                
  • 你真的了解单例模式么？
                                    w574240966
java单例设计模式jvm
                                    
        单例模式，很多初学者认为单例模式很简单，并且认为自己已经掌握了这种设计模式。但事实上，你真的了解单例模式了么。 
  
一，单例模式的5中写法。（回字的四种写法，哈哈。） 
    1，懒汉式 
          （1）线程不安全的懒汉式 
    public cla
    
                                
    •