cheun258
cheun258

Android 下 RxJava 详解，长篇巨作，由浅入深。

权声明：本文为博主原创文章，未经博主允许不得转载。更多文章，请查看 http://blog.csdn.net/yyh352091626

RxJava：https://github.com/ReactiveX/RxJava

    • 前言
    • RxJava 概念初步理解
      • 作用 - 异步
      • 模式 - 观察者模式
      • 结构 - 响应式编程
      • 优势 - 逻辑简洁
    • RxJava 依赖
    • RxJava 入门
      • 事件产生
      • 事件消费
      • 事件订阅
      • 不完整定义回调
      • 入门示例
    • RxJava 进阶
      • Scheduler线程控制
      • 变换
        • map操作符
        • flatMap操作符
    • RxJava 其他常用操作符
    • RxJava 应用
      • RxJavaRetrofit 的网络请求方式
      • RxBus
      • RxBinding
    • RxJava 的一些坑
      • 未取消订阅而引起的内存泄漏
    • 总结

前言

使用了RxJava有一段时间了，深深感受到了其“牛逼”之处。下面，就从RxJava的基础开始，一步一步与大家分享一下这个强大的异步库的用法！

PS: 建议先看看目录结构，便于理解，哈哈

RxJava 概念初步理解

RxJava Repo上给的解释是：“RxJava is a Java VM implementation of Reactive Extensions: a library for composing asynchronous and event-based programs by using observable sequences.” 大概就是说RxJava是Java VM上一个灵活的、使用可观测序列来组成的一个异步的、基于事件的库。那么，RxJava有哪些特点呢？

作用 - 异步

前面这段解释，重点就在于异步！但是它又不像 AsyncTask 这样用法简单，所以刚接触RxJava的童鞋，可能会觉得特别难，无从下手，没事，相信通过这篇文章，大伙儿可以有一个比较深刻的理解！此处应该有呼声…

Android 下 RxJava 详解，长篇巨作，由浅入深。_第1张图片

RxJava可以浓缩为异步两个字，其核心的东西不外乎两个， Observables（被观察者） 和 Subscribers（观察者）。Observables可以发出一系列的 事件，这里的事件可以是任何东西，例如网络请求、复杂计算处理、数据库操作、文件读写等等，事件执行结束后交给Subscriber的回调处理。

模式 - 观察者模式

观察者模式是一种对象的行为模式，也常称为发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。 例如用过事件总线EventBus库的童鞋就知道，EventBus属于Publish/Subscribe模式，实际上，使用RxJava也可以设计出一套事件总线的库，称为RxBus。有兴趣的话可以在学完RxJava之后，可以尝试写一个。这里就不细说了~

那么，RxJava也是一种扩展的观察者模式！

观察者模式是Java设计模式中很常用的一个模式。举个栗子，Android中View的点击监听器的实现，View是被观察者，OnClickListener对象是观察者，Activity要如何知道View被点击了？那就是派一个OnClickListener对象，入驻View，与View达成一个订阅关系，一旦View被点击了，就通过OnClickListener对象的OnClick方法传达给Activity。采用观察者模式可以避免去轮询检查，节约有限的cpu资源。

结构 - 响应式编程

响应？顾名思义，就是“你变化，我响应”。举个栗子，a = b + c; 这句代码将b+c的值赋给a，而之后如果b和c的值改变了不会影响到a，然而，对于响应式编程，之后b和c的值的改变也动态影响着a，意味着a会随着b和c的变化而变化。

响应式编程的组成为Observable/Operator/Subscriber，RxJava在响应式编程中的基本流程如下：

Observable -> Operator 1 -> Operator 2 -> Operator 3 -> Subscriber

这个流程，可以简单的理解为：

  1. Observable发出一系列事件，他是事件的产生者；
  2. Subscriber负责处理事件，他是事件的消费者；
  3. Operator是对Observable发出的事件进行修改和变换；
  4. 若事件从产生到消费不需要其他处理，则可以省略掉中间的Operator，从而流程变为Obsevable -> Subscriber；
  5. Subscriber通常在主线程执行，所以原则上不要去处理太多的事务，而这些复杂的处理则交给Operator；

优势 - 逻辑简洁

Rx 优势可以概括为四个字，那就是 逻辑简洁。逻辑简洁并不意味着代码简洁，但是，由于链式结构，一条龙，你可以从头到尾，从上到下，很清楚的看到这个连式结构的执行顺序。对于开发人员来说，代码质量并不在于代码量，而在于逻辑是否清晰简洁，可维护性如何，代码是否健壮！

另外，熟悉lambda的，还可以进一步提高代码的简洁性。举个简单栗子，暂时不需要过多理解，后面会一一道来：

// 不使用lambda
Observable.just("Hello World!")
     .map(new Func1() {
         @Override
         public String call(String s) {
             return s + "I am kyrie!";
         }
     })
     .subscribeOn(Schedulers.io())
     .observeOn(AndroidSchedulers.mainThread())
     .subscribe(new Action1() {
         @Override
         public void call(String s) {
             Log.i(TAG, s);
         }
     });

// 使用lambda
Observable.just("Hello World!")
    .map(s -> s + "I am kyrie!")
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(s -> {
        Log.i(TAG, s);
    });

RxJava 依赖

// Android 平台下须引入的一个依赖，主要用于线程控制
compile 'io.reactivex:rxandroid:1.1.0'
// RxJava
compile 'io.reactivex:rxjava:1.1.5'

这是我项目里面用的版本，可以到Maven/RxJava下获取最新版本。

RxJava 入门

前面讲了那么多，主要是想让大家在概念上对RxJava有一个初步的认识就好，接下来，将为您解开RxJava神秘的面纱~~

无需过分纠结于“事件”这个词，暂时可以简单的把“事件”看成是一个值，或者一个对象。

  1. 事件产生，就是构造要传递的对象；
  2. 事件处理变换，就是改变传递的对象，可以改变对象的值，或是干脆创建个新对象，新对象类型也可以与源对象不一样；
  3. 事件处理，就是接收到对象后要做的事；

事件产生

RxJava创建一个事件比较简单，由 Observable 通过 create 操作符来创建。举个栗子，还是经典的 HelloWorld~~

// 创建一个Observable
Observable observable = Observable.create(new Observable.OnSubscribe() {

    @Override
    public void call(Subscribersuper String> subscriber) {
        // 发送一个 Hello World 事件
        subscriber.onNext("Hello World!");

        // 事件发送完成
        subscriber.onCompleted();
    }
});

这段代码可以理解为， Observable 发出了一个类型为 String ，值为 “Hello World!” 的事件，仅此而已。

对于 Subscriber 来说，通常onNext()可以多次调用，最后调用onCompleted()表示事件发送完成。

上面这段代码，也可以通过just操作符进行简化。RxJava操作符后面会详细介绍，这里先有个了解。

// 创建对象,just里面的每一个参数，相当于调用一次Subscriber#OnNext()
Observable observable = Observable.just("Hello World!");

这样，是不是简单了许多？

事件消费

有事件产生，自然也要有事件消费。RxJava 可以通过 subscribe 操作符，对上述事件进行消费。首先，先创建一个观察者。

// 创建一个Observer
Observer observer = new Observer() {
    @Override
    public void onCompleted() {
        Log.i(TAG, "complete");
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
        Log.i(TAG, s);
    }
};

或者

// 创建一个Subscriber
Subscriber subscriber = new Subscriber() {
    @Override
    public void onCompleted() {
        Log.i(TAG, "complete");
    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(String s) {
        Log.i(TAG, s);
    }
};

这两种方式里面， Observer 是观察者， Subscriber 也是观察者，Subscriber 是一个实现了Observer接口的抽象类，对 Observer 进行了部分扩展，在使用上基本没有区别， Subscriber 多了发送之前调用的 onStart() 和解除订阅关系的 unsubscribe() 方法。

并且，在 RxJava 的 subscribe 过程中，Observer 也总是会先被转换成一个 Subscriber 再使用。所以在这之后的示例代码，都使用 Subscriber 来作为观察者。

事件订阅

最后，我们可以调用 subscribe 操作符， 进行事件订阅。

// 订阅事件
observable.subscribe(subscriber);

在 Subscriber 实现的三个方法中，顾名思义，对应三种不同状态：
1. onComplete(): 事件全部处理完成后回调
2. onError(Throwable t): 事件处理异常回调
3. onNext(T t): 每发出一个事件，回调一次

不完整定义回调

对于事件消费与事件订阅来说，好像为了打印一个“Hello World！”要废好大的劲… 其实，RxJava 提供了不完整定义的回调。我们可以为 Subscriber 中的三种状态根据自身需要分别创建一个回调动作 Action：

// onComplete()
Action0 onCompleteAction = new Action0() {
    @Override
    public void call() {
        Log.i(TAG, "complete");
    }
};

// onNext(T t)
Action1 onNextAction = new Action1() {
    @Override
    public void call(String s) {
        Log.i(TAG, s);
    }
};

// onError(Throwable t)
Action1 onErrorAction = new Action1() {
    @Override
    public void call(Throwable throwable) {

    }
};

那么，RxJava 的事件订阅支持以下三种不完整定义的回调。

observable.subscribe(onNextAction);

observable.subscribe(onNextAction, onErrorAction);

observable.subscribe(onNextAction, onErrorAction, onCompleteAction);

我们可以根据当前需要，传入对应的 Action， RxJava 会相应的自动创建 Subscriber。

  1. Action0 表示一个无回调参数的Action；
  2. Action1 表示一个含有一个回调参数的Action；
  3. 当然，还有Action2 ~ Action9，分别对应2~9个参数的Action；
  4. 每个Action，都有一个 call() 方法，通过泛型，来指定对应参数的类型；

入门示例

前面讲解了事件的产生到消费、订阅的过程，下面就举个完整的例子。从res/mipmap中取出一张图片，显示在ImageView上。

final ImageView ivLogo = (ImageView) findViewById(R.id.ivLogo);

Observable.create(new Observable.OnSubscribe() {
        @Override
        public void call(Subscribersuper Drawable> subscriber) {

            // 从mipmap取出一张图片作为Drawable对象
            Drawable drawable = ContextCompat.getDrawable(mContext, R.mipmap.ic_launcher);

            // 把Drawable对象发送出去
            subscriber.onNext(drawable);

            subscriber.onCompleted();
        }
    })
    .subscribe(new Subscriber() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {
            Log.i(TAG, e.toString());
        }

        @Override
        public void onNext(Drawable drawable) {
            // 接收到Drawable对象，显示在ImageView上
            ivLogo.setImageDrawable(drawable);
        }
    });

上面示例是RxJava最基本的一个用法。消化一下，继续~~

RxJava 进阶

Scheduler线程控制

默认情况下，RxJava事件产生和消费均在同一个线程中，例如在主线程中调用，那么事件的产生和消费都在主线程。

那么问题来了，假如事件产生的过程是耗时操作，比如网络请求，结果显示在UI中，这个时候在主线程执行对于网络请求就不合适了，而在子线程执行，显示结果需要进行UI操作，同样不合适~~

所以，RxJava 的第一个牛逼之处在于可以自由切换线程！那么，如何做？

在 RxJava 中，提供了一个名为 Scheduler 的线程调度器，RxJava 内部提供了4个调度器，分别是：

  1. Schedulers.io(): I/O 操作（读写文件、数据库、网络请求等），与newThread()差不多，区别在于io() 的内部实现是是用一个无数量上限的线程池，可以重用空闲的线程，因此多数情况下 io() 效率比 newThread() 更高。值得注意的是，在 io() 下，不要进行大量的计算，以免产生不必要的线程；

  2. Schedulers.newThread(): 开启新线程操作；

  3. Schedulers.immediate(): 默认指定的线程，也就是当前线程；

  4. Schedulers.computation():计算所使用的调度器。这个计算指的是 CPU 密集型计算，即不会被 I/O等操作限制性能的操作，例如图形的计算。这个 Scheduler 使用的固定的线程池，大小为 CPU 核数。值得注意的是，不要把 I/O 操作放在 computation() 中，否则 I/O 操作的等待时间会浪费 CPU；

  5. AndroidSchedulers.mainThread(): RxJava 扩展的 Android 主线程；

我们可以通过 subscribeOn() 和 observeOn() 这两个方法来进行线程调度。举个栗子：

依然还是显示一张图片，不同的是，这次是从网络上加载图片

final ImageView ivLogo = (ImageView) findViewById(R.id.ivLogo);

Observable.create(new Observable.OnSubscribe() {
    @Override
    public void call(Subscribersuper Drawable> subscriber) {

        try {
            Drawable drawable = Drawable.createFromStream(new URL("https://ss2.baidu.com/6ONYsjip0QIZ8tyhnq/it/u=2502144641,437990411&fm=80&w=179&h=119&img.JPEG").openStream(), "src");
            subscriber.onNext(drawable);
        } catch (IOException e) {
            subscriber.onError(e);
        }
    }
})
        // 指定 subscribe() 所在的线程，也就是上面call()方法调用的线程
        .subscribeOn(Schedulers.io())
        // 指定 Subscriber 回调方法所在的线程，也就是onCompleted, onError, onNext回调的线程
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, e.toString());
            }

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

所以，这段代码就做一件事，在 io 线程加载一张网络图片，加载完毕之后在主线程中显示到ImageView上。

变换

RxJava的又一牛逼之处，在于 变换。啥意思呢？ 就是将发送的事件或事件序列，加工后转换成不同的事件或事件序列。

map操作符

变换的概念不好理解吧？举个简单的栗子，我们对上述示例 进行改写。

final ImageView ivLogo = (ImageView) findViewById(R.id.ivLogo);

Observable.create(new Observable.OnSubscribe() {
    @Override
    public void call(Subscribersuper String> subscriber) {

        subscriber.onNext("https://ss2.baidu.com/-vo3dSag_xI4khGko9WTAnF6hhy/image/h%3D200/sign=4db5130a073b5bb5a1d727fe06d2d523/cf1b9d16fdfaaf51965f931e885494eef11f7ad6.jpg");
    }
}).map(new Func1() {
    @Override
    public Drawable call(String url) {
        try {
            Drawable drawable = Drawable.createFromStream(new URL(url).openStream(), "src");
            return drawable;
        } catch (IOException e) {

        }
        return null;
    }
})
        // 指定 subscribe() 所在的线程，也就是call()方法调用的线程
        .subscribeOn(Schedulers.io())
        // 指定 Subscriber 回调方法所在的线程，也就是onCompleted, onError, onNext回调的线程
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {
                Log.e(TAG, e.toString());
            }

            @Override
            public void onNext(Drawable drawable) {
                if (drawable != null) {
                    ivLogo.setImageDrawable(drawable);
                }
            }
        });

经过改写代码后，有什么变化呢？ Observable 创建了一个 String 事件，也就是产生一个url，通过 map 操作符进行变换，返回Drawable对象，这个变换指的就是通过url进行网络图片请求，返回一个Drawable。所以简单的来说就是把String事件，转换为Drawable事件。逻辑表示就是：

Observable<String> --> map变换 --> Observable<Drawable>

那么，Func1 是什么呢？与 Action1 类似,不同的是 FuncX 有返回值，而 ActionX 没有。为什么需要返回值呢？目的就在于对象的变换，由String对象转换为Drawable对象。同样，也有Func0 ~ Func9，对应不同的参数个数。

当然了，RxJava 的变换，可不止于map这么简单，继续往下！

flatMap操作符

不难发现，上述的 map 操作符，是一对一的变换，并且返回的是变换后的对象。而 flatMap 操作符可以适应一对多，并且返回的是一个 Observable 。应用场景举例：例如一个员工负责多个任务，现在要打印所有员工的所有任务。

final List list = new ArrayList() {
    {
        add(new Employee("jackson", missions1));
        add(new Employee("sunny", missions2));
    }
};
Observable.from(list)
        .flatMap(new Func1>() {
            @Override
            public Observable call(Employee employee) {
                return Observable.from(employee.missions);
            }
        })
        .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Employee.Mission mission) {
                Log.i(TAG, mission.desc);
            }
        });

通过上面的代码可以看出，map 与 flatMap 这两个操作符的共同点在于，他们都是把一个对象转换为另一个对象，但须注意以下这些特点:

  1. flatMap 返回的是一个Observable对象，而 map 返回的是一个普通转换后的对象;
  2. flatMap 返回的Observable对象并不是直接发送到Subscriber的回调中，而是重新创建一个Observable对象，并激活这个Observable对象，使之开始发送事件；而 map 变换后返回的对象直接发到Subscriber回调中；
  3. flatMap 变换后产生的每一个Observable对象发送的事件，最后都汇入同一个Observable，进而发送给Subscriber回调；
  4. map返回类型 与 flatMap 返回的Observable事件类型，可以与原来的事件类型一样；
  5. 可以对一个Observable多次使用 map 和 flatMap；

鉴于 flatMap 自身强大的功能，这常常被用于 嵌套的异步操作，例如嵌套网络请求。传统的嵌套请求，一般都是在前一个请求的 onSuccess() 回调里面发起新的请求，这样一旦嵌套多个的话，缩进就是大问题了，而且严重的影响代码的可读性。而RxJava嵌套网络请求仍然通过链式结构，保持代码逻辑的清晰！举个栗子：

Github上的 README.md 文件，通常是 MarkDown 语法。我们要获取 README.md 内容并按 MarkDown 风格显示在UI上，就可以通过以下方式（Retrofit2 + RxJava，稍后会介绍）：

new ReadmeContentClient()
    // 获取md语法的Readme内容, 返回的是一个Observable对象
    .getReadme()
    .flatMap(new Func1>() {
        @Override
        public Observable call(String md) {
            // 由于Readme的内容是md语法，需要转成html字符串通过WebView显示到UI
            // 返回的也是Observable对象
            return new MarkDownStyleClient(md)
                            .formatMarkStyle();
        }
    })
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Observer() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, "readme:" + e.toString());
        }

        @Override
        public void onNext(String html) {
            // html就是根据readme md格式内容，生成的html代码
            view.showReadme(html);
        }
    });

RxJava 其他常用操作符

  1. from
    接收一个集合作为输入，然后每次输出一个元素给subscriber。

    // Observable.from(T[] params)
Observable.from(new Integer[]{1, 2, 3, 4, 5})
    .subscribe(new Action1() {
        @Override
        public void call(Integer number) {
            Log.i(TAG, "number:" + number);
        }
    });

    注意：如果from()里面执行了耗时操作，即使使用了subscribeOn(Schedulers.io())，仍然是在主线程执行，可能会造成界面卡顿甚至崩溃，所以耗时操作还是使用create();

  2. just
    接收一个可变参数作为输入，最终也是生成数组，调用from()，然后每次输出一个元素给subscriber。

    // Observable.just(T... params)，params的个数为1 ~ 10
Observable.just(1, 2, 3, 4, 5)
    .subscribe(new Action1() {
        @Override
        public void call(Integer number) {
            Log.i(TAG, "number:" + number);
        }
    });

  3. filter
    条件过滤，去除不符合某些条件的事件。举个栗子:

    Observable.from(new Integer[]{1, 2, 3, 4, 5})
    .filter(new Func1() {
        @Override
        public Boolean call(Integer number) {
            // 偶数返回true，则表示剔除奇数，留下偶数
            return number % 2 == 0;
        }
    })
    .subscribe(new Action1() {
        @Override
        public void call(Integer number) {
            Log.i(TAG, "number:" + number);
        }
    });

  4. take
    最多保留的事件数。

  5. doOnNext
    在处理下一个事件之前要做的事。

    Observable.from(new Integer[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12})
    .filter(new Func1() {
        @Override
        public Boolean call(Integer number) {
            // 偶数返回true，则表示剔除奇数
            return number % 2 == 0;
        }
    })
    // 最多保留三个，也就是最后剩三个偶数
    .take(3)
    .doOnNext(new Action1() {
        @Override
        public void call(Integer number) {
            // 在输出偶数之前输出它的hashCode
            Log.i(TAG, "hahcode = " + number.hashCode() + "");
        }
    })
    .subscribe(new Action1() {
        @Override
        public void call(Integer number) {
            Log.i(TAG, "number = " + number);
        }
    });

    输出如下：

    hahcode = 2
number = 2
hahcode = 4
number = 4
hahcode = 6
number = 6

  6. debounce
    通俗点讲，就是N个事件发生的时间间隔太近，就过滤掉前N-1个事件，保留最后一个事件。debounce可以指定这个时间间隔！可以用在SearchEditText请求关键词的地方，SearchEditText的内容变化太快，可以抵制频繁请求关键词，后面第15条15.Subject会介绍这个。为了演示效果，先举个简单栗子：

    Observable
    .create(new Observable.OnSubscribe() {
        @Override
        public void call(Subscribersuper Integer> subscriber) {
            int i = 0;
            int[] times = new int[]{100, 1000};
            while (true) {
                i++;
                if (i >= Integer.MAX_VALUE - 1)
                    break;
                subscriber.onNext(i);
                try {
                    // 注意！！！！
                    // 当i为奇数时，休眠1000ms，然后才发送i+1，这时i不会被过滤掉
                    // 当i为偶数时，只休眠100ms，便发送i+1，这时i会被过滤掉
                    Thread.sleep(times[i % 2]);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            subscriber.onCompleted();
        }
    })
    // 间隔400ms以内的事件将被丢弃
    .debounce(400, TimeUnit.MILLISECONDS)
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Subscriber() {
        @Override
        public void onCompleted() {
            Log.i(TAG, "complete");
        }

        @Override
        public void onError(Throwable e) {
            Log.e(TAG, e.toString());
        }

        @Override
        public void onNext(Integer integer) {
            Log.i(TAG, "integer = " + integer);
        }
    });

    输出结果：

    11-23 10:44:45.167 MainActivity: integer = 1
11-23 10:44:46.270 MainActivity: integer = 3
11-23 10:44:47.373 MainActivity: integer = 5
11-23 10:44:48.470 MainActivity: integer = 7
11-23 10:44:49.570 MainActivity: integer = 9
11-23 10:44:50.671 MainActivity: integer = 11
11-23 10:44:51.772 MainActivity: integer = 13
11-23 10:44:52.872 MainActivity: integer = 15
11-23 10:44:53.973 MainActivity: integer = 17
...

    我们设置过滤条件为400ms，可以发现，奇数正常输出，因为在它的下一个事件事件隔了1000ms，所以它不会被过滤掉；偶数被过滤掉，是因为它距离下一个事件（奇数）只隔了100ms。并且，输出的两个事件相隔大约为 100ms + 1000ms = 1100ms。

  7. merge
    用于合并两个Observable为一个Observable。较为简单。

    Observable.merge(Observable1, Observable2)
    .subscribe(subscriber);

  8. concat
    顺序执行多个Observable，个数为1 ~ 9。例子稍后与first操作符一起~~

  9. compose
    与 flatMap 类似，都是进行变换，返回Observable对象，激活并发送事件。

    1. compose 是唯一一个能够从数据流中得到原始Observable的操作符，所以，那些需要对整个数据流产生作用的操作（比如，subscribeOn()和observeOn()）需要使用 compose 来实现。相较而言，如果在flatMap()中使用subscribeOn()或者observeOn()，那么它仅仅对在 flatMap 中创建的Observable起作用，而不会对剩下的流产生影响。这样就可以简化subscribeOn()以及observeOn()的调用次数了。
    2. compose 是对 Observable 整体的变换，换句话说， flatMap 转换Observable里的每一个事件，而 compose 转换的是整个Observable数据流。
    3. flatMap 每发送一个事件都创建一个 Observable，所以效率较低。而 compose 操作符只在主干数据流上执行操作。
    4. 建议使用 compose 代替 flatMap。

  10. first
    只发送符合条件的第一个事件。可以与前面的contact操作符，做网络缓存。举个栗子：依次检查Disk与Network，如果Disk存在缓存，则不做网络请求，否则进行网络请求。

    // 从缓存获取
Observable fromDisk = Observable.create(new Observable.OnSubscribe() {
    @Override
    public void call(Subscribersuper BookList> subscriber) {
        BookList list = getFromDisk();
        if (list != null) {
            subscriber.onNext(list);
        } else {
            subscriber.onCompleted();
        }
    }
});

// 从网络获取
Observable fromNetWork = bookApi.getBookDetailDisscussionList();

Observable.concat(fromDisk, fromNetWork)
        // 如果缓存不为null，则不再进行网络请求。反之
        .first()
        .subscribeOn(Schedulers.io())
        .observeOn(AndroidSchedulers.mainThread())
        .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(BookList discussionList) {

            }
        });

    网络缓存用法，具体可参见我的项目：https://github.com/JustWayward/BookReader

  11. timer
    可以做定时操作，换句话讲，就是延迟执行。事件间隔由timer控制。举个栗子：两秒后输出“Hello World！”

    Observable.timer(2, TimeUnit.SECONDS)
    .subscribe(new Subscriber() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Long aLong) {
            Log.i(TAG, "Hello World!");
        }
    });

  12. interval
    定时的周期性操作，与timer的区别就在于它可以重复操作。事件间隔由interval控制。举个栗子：每隔两秒输出“Hello World！”

    Observable.interval(2, TimeUnit.SECONDS)
    .subscribe(new Subscriber() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Long aLong) {
            Log.i(TAG, "Hello World!");
        }
    });

  13. throttleFirst
    与debounce类似，也是时间间隔太短，就丢弃事件。可以用于防抖操作，比如防止双击。

    RxView.clicks(button)
  .throttleFirst(1, TimeUnit.SECONDS)
  .subscribe(new Observer() {
      @Override
      public void onCompleted() {

      }

      @Override
      public void onError(Throwable e) {

      }

      @Override
      public void onNext(Object o) {
           Log.i(TAG, "do clicked!");
      }
  }); 
    上面这个RxView详见：https://github.com/JakeWharton/RxBinding， 主要与RxJava结合用于一些View的事件绑定，JakeWharton大神的项目，厉害。
      
    
  14.  
    Single 
     Single与Observable类似，相当于是他的精简版。订阅者回调的不是OnNext/OnError/onCompleted，而是回调OnSuccess/OnError。
     
    Single.create(new Single.OnSubscribe() {
    @Override
    public void call(SingleSubscribersuper Object> subscriber) {
        subscriber.onSuccess("Hello");
    }
}).subscribe(new SingleSubscriber() {
    @Override
    public void onSuccess(Object value) {
        Log.i(TAG, value.toString());
    }

    @Override
    public void onError(Throwable error) {

    }
});  
    
  15.  
    Subject 
     Subject这个类，既是Observable又是Observer，啥意思呢？就是它自身既是事件的生产者，又是事件的消费者，相当于自身是一条管道，从一端进，又从另一端出。举个栗子：PublishSubject
     
    Subject subject = PublishSubject.create();

// 1.由于Subject是Observable，所以进行订阅
subject.subscribe(new Subscriber() {
    @Override
    public void onCompleted() {

    }

    @Override
    public void onError(Throwable e) {

    }

    @Override
    public void onNext(Object o) {
        Log.i(TAG, o.toString());
    }
});

// 2.由于Subject同时也是Observer，所以可以调用onNext发送数据
subject.onNext("world"); 
    这个好像有点厉害的样子，哈哈。可以配合debounce，避免SearchEditText频繁请求。
     
    
Subject subject = PublishSubject.create();

subject.debounce(400, TimeUnit.MILLISECONDS)
        .subscribe(new Subscriber() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Object o) {
            // request
        }
    });

edittext.addTextChangedListener(new TextWatcher() {

    @Override 
    public void beforeTextChanged(CharSequence s, int start, int count, int after) { }

    @Override 
    public void onTextChanged(CharSequence s, int start, int before, int count) {
        subject.onNext(s.toString());
    }

    @Override 
    public void afterTextChanged(Editable s) { } 
});  
    
   
    RxJava 应用
     
   
    RxJava+Retrofit 的网络请求方式
     
   
     
    
    Retrofit是一个非常适合RestAPI的网络请求库。没用过的童鞋，还是推荐学一学的。
     
   
     
   
    使用Callback的请求方式：
     
   
    // 1. 定义一个请求接口
@GET("/match/stat")
Call getMatchStat(@Query("mid") String mid, @Query("tabType") String tabType);

// 2. 创建Service对象
Retrofit retrofit = new Retrofit.Builder()
                        .baseUrl(BuildConfig.TENCENT_SERVER)
                        .addConverterFactory(ScalarsConverterFactory.create())
                        .client(OkHttpHelper.getTecentClient()).build();

TencentApi api = retrofit.create(TencentApi.class);

// 3. 调用
Call call = api.getMatchStat(mid, tabType);
call.enqueue(new Callback() {
    @Override
    public void onResponse(Call call, Response response) {
            // 成功
        } else {
            // 无数据
        }
    }

    @Override
    public void onFailure(Call call, Throwable t) {
        // 失败
    }
});
     
   
    与 RxJava 结合的方式，则是
     
   
    // 1. 定义请求接口，返回的是Observable对象
@GET("/user/followers")
Observable> followers();

// 2. 同样是创建api对象
...
// 3. 请求
api.followers()
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe(new Observer>() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {
            // 请求出错。可能发生网络异常、Json解析异常等等
        }

        @Override
        public void onNext(List list) {
            // 请求成功
            view.showMyFollowers(list);
        }
    });
     
   
    若需嵌套请求，比如先获取Token再进行才能进行登录，可参考flatMap操作符最后的获取Readme内容显示在WebView上的例子。
     
   
     
    
    Retrofit2 + RxJava + Dagger2: 具体可参见我的项目，里面有比较详细的用法。 
    https://github.com/JustWayward/BookReader
     
   
     
   
    不难发现，Retrofit 把请求封装进 Observable ，在请求结束后调用 onNext() 以及 OnCompleted() 或在请求失败后调用 onError()。 
     
   
    注：RxJava形式的请求，并不能减少代码量，但是逻辑非常清晰。假如请求到数据之后需要对数据进行处理，并且是耗时操作，难道要再开一个线程，或者用AsyncTask再做一次异步？很显然，RxJava的变换很好的解决了这个问题，依然会使逻辑结构清晰。
     
   
    RxBus
     
   
    准确的来说，是一种基于RxJava实现事件总线的一种思想。可以替代EventBus/Otto，因为他们都依赖于观察者模式。可以参考https://github.com/AndroidKnife/RxBus这个库。
     
   
    RxBinding
     
   
    前面介绍过了，JakeWharton大神的项目，https://github.com/JakeWharton/RxBinding， 主要与RxJava结合用于一些View的事件绑定。
     
   
    RxJava 的一些坑
     
   
    未取消订阅而引起的内存泄漏
     
   
    举个栗子，对于前面常用操作符12.interval做周期性操作的例子，并没有使之停下来的，没有去控制订阅的生命周期，这样，就有可能引发内存泄漏。所以，在Activity#onDestroy()的时候或者不需要继续执行的时候应该取消订阅。
     
   
    Subscription subscription = Observable.interval(2, TimeUnit.SECONDS)
    .subscribe(new Subscriber() {
        @Override
        public void onCompleted() {

        }

        @Override
        public void onError(Throwable e) {

        }

        @Override
        public void onNext(Long aLong) {
            Log.i(TAG, "Hello World!");
        }
    });
// 调用unsubscribe();方法进行取消订阅
subscription.unsubscribe();
     
   
    但是，如果有很多个数据源，那岂不是要取消很多次？当然不是的，可以利用 CompositeSubscription， 相当于一个  Subscription 集合。
     
   
    CompositeSubscription list = new CompositeSubscription();
list.add(subscription1);
list.add(subscription2);
list.add(subscription3);

// 统一调用一次unsubscribe，就可以把所有的订阅都取消
list.unsubscribe();
     
   
    总结
     
   
    相信到了这里，大家对RxJava应该有了一个比较清晰的理解。当然，实践出真知，还是要去尝试，才能更深层次的体会到其强大之处。
     
   
    最后，总结一下RxJava的基本使用过程。
     
   
       
    
    1. 首先是创建事件源源，也就是被观察者，可以用Observable的create/just/from等方法来创建;
      2.  
    
    2. 通过filter/debounce等操作符，进行自定义事件过滤；
      3.  
    
    3. 通过Schedules进行事件发送和订阅的线程控制，也就是subscribeOn() 和 observeOn();
      4.  
    
    4. 通过map/flatMap/compose等操作符，进行事件的变换；
      5.  
    
    5. 调用subscribe进行事件订阅；
      6.  
    
    6. 最后，不要忘了对订阅者生命周期的控制，不用的时候，记得调用unsubscribe()，以免引发内存泄漏。
      7.  
   
     
   
    感谢阅读！
     
   
  

                            
                        
                    
                    
                    
    
                    
                    
                    
    
                
                
    
                    
                
    
            
        
    
    
    
        
    你可能感兴趣的:(Android 下 RxJava 详解，长篇巨作，由浅入深。)
    
        
    
            
    
                
      
                    
    • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
      很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
      
                    
      • 
                    
    • android系统selinux中添加新属性property
                        辉色投像

                        
      1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
      
                    
      • 
                    
    • 2020-01-25
                        晴岚85

                        
      郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
      
                    
      • 
                    
    • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
      前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
      
                    
      • 
                    
    • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
      在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
      
                    
      • 
                    
    • 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了一个项目，并基于该项目做了一些修改，随后你发现原作者对
      
                    
      • 
                    
    • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
      需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
      
                    
      • 
                    
    • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
      摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
      
                    
      • 
                    
    • 《庄子.达生9》
                        钱江潮369

                        
      【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
      
                    
      • 
                    
    • Python中os.environ基本介绍及使用方法
                        鹤冲天Pro
#Pythonpython服务器开发语言
                        
      文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
      
                    
      • 
                    
    • 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"现在你可以开始编写你的第
      
                    
      • 
                    
    • 从鸡肉高汤到记忆的魔法再到有效提示的艺术
                        步子哥
人工智能
                        
      还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
      
                    
      • 
                    
    • 今日囧事
                        唯愿岁月可回首

                        
      今天晚上，房东打来电话说晚上过来取个东西。晚上到家后，洗了一下水果，把卧室的空调打开，在卧室的阳台叠衣服。不一会儿，听见了敲门声，老公和丫头出去开门，果然是房东来了。由于我在叠衣服，床上比较乱，老公随手就把卧室门带上了。我赶紧把衣服收在柜子里，一拧门，好吧，打不开。听见外面热热闹闹的，我喊老公帮我开门，开了几次都开不开。丫头说：妈妈，你先在里面休息一会，我们正在找钥匙。听见外面房东拿了自己东西，老
      
                    
      • 
                    
    • 今天我破防了
                        sin信仰

                        
      今天本来是大年初一，新年的第一天，应该是高高兴兴的一天，但是我怎么也高兴不起来。具体原因很简单，原本计划年后去县城找了一份会计的工作，被公公婆婆否定了，我心里立马就不舒服了，但是当时刚好肚子疼，我去了厕所，等我上完厕所，公公由于喝了酒还在那里和婆婆唠叨个没完。然后我就在心情极度压抑的情况下把午饭吃完的碗筷和锅给刷了。边刷碗筷和锅，边在那里难受，感觉自己在这个家里真的是过的憋屈死了，公婆不让我去上班
      
                    
      • 
                    
    • 谁家酒器最绝唱，藏在酒厂人未知？景阳冈酒厂先秦藏品大揭秘
                        李虓酒评论

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

                        
      近日，关于郎朗大婚的新闻上了热搜，看了新娘的照片，既有天使般的面容，更有魔鬼般的身材，关键是人家还身世好，又有才华，这真的是让所有男人羡慕嫉妒恨哪。有些人不禁会想，“凭什么郎朗的人生就象开挂了一样，可我却每天都活得这么狼狈！”其实，每个开挂的人生背后，都是苦行僧般的自律。01欲戴王冠，必承其重。练琴不能只靠兴趣，更需要自律！我们先来看一下朗朗在小时候的作息时间表：早晨5:45起床，练琴1小时。中午
      
                    
      • 
                    
    • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
      随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
      
                    
      • 
                    
    • 四章-32-点要素的聚合
                        彩云飘过

                        
      本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
      
                    
      • 
                    
    • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
      不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
      
                    
      • 
                    
    • 东南林氏之九牧林候选父系
                        祖缘树TheYtree

                        
      渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
      
                    
      • 
                    
    • 【JS】执行时长(100分) |思路参考+代码解析（C++）
                        l939035548
JS算法数据结构c++
                        
      题目为了充分发挥GPU算力，需要尽可能多的将任务交给GPU执行，现在有一个任务数组，数组元素表示在这1秒内新增的任务个数且每秒都有新增任务。假设GPU最多一次执行n个任务，一次执行耗时1秒，在保证GPU不空闲情况下，最少需要多长时间执行完成。题目输入第一个参数为GPU一次最多执行的任务个数，取值范围[1,10000]第二个参数为任务数组长度，取值范围[1,10000]第三个参数为任务数组，数字范围
      
                    
      • 
                    
    • ARM中断处理过程
                        落汤老狗
嵌入式linux
                        
      一、前言本文主要以ARM体系结构下的中断处理为例，讲述整个中断处理过程中的硬件行为和软件动作。具体整个处理过程分成三个步骤来描述：1、第二章描述了中断处理的准备过程2、第三章描述了当发生中的时候，ARM硬件的行为3、第四章描述了ARM的中断进入过程4、第五章描述了ARM的中断退出过程本文涉及的代码来自3.14内核。另外，本文注意描述ARM指令集的内容，有些sourcecode为了简短一些，删除了T
      
                    
      • 
                    
    • 梁文道《尽头:怎样是好的阅读和书写》 片段
                        白夜书摘

                        
      1、写小说的人，有时会强烈地感到一种现实的召唤，想去面对和回应现实。这时他们会觉得自己正站在时代中心，就像黑格尔说的，要把时代精神掌握在自己的小说（不是哲学）里面。但是这也很危险，当一个作家像一个时代那样书写，可能就会出现问题了。2、文字是远比语言大块而且湿冷的木头，又距离我们内心的火花稍远，不容易瞬间点燃起来，这处隙缝，给了我们回身的余地，可以再多看一下想一下设身处地一下；人类过往这最后五千年，
      
                    
      • 
                    
    • 阶段总结反思
                        轻争

                        
      马上就要进入10月份了，今天做一下前段时间的总结和反思。前段时间，日更、英语、健身、护肤坚持的比较好。阅读、书法坚持的不好。1.中间被迫停更半个多月，其余时间一直在坚持日更挑战。偶尔也有不想写的时候，就做一下摘抄。因为阅读（输入）没跟上来，所以写作（输出）质量有待进一步加强。2.英语做到了一周至少学习5天，每次不少于30分钟，但是小班课没有跟上更新速度，下一步要争取利用零碎时间补听小班课。3.减肥
      
                    
      • 
                    
    • 怎么做淘客赚钱(2022最新免费淘客盈利的方法)
                        高省_飞智666600

                        
      很多人都不知道什么是淘宝客，今天小编为大家解答一下吧。淘宝客，现在简称淘客，是时下比较流行的一个词语，特质为淘宝店推广商品获取提成的人，这些人没有自己的产品，只是在淘宝里面选择适合自己的产品，在自己比较熟悉的领域推广，把产品卖出去之后，会从淘宝店家那里获得百分之五到百分之五十左右的佣金。淘宝客付出的是什么呢？时间。你需要花时间去选适合自己推广的产品，需要花时间去选自己的推广方法，如果你打算自己做个
      
                    
      • 
                    
    • 自我意识
                        徐立华

                        
      ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
      
                    
      • 
                    
    • Python爬虫解析工具之xpath使用详解
                        eqa11
python爬虫开发语言
                        
      文章目录Python爬虫解析工具之xpath使用详解一、引言二、环境准备1、插件安装2、依赖库安装三、xpath语法详解1、路径表达式2、通配符3、谓语4、常用函数四、xpath在Python代码中的使用1、文档树的创建2、使用xpath表达式3、获取元素内容和属性五、总结Python爬虫解析工具之xpath使用详解一、引言在Python爬虫开发中，数据提取是一个至关重要的环节。xpath作为一门
      
                    
      • 
                    
    • C++菜鸟教程 - 从入门到精通 第二节
                        DreamByte
c++
                        
      一.上节课的补充(数据类型)1.前言继上节课,我们主要讲解了输入,输出和运算符,我们现在来补充一下数据类型的知识上节课遗漏了这个知识点,非常的抱歉顺便说一下,博主要上高中了,更新会慢,2-4周更新一次对了,正好赶上中秋节,小编跟大家说一句:中秋节快乐!2.int类型上节课,我们其实只用了int类型int类型,是整数类型,它们存贮的是整数,不能存小数(浮点数)定义变量的方式很简单inta;//定义一
      
                    
      • 
                                
    • Spring4.1新特性——综述
                                    jinnianshilongnian
spring 4.1
                                    
      目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
      
                                
      • 
                                
    • Schema与数据类型优化
                                    annan211
数据结构mysql
                                    
      

目前商城的数据库设计真是一塌糊涂，表堆叠让人不忍直视，无脑的架构师，说了也不听。
在数据库设计之初，就应该仔细揣摩可能会有哪些查询，有没有更复杂的查询，而不是仅仅突出
很表面的业务需求，这样做会让你的数据库性能成倍提高，当然，丑陋的架构师是不会这样去考虑问题的。

选择优化的数据类型
 1 更小的通常更好
   更小的数据类型通常更快，因为他们占用更少的磁盘、内存和cpu缓存，
      
                                
      • 
                                
    • 第一节 HTML概要学习
                                    chenke
htmlWebcss
                                    
      第一节 HTML概要学习 
 
1. 什么是HTML 
 
HTML是英文Hyper Text Mark-up Language(超文本标记语言)的缩写，它规定了自己的语法规则，用来表示比“文本”更丰富的意义，比如图片，表格，链接等。浏览器（IE,FireFox等）软件知道HTML语言的语法，可以用来查看HTML文档。目前互联网上的绝大部分网页都是使用HTML编写的。 
 
打开记事本 输入一下内
      
                                
      • 
                                
    • MyEclipse里部分习惯的更改
                                    Array_06
eclipse
                                    
      继续补充中---------------------- 
 
 
 
1.更改自己合适快捷键windows-->prefences-->java-->editor-->Content Assist--> 
     Activation triggers for java的右侧“.”就可以改变常用的快捷键 
 
选中 Text 
      
                                
      • 
                                
    • 近一个月的面试总结
                                    cugfy
面试
                                    
      本文是在学习中的总结，欢迎转载但请注明出处：http://blog.csdn.net/pistolove/article/details/46753275 
 
 
前言 
      打算换个工作，近一个月面试了不少的公司，下面将一些面试经验和思考分享给大家。另外校招也快要开始了，为在校的学生提供一些经验供参考，希望都能找到满意的工作。 
      
                                
      • 
                                
    • HTML5一个小迷宫游戏
                                    357029540
html5
                                    
           通过《HTML5游戏开发》摘抄了一个小迷宫游戏，感觉还不错，可以画画，写字，把摘抄的代码放上来分享下，喜欢的同学可以拿来玩玩！ 
 
<html> 
 <head> 
 <title>创建运行迷宫</title> 
 <script type="text/javascript"
      
                                
      • 
                                
    • 10步教你上传githib数据
                                    张亚雄
git
                                    
      官方的教学还有其他博客里教的都是给懂的人说得，对已我们这样对我大菜鸟只能这么来锻炼，下面先不玩什么深奥的，先暂时用着10步干净利索。等玩顺溜了再用其他的方法。 
操作过程（查看本目录下有哪些文件NO.1）ls 
（跳转到子目录NO.2）cd+空格+目录 
（继续NO.3）ls 
（匹配到子目录NO.4）cd+ 目录首写字母+tab键+（首写字母“直到你所用文件根就不再按TAB键了”） 
（查看文件
      
                                
      • 
                                
    • MongoDB常用操作命令大全
                                    adminjun
mongodb操作命令
                                    
      成功启动MongoDB后，再打开一个命令行窗口输入mongo，就可以进行数据库的一些操作。输入help可以看到基本操作命令，只是MongoDB没有创建数据库的命令，但有类似的命令   如：如果你想创建一个“myTest”的数据库，先运行use myTest命令，之后就做一些操作（如：db.createCollection('user')）,这样就可以创建一个名叫“myTest”的数据库。   
一
      
                                
      • 
                                
    • bat调用jar包并传入多个参数
                                    aijuans

                                    
      下面的主程序是通过eclipse写的： 
1.在Main函数接收bat文件传递的参数（String[] args） 
 如：   String ip =args[0];          String user=args[1];       &nbs
      
                                
      • 
                                
    • Java中对类的主动引用和被动引用
                                    ayaoxinchao
java主动引用对类的引用被动引用类初始化
                                    
        
在Java代码中，有些类看上去初始化了，但其实没有。例如定义一定长度某一类型的数组，看上去数组中所有的元素已经被初始化，实际上一个都没有。对于类的初始化，虚拟机规范严格规定了只有对该类进行主动引用时，才会触发。而除此之外的所有引用方式称之为对类的被动引用，不会触发类的初始化。虚拟机规范严格地规定了有且仅有四种情况是对类的主动引用，即必须立即对类进行初始化。四种情况如下：1.遇到ne
      
                                
      • 
                                
    • 导出数据库 提示 outfile disabled
                                    BigBird2012
mysql
                                    
      在windows控制台下，登陆mysql，备份数据库： 
  
mysql>mysqldump -u root -p test test > D:\test.sql 
使用命令 mysqldump 格式如下： mysqldump -u root -p *** DBNAME > E:\\test.sql。 
注意：执行该命令的时候不要进入mysql的控制台再使用，这样会报
      
                                
      • 
                                
    • Javascript 中的 && 和 ||
                                    bijian1013
JavaScript&&||
                                    
              准备两个对象用于下面的讨论 
var alice = {
    name: "alice",
    toString: function () {
        return this.name;
    }
}
var smith = {
    name: "smith",
 
      
                                
      • 
                                
    • [Zookeeper学习笔记之四]Zookeeper Client Library会话重建
                                    bit1129
zookeeper
                                    
      为了说明问题，先来看个简单的示例代码： 
  
package com.tom.zookeeper.book;

import com.tom.Host;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.Wat
      
                                
      • 
                                
    • 【Scala十一】Scala核心五：case模式匹配
                                    bit1129
scala
                                    
      package spark.examples.scala.grammars.caseclasses

object CaseClass_Test00 {

  def simpleMatch(arg: Any) = arg match {
    case v: Int => "This is an Int"
    case v: (Int, String)
      
                                
      • 
                                
    • 运维的一些面试题
                                    yuxianhua
linux
                                    
      1、Linux挂载Winodws共享文件夹 
  
mount -t cifs //1.1.1.254/ok /var/tmp/share/ -o username=administrator,password=yourpass
或
mount -t cifs -o username=xxx,password=xxxx //1.1.1.1/a /win 
  
 
      
                                
      • 
                                
    • Java lang包-Boolean
                                    BrokenDreams
boolean
                                    
               Boolean类是Java中基本类型boolean的包装类。这个类比较简单，直接看源代码吧。 
 

public final class Boolean implements java.io.Serializable,
                                      
      
                                
      • 
                                
    • 读《研磨设计模式》-代码笔记-命令模式-Command
                                    bylijinnan
java设计模式
                                    
      声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 


import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

/**
 * GOF 在《设计模式》一书中阐述命令模式的意图：“将一个请求封装
      
                                
      • 
                                
    • matlab下GPU编程笔记
                                    cherishLC
matlab
                                    
      不多说，直接上代码 
 
gpuDevice   %   查看系统中的gpu,,其中的DeviceSupported会给出matlab支持的GPU个数。
g=gpuDevice(1);    %会清空 GPU 1中的所有数据,,将GPU1 设为当前GPU
reset(g)  %也可以清空GPU中数据。

a=1;
a=gpuArray(a);    %将a从CPU移到GPU中
onGP
      
                                
      • 
                                
    • SVN安装过程
                                    crabdave
SVN
                                    
      SVN安装过程 
  
subversion-1.6.12 
  
./configure --prefix=/usr/local/subversion --with-apxs=/usr/local/apache2/bin/apxs --with-apr=/usr/local/apr --with-apr-util=/usr/local/apr --with-openssl=/
      
                                
      • 
                                
    • sql　行列转换
                                    daizj
sql行列转换行转列列转行
                                    
      行转列的思想是通过case when 来实现 
列转行的思想是通过union all 来实现 
 
下面具体例子： 
 
假设有张学生成绩表(tb)如下: 
Name Subject Result 
张三 语文　　74 
张三 数学　　83 
张三 物理　　93 
李四 语文　　74 
李四 数学　　84 
李四 物理　　94 
*/ 
/* 
想变成 
姓名   &
      
                                
      • 
                                
    • MySQL--主从配置
                                    dcj3sjt126com
mysql
                                    
         linux下的mysql主从配置：   说明：由于MySQL不同版本之间的(二进制日志)binlog格式可能会不一样，因此最好的搭配组合是Master的MySQL版本和Slave的版本相同或者更低，   Master的版本肯定不能高于Slave版本。（版本向下兼容）   
   mysql1  : 192.168.100.1    //master   mysq
      
                                
      • 
                                
    • 关于yii 数据库添加新字段之后model类的修改
                                    dcj3sjt126com
Model
                                    
      rules: 
array('新字段','safe','on'=>'search') 
1、array('新字段', 'safe')//这个如果是要用户输入的话，要加一下， 
2、array('新字段', 'numerical'),//如果是数字的话 
3、array('新字段', 'length', 'max'=>100),//如果是文本 
1、2、3适当的最少要加一条，新字段才会被
      
                                
      • 
                                
    • sublime text3 中文乱码解决
                                    dyy_gusi
Sublime Text
                                    
      sublime text3中文乱码解决 
原因：缺少转换为UTF-8的插件 
目的：安装ConvertToUTF8插件包 
第一步：安装能自动安装插件的插件，百度“Codecs33”，然后按照步骤可以得到以下一段代码： 
import urllib.request,os,hashlib; h = 'eb2297e1a458f27d836c04bb0cbaf282' + 'd0e7a30980927
      
                                
      • 
                                
    • 概念了解：CGI，FastCGI，PHP-CGI与PHP-FPM
                                    geeksun
PHP
                                    
      CGI 
CGI全称是“公共网关接口”(Common Gateway Interface)，HTTP服务器与你的或其它机器上的程序进行“交谈”的一种工具，其程序须运行在网络服务器上。 
CGI可以用任何一种语言编写，只要这种语言具有标准输入、输出和环境变量。如php,perl,tcl等。 FastCGI 
FastCGI像是一个常驻(long-live)型的CGI，它可以一直执行着，只要激活后，不
      
                                
      • 
                                
    • Git push 报错 "error: failed to push some refs to " 解决
                                    hongtoushizi
git
                                    
      Git push 报错 "error: failed to push some refs to " . 
此问题出现的原因是：由于远程仓库中代码版本与本地不一致冲突导致的。 
由于我在第一次git pull --rebase 代码后，准备push的时候，有别人往线上又提交了代码。所以出现此问题。 
解决方案： 
1： git pull    
2：
      
                                
      • 
                                
    • 第四章 Lua模块开发
                                    jinnianshilongnian
nginxlua
                                    
      在实际开发中，不可能把所有代码写到一个大而全的lua文件中，需要进行分模块开发；而且模块化是高性能Lua应用的关键。使用require第一次导入模块后，所有Nginx 进程全局共享模块的数据和代码，每个Worker进程需要时会得到此模块的一个副本（Copy-On-Write），即模块可以认为是每Worker进程共享而不是每Nginx Server共享；另外注意之前我们使用init_by_lua中初
      
                                
      • 
                                
    • java.lang.reflect.Proxy
                                    liyonghui160com

                                    
        
1.简介 
  
Proxy 提供用于创建动态代理类和实例的静态方法 
（1）动态代理类的属性 
 
 代理类是公共的、最终的，而不是抽象的 
 未指定代理类的非限定名称。但是，以字符串 "$Proxy" 开头的类名空间应该为代理类保留 
 代理类扩展 java.lang.reflect.Proxy  
 代理类会按同一顺序准确地实现其创建时指定的接口
      
                                
      • 
                                
    • Java中getResourceAsStream的用法
                                    pda158
java
                                    
      1.Java中的getResourceAsStream有以下几种： 1. Class.getResourceAsStream(String path) ： path 不以’/'开头时默认是从此类所在的包下取资源，以’/'开头则是从ClassPath根下获取。其只是通过path构造一个绝对路径，最终还是由ClassLoader获取资源。   　　2. Class.getClassLoader.get
      
                                
      • 
                                
    • spring 包官方下载地址（非maven）
                                    sinnk
spring
                                    
      SPRING官方网站改版后，建议都是通过 Maven和Gradle下载，对不使用Maven和Gradle开发项目的，下载就非常麻烦，下给出Spring Framework jar官方直接下载路径: 
  
 http://repo.springsource.org/libs-release-local/org/springframework/spring/ 
  
s
      
                                
      • 
                                
    • Oracle学习笔记(7) 开发PLSQL子程序和包
                                    vipbooks
oraclesql编程
                                    
          哈哈，清明节放假回去了一下，真是太好了，回家的感觉真好啊！现在又开始出差之旅了，又好久没有来了，今天继续Oracle的学习！ 
     这是第七章的学习笔记，学习完第六章的动态SQL之后，开始要学习子程序和包的使用了……，希望大家能多给俺一些支持啊！ 
    编程时使用的工具是PLSQL
      
                                
      •