LeBron_Six
LeBron_Six

RxJava 从入门到出轨

目录

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

前言

转载请注明出处：http://blog.csdn.net/yyh352091626/article/details/53304728

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

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

RxJava 概念初步

RxJava 在Github 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上一个灵活的、使用可观测序列来组成的一个异步的、基于事件的库。咋一看好像不知道是啥东西… … 没事，往下看~

作用 - 异步

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

RxJava精华可以浓缩为异步两个字，其核心的东西不外乎两个： 

1.  Observable（被观察者） 

2.  Observer/Subscriber（观察者）

Observables可以发出一系列的 事件，这里的事件可以是任何东西，例如网络请求、复杂计算处理、数据库操作、文件操作等等，事件执行结束后交给 Observer/Subscriber 的回调处理。

模式 - 观察者模式

观察者模式是一种对象的行为模式，是 Java 设计模式中很常用的一个模式。观察者模式也常称为:

发布-订阅模式(Publish/Subscribe)

模型-视图模式(Model/View)

源-监听器模式(Source/Listener)

从属者模式(Dependents)

例如用过事件总线 EventBus 库的童鞋就知道，EventBus 属于发布-订阅模式(Publish/Subscribe)。

// 事件订阅
@Subscribe(threadMode = ThreadMode.MAIN)
public void showDownProgress(MyEvent event) {
     // TODO
}

// 事件发布
EventBus.getDefault().post(new MyEvent());

实际上，使用 RxJava 也可以设计出一套事件总线的库，这个称为 RxBus。有兴趣的话可以在学完 RxJava 之后，可以尝试写一个。这里就不细说了~

为啥说这个呢？因为，RxJava 也是一种扩展的观察者模式！

举个栗子，Android 中 View 的点击监听器的实现，View 是被观察者，OnClickListener 对象是观察者，Activity 要如何知道 View 被点击了？那就是构造一个 OnClickListener 对象，通过 setOnClickListener 与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 Studio 项目下，为 module 增加 Gradle 依赖。

// 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);
    }
};
  1. Observer 是观察者， Subscriber 也是观察者，Subscriber 是一个实现了Observer接口的抽象类，对 Observer 进行了部分扩展，在使用上基本没有区别；
  2. Subscriber 多了发送之前调用的 onStart() 和解除订阅关系的 unsubscribe() 方法。
  3. 并且，在 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() 方法，通过泛型T，来指定对应参数的类型；

入门示例

前面讲解了事件的产生到消费、订阅的过程，下面就举个完整的例子。从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", mission_list1));
        add(new Employee("sunny", mission_list2));
    }
};
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())，仍然是在主线程执行，可能会造成界面卡顿甚至崩溃，所以耗时操作还是使用Observable.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 >= 100)
                    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)

// 加入RxJava支持
                        .addCallAdapterFactory(RxJavaCallAdapterFactory.create()) 
                        .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) {
        if(response != null && response.body()!=null)
            // 成功
        } 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开发)
    
        
    
            
    
                
      
                    
    • Android应用性能优化
                        轻口味
Android
                        
      Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
      
                    
      • 
                    
    • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
      总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
      
                    
      • 
                    
    • Visual Studio中的Android模拟器使用详解
                        wurui8
androidandroidstudioandroidandroid应用
                        
      关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
      
                    
      • 
                    
    • （小白入门）Windows环境下搭建React Native Android开发环境
                        码农老黑
前端ReactNative移动开发Androidstudio
                        
      ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
      
                    
      • 
                    
    • 使用 ADB 命令在 Android 设备上进行截屏
                        开心呆哥
adbandroid
                        
      在Android开发和调试过程中，截取设备屏幕是一项非常有用的功能。ADB（AndroidDebugBridge）是一个强大的工具，可以帮助我们与Android设备进行通信和调试。本文将介绍如何使用ADB命令在Android设备上进行截屏。1.准备工作在开始之前，确保你已经完成以下准备工作：在计算机上安装好AndroidSDK，并且配置好了ADB。连接你的Android设备到计算机，并确保ADB能
      
                    
      • 
                    
    • 字节跳动面试官亲述：Android开发学会了这些技术，你离大厂不远了
                        m0_65322636
程序员架构移动开发android
                        
      HTTPSHTTP是超文本传输协议，明文传输；HTTPS使用SSL协议对HTTP传输数据进行了加密HTTP默认80端口；HTTPS默认443端口优点：安全缺点：费时、SSL证书收费，加密能力还是有限的，但是比HTTP强多了2、Java基础&容器&同步&设计模式StringBuilder、StringBuffer、+、String.concat链接字符串：StringBuffer线程安全，Strin
      
                    
      • 
                    
    • Java 学习路线：语言、框架、中间件与数据库
                        高危型
java
                        
      Java是一门功能强大、应用广泛的编程语言，适用于企业级应用、Web开发、大数据处理、Android开发等各种场景。这里为大家介绍了一下我认为较为合适的学习路线一、Java基础1.1Java语言基础1.1.1安装JDK和IDE安装JDK：下载JDK：访问Oracle官网，下载最新的JavaDevelopmentKit（JDK）。安装JDK：按照操作系统要求安装JDK并配置环境变量。Windows上
      
                    
      • 
                    
    • ADB 之 logcat 极简小抄（过滤日志、保存日志到文件）
                        我命由我12345
Android-ADB-极简小抄adb安卓android-studioandroidstudioandroid运维开发运维
                        
      一、logcatlogcat是Android开发中用于查看系统日志信息的工具二、logcat极简小抄1、查看日志adblogcat2、过滤日志按标签过滤日志adblogcat-s【标签】#演示：按标签test过滤日志adblogcat-stest按等级过滤日志adblogcat*:【等级】#V：Verbose，显示所有级别的日志#D：Debug，显示Debug级别及以上的日志#I：Info，显示I
      
                    
      • 
                    
    • Unity 插件 UniWebView，可以内嵌网页/浏览器到应用中
                        Jinx Boy
unity游戏引擎android
                        
      给大家推荐一个非常好用的unity内嵌网页插件：UniWebView最近在做安卓pad应用开发，需要用到内嵌网页的功能，发现这个最好用。一拖一改就可以了就是遇到了两个问题：一个是没有定位权限有些网页会打不开，解决方案可以看这篇：UnityAndroid内嵌网页，网页不开，没有定位权限另一个是加密的网页内容不允许加载，解决方案可以看这篇：Android开发，嵌入网页，网页打不开报错ERR_CLEAR
      
                    
      • 
                    
    • 实例化ViewModel的三种方式及对比
                        兰亭大境
开发语言kotlin
                        
      privatevalvm:DemoViewModelbyviewModels()privatevalvm2bylazy{ViewModelProvider(this).get(DemoViewModel::class.java)}privatevalvm3bylazy{WeakReference(DemoViewModel()).get()}在Android开发中，三种方式用于获取ViewMode
      
                    
      • 
                    
    • 字节跳动资深面试官亲述：15个经典面试问题及回答思路，知乎上转疯了！
                        左夜天
程序员android
                        
      前言这是“拔剑金九银十”的第二篇文章，本文主要针对3年以上的Android开发者进阶面试中高级开发工程师而整理。希望可以对你们有所帮助。不多废话，进入正题。目录：Java中高级计算机网络Android高级面试—性能优化Android优秀第三方库Androidframework相关其他Android高频面试题阿里P7薪资待遇**阿里薪资结构：**一般是12+1+3=16薪•年底的奖金为0-6个月薪资
      
                    
      • 
                    
    • Android开发使用框架手把手搭建一个简单项目
                        TTTTao2323
Androidandroid学习架构javakotlin
                        
      前言：年关将近，公司也没有什么业务了，基本上都是些旧项目维护以及客户给出的功能改动等小需求。正好其中有个需求是关于某个维护了近五年的小项目功能改动，由于这个项目当时搭建得并不好再加上后续的功能变化和最初设计时出入比较大，以至于每次收到有关这个项目的新需求时我都会非常头疼，于是就趁着这段业务空闲期把整个项目优化重构一遍，这样一来就算后续有了新的改动需求维护这个项目的同事也不再会因为“在屎山里面加屎”
      
                    
      • 
                    
    • Jetpack Compose 架构如何选？MVP 、 MVVM 还是 MVI？
                        goodhighting
程序员架构
                        
      首先，先看看不借助任何架构的Compose代码是怎样的？不使用架构的情况下，逻辑代码将与UI代码耦合在一起，在Compose中这种弊端显得尤为明显。常规Android开发默认引入了MVC思想，XML的布局方式使得UI层与逻辑层有了初步的解耦。但是Compose中，布局和逻辑同样都使用Kotlin实现，当布局中夹了杂逻辑，界限变得更加模糊。此外，ComposeUI中混入逻辑代码会带来更多的潜在隐患。
      
                    
      • 
                    
    • 手把手带你搭建一个优秀的Android项目架构
                        赖欣昱

                        
      手把手带你搭建一个优秀的Android项目架构XArchAndroid架构最佳实践-手把手带你搭建一个优秀的Android项目架构项目地址:https://gitcode.com/gh_mirrors/xa/XArch项目介绍在现代Android开发中，一个优秀的项目架构是确保项目可维护性、可扩展性和高效性的关键。本文介绍的开源项目正是为了解决这一需求而诞生的。该项目不仅提供了一个完整的Andro
      
                    
      • 
                    
    • 探索Android开发新境界：MVI架构的卓越实践
                        宣苓滢Rosa

                        
      探索Android开发新境界：MVI架构的卓越实践android-architecture追求android架构更佳实践~项目地址:https://gitcode.com/gh_mirrors/an/android-architecture在快速迭代的Android开发领域，追求高效、可维护的架构一直是开发者们的共同目标。今天，我们聚焦于一个值得关注的开源项目——Android架构更佳实践，这是一
      
                    
      • 
                    
    • 4-5.Android Camera 之其他方式预览图像编码模板（TextureView）
                        我命由我12345
Android-简化编程androidjavajava-eeandroid-studioandroidstudio安卓
                        
      一、CameraCamera用于捕获图像和视频在Android开发的早期阶段，Android提供android.hardware.CameraAPI，开发者用它来访问和控制设备的摄像头硬件然而，随着Android系统的发展，从Android5.0（API级别21）开始，Android引入了一个新的Camera2API，以提供更强大和灵活的控制功能二、Camera图像预览1、UtilMyCamera
      
                    
      • 
                    
    • android 相机预览的分辨率,Android开发 Camera2开发_2_预览分辨率或拍照分辨率的计算...
                        吴适于
android相机预览的分辨率
                        
      前言不管在Camera1或者Camera2在适配不同手机/不同使用场景的情况下都需要计算摄像头里提供的分辨率列表中最合适的那一个分辨率.所以在需要大量机型适配的app,是不建议不经过计算直接自定义分辨率设置到预览或者拍照照片中,有概率会因为摄像头不支持你输入的自定义分辨率导致报错或者打不开摄像头.如果你的确有需求要自定义分辨率,那么使用场景只有一个那就是你是在开发Android设备,并且你输入的自
      
                    
      • 
                    
    • Android 组件化，从入门到不可自拔
                        字节跳不动

                        
      前言组件化技术，在Android开发中有着举足轻重的作用。随着时间推移，软件项目很多都会变得越来越庞杂。此时，采用组件化技术，对项目进行改造，是一种较优的方案。谈谈模块化要聊组件化，惯例是要谈谈模块化的，毕竟它与组件化确实有一些相同点，在组件化的项目中它也会与组件化发生关联。什么是模块化模块化开发，是每个开发者都熟悉的。即将常用的UI、网络请求、数据库操作、第三方库的使用等公共部分抽离封装成基础模
      
                    
      • 
                    
    • 一个Android开发者的React Native之路
                        青灯明月
RNAndroidReactandroidreactnative
                        
      这是一个Android开发者一个月以来学习ReactNative的一些经验和感悟，如有错漏之处敬请指出~1.什么是ReactNativeReactNative是Facebook在2015年开源的一个项目，用官方的话来解释就是：ReactNativeletsyoubuildmobileappsusingonlyJavaScriptReactNative让你只用JavaScript就能编写移动端App
      
                    
      • 
                    
    • 解锁Android开发利器：MVVM架构_android的mvvm
                        2401_86637402
面试辅导大厂内推android架构
                        
      //从网络或其他数据源获取天气数据returnWeather(city,"25°C")}}2.定义View：classWeatherActivity:AppCompatActivity(){privatelateinitvarviewModel:WeatherViewModeloverridefunonCreate(savedInstanceState:Bundle?){super.onCreat
      
                    
      • 
                    
    • React Native新架构系列-C++实现跨平台Turbo Native Module
                        林克在思考
ReactNativereactnativec++react.js
                        
      今天我们介绍在ReactNative新架构中如何C++代码实现一个跨平台的C++TurboNativeModule扩展API。阅读本文前建议阅读上一篇文章。本系列基于ReactNative0.73.4版本，从一名Android开发者的视角进行介绍。本系列介绍的内容默认读者对ReactNative有一定的了解，对基础的开发内容不再赘述。在上一篇文章中ReactNative新架构系列-自定义Turbo
      
                    
      • 
                    
    • 2020年是做安卓开发人员的绝佳时机，android开发面试自我介绍
                        m0_66144765
程序员架构移动开发android
                        
      你这样做仅仅是准备好一个开发环境去构建安卓App,但是你还得去准备好基础和基本知识来理解安卓开发和大多数教程使用的通用术语你现在也可以在安卓系统上构建基本的App，并且可以开发一些功能。随意使用空白画布，用你的想象力填充它。当你玩完创意后，2020年你的下一个目标是加快游戏进度，推动自己成为一名为数十亿人构建应用的开发者。我们现在去第二层！提升自己-作为一个安卓开发者Level2这个列表将作为你学
      
                    
      • 
                    
    • 2024年Android开发60条技术经验总结，2024年最新面试安卓系统架构
                        2301_82243733
程序员android面试学习
                        
      总结【Android详细知识点思维脑图（技能树）】我个人是做Android开发，已经有十来年了，目前在某创业公司任职CTO兼系统架构师。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪资真的特别高（钱多也不一定能找到合适的），所以努力让自己成为高级工程师才是最重要的。这里
      
                    
      • 
                    
    • SQLite数据库管理与Android应用集成
                        含老司开挖掘机

                        
      本文还有配套的精品资源，点击获取简介：SQLite是一种轻量级的关系型数据库，适用于移动设备和单机应用。它内置了对SQL标准的支持，并提供丰富的数据操作功能。在Android开发中，SQLite是默认的数据库解决方案，可通过SQLiteOpenHelper和SQLiteDatabaseAPI进行管理。本教程将通过实践帮助理解SQLite数据库的创建、管理和使用，以及如何将其与Android应用集成
      
                    
      • 
                    
    • 4-2.Android Camera 之预览图像编码模板（SurfaceView）
                        我命由我12345
Android-简化编程androidjavajava-eeandroid-studioandroidstudio视频
                        
      一、CameraCamera用于捕获图像和视频在Android开发的早期阶段，Android提供android.hardware.CameraAPI，开发者用它来访问和控制设备的摄像头硬件然而，随着Android系统的发展，从Android5.0（API级别21）开始，Android引入了一个新的Camera2API，以提供更强大和灵活的控制功能二、Camera预览图像1、UtilMyCamera
      
                    
      • 
                    
    • Kotlin 枚举类
                        wjs2024
开发语言
                        
      Kotlin枚举类概述Kotlin是一种现代的编程语言，由JetBrains开发，旨在提高开发者的工作效率和代码质量。它运行在Java虚拟机(JVM)上，与Java完全兼容，同时提供了许多现代语言特性，如空安全、扩展函数和协程等。Kotlin的设计哲学是简洁和表达性，这使得它成为Android开发的官方语言，并在后端开发中也越来越受欢迎。Kotlin枚举类简介枚举类是Kotlin中的一种特殊类，用
      
                    
      • 
                    
    • Android开发、adb、monkey测试
                        AoChengi

                        
      一、手机测试概念传统手机测试VS手机应用软件测试传统手机测试：指测试手机本身比如抗压，抗摔，抗疲劳，抗低温高温等。也包括手机本身功能、性能等测试。手机应用软件测试C/SClient/Server手机应用软件是基于手机操作系统之上开发出来的软件，做这样的测试就叫做手机应用软件测试。二、手机端常规测试2.1.What2.1.1.介绍手机测试的概念架构image.pngimage.png对于手机端测试，
      
                    
      • 
                    
    • 单例模式双重锁中volatile的作用
                        Mr Lee_
AndroidJava单例模式java开发语言
                        
      对于学android开发的同学来说，单例模式应该在熟悉不过了吧，单例模式（SingletonPattern）是Java中最简单的设计模式之一，还可以分为饿汉式和懒汉式，这篇文章浅谈下懒汉式，重点讲一下饿汉式的volatile的作用，如有什么问题，还请大家多多指教哈！！！懒汉式顾名思义，就是一个很懒的人，他什么都不想动，就只想着躺平，只有到饿了的时候才会去找吃的，简单来说就是一开始并不会去实例化，只
      
                    
      • 
                    
    • Android Camera系列（三）：GLSurfaceView+Camera
                        如果可以003
AndroidCameraandroidCameraGLSurfaceView
                        
      人类的悲欢并不相通—鲁迅AndroidCamera系列（一）：SurfaceView+CameraAndroidCamera系列（二）：TextureView+CameraAndroidCamera系列（三）：GLSurfaceView+Camera本系列主要讲述Android开发中Camera的相关操作、预览方式、视频录制等，项目结构代码耦合性低，旨在帮助大家能从中有所收获（方便copy:）），
      
                    
      • 
                    
    • Unity 对接 Android 第三方广告，App 切换到后台后，再次打开时，第三方广告被销毁导致无法触发回调逻辑的问题
                        艾沃尼斯
苦大仇深AndroidStudioandroid
                        
      该问题是由发行进行游戏测试时遇到并反馈的。大致情况如下：1.当触发了插屏广告后，在关闭广告前将App切换到后台，之后再次打开App，此时插屏广告消失，并切游戏卡死。2.当触发激励视频广告后，在广告展示完毕前将App切换到后台，之后再次打开App，此时激励视频广告消失，并且不会获得奖励。虽然接第三方广告也接了很长一段时间了，但这个问题头一次遇到，因为不是专业Android开发人员，所以也一脸懵逼。解
      
                    
      • 
                                
    • Dom
                                    周华华
JavaScripthtml
                                    
      <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> 
<html xmlns="http://www.w3.org/1999/xhtml&q
      
                                
      • 
                                
    • 【Spark九十六】RDD API之combineByKey
                                    bit1129
spark
                                    
      1. combineByKey函数的运行机制 
  
RDD提供了很多针对元素类型为(K,V)的API，这些API封装在PairRDDFunctions类中，通过Scala隐式转换使用。这些API实现上是借助于combineByKey实现的。combineByKey函数本身也是RDD开放给Spark开发人员使用的API之一 
  
首先看一下combineByKey的方法说明：
      
                                
      • 
                                
    • msyql设置密码报错：ERROR 1372 (HY000): 解决方法详解
                                    daizj
mysql设置密码
                                    
      MySql给用户设置权限同时指定访问密码时，会提示如下错误： 
ERROR 1372 (HY000): Password hash should be a 41-digit hexadecimal number； 
  
问题原因：你输入的密码是明文。不允许这么输入。 
  
解决办法：用select password('你想输入的密码');查询出你的密码对应的字符串， 
然后
      
                                
      • 
                                
    • 路漫漫其修远兮 吾将上下而求索
                                    周凡杨
学习 思索
                                    
      王国维在他的《人间词话》中曾经概括了为学的三种境界古今之成大事业、大学问者，罔不经过三种之境界。“昨夜西风凋碧树。独上高楼，望尽天涯路。”此第一境界也。“衣带渐宽终不悔，为伊消得人憔悴。”此第二境界也。“众里寻他千百度，蓦然回首，那人却在灯火阑珊处。”此第三境界也。学习技术，这也是你必须经历的三种境界。第一层境界是说，学习的路是漫漫的，你必须做好充分的思想准备，如果半途而废还不如不要开始。这里，注
      
                                
      • 
                                
    • Hadoop(二)对话单的操作
                                    朱辉辉33
hadoop
                                    
      Debug： 
 
1、 
 
A = LOAD '/user/hue/task.txt' USING PigStorage(' ') 
AS (col1,col2,col3); 
DUMP A; 
 
//输出结果前几行示例： 
(>ggsnPDPRecord(21),,) 
(-->recordType(0),,) 
(-->networkInitiation(1),,) 

      
                                
      • 
                                
    • web报表工具FineReport常用函数的用法总结（日期和时间函数）
                                    老A不折腾
finereport报表工具web开发
                                    
      web报表工具FineReport常用函数的用法总结（日期和时间函数） 
  
说明：凡函数中以日期作为参数因子的，其中日期的形式都必须是yy/mm/dd。而且必须用英文环境下双引号(" ")引用。 
  
DATE 
DATE(year,month,day):返回一个表示某一特定日期的系列数。 
Year:代表年，可为一到四位数。 
Month:代表月份。
      
                                
      • 
                                
    • c++ 宏定义中的##操作符
                                    墙头上一根草
C++
                                    
      #与##在宏定义中的--宏展开 #include <stdio.h> #define f(a,b) a##b #define g(a)   #a #define h(a) g(a) int main() {       &nbs
      
                                
      • 
                                
    • 分析Spring源代码之，DI的实现
                                    aijuans
springDI现源代码
                                    
      (转) 
   
分析Spring源代码之，DI的实现  
2012/1/3 by tony 
                接着上次的讲，以下这个sample    
[java]  
view plain 
copy 
print 

      
                                
      • 
                                
    • for循环的进化
                                    alxw4616
JavaScript
                                    
      // for循环的进化
// 菜鸟
for (var i = 0; i < Things.length ; i++) {
	// Things[i]
}

// 老鸟
for (var i = 0, len = Things.length; i < len; i++) {
	// Things[i]
}

// 大师
for (var i = Things.le
      
                                
      • 
                                
    • 网络编程Socket和ServerSocket简单的使用
                                    百合不是茶
网络编程基础IP地址端口
                                    
        
网络编程;TCP/IP协议 
  
网络:实现计算机之间的信息共享,数据资源的交换 
  
协议:数据交换需要遵守的一种协议,按照约定的数据格式等写出去 
  
端口:用于计算机之间的通信 
     每运行一个程序，系统会分配一个编号给该程序，作为和外界交换数据的唯一标识 
0~65535 
  
查看被使用的
      
                                
      • 
                                
    • JDK1.5 生产消费者
                                    bijian1013
javathread生产消费者java多线程
                                    
      ArrayBlockingQueue： 
       一个由数组支持的有界阻塞队列。此队列按 FIFO（先进先出）原则对元素进行排序。队列的头部 是在队列中存在时间最长的元素。队列的尾部 是在队列中存在时间最短的元素。新元素插入到队列的尾部，队列检索操作则是从队列头部开始获得元素。 
ArrayBlockingQueue的常用方法： 

      
                                
      • 
                                
    • JAVA版身份证获取性别、出生日期及年龄
                                    bijian1013
java性别出生日期年龄
                                    
              工作中需要根据身份证获取性别、出生日期及年龄，且要还要支持15位长度的身份证号码，网上搜索了一下，经过测试好像多少存在点问题，干脆自已写一个。 
CertificateNo.java 
package com.bijian.study;

import java.util.Calendar;
import 
      
                                
      • 
                                
    • 【Java范型六】范型与枚举
                                    bit1129
java
                                    
      首先，枚举类型的定义不能带有类型参数，所以，不能把枚举类型定义为范型枚举类，例如下面的枚举类定义是有编译错的 
  
public enum EnumGenerics<T> { //编译错，提示枚举不能带有范型参数
    OK, ERROR;
    public <T> T get(T type) {
        return null;
    
      
                                
      • 
                                
    • 【Nginx五】Nginx常用日志格式含义
                                    bit1129
nginx
                                    
      1. log_format 
1.1 log_format指令用于指定日志的格式，格式： 
  
log_format name(格式名称) type(格式样式) 
  
1.2 如下是一个常用的Nginx日志格式： 
  
log_format      main    '[$time_local]|$request_time|$status|$body_bytes
      
                                
      • 
                                
    • Lua 语言 15 分钟快速入门
                                    ronin47
lua 基础
                                    
      -
- 
单行注释   
-
-
[[   
    
[多行注释]   
-
-
]]       
-
-
-
-
-
-
-
-
-
-   
- 
1. 
变量 & 控制流   
-
-
-
-
-
-
-
-
-
-   
num 
= 
23 
-
- 
数字都是双精度   
str 
= 
'aspythonstring' 

      
                                
      • 
                                
    • java-35.求一个矩阵中最大的二维矩阵 ( 元素和最大 )
                                    bylijinnan
java
                                    
      the idea is from: 
http://blog.csdn.net/zhanxinhang/article/details/6731134 
 


public class MaxSubMatrix {

	/**see http://blog.csdn.net/zhanxinhang/article/details/6731134
	 * Q35
求一个矩阵中最大的二维
      
                                
      • 
                                
    • mongoDB文档型数据库特点
                                    开窍的石头
mongoDB文档型数据库特点
                                    
      MongoDD: 文档型数据库存储的是Bson文档-->json的二进制 
 
特点：内部是执行引擎是js解释器，把文档转成Bson结构，在查询时转换成js对象。 
 
mongoDB传统型数据库对比 
   传统类型数据库：结构化数据，定好了表结构后每一个内容符合表结构的。也就是说每一行每一列的数据都是一样的 
   文档型数据库：不用定好数据结构，
      
                                
      • 
                                
    • [毕业季节]欢迎广大毕业生加入JAVA程序员的行列
                                    comsci
java
                                    
       
    一年一度的毕业季来临了。。。。。。。。 
 
     正在投简历的学弟学妹们。。。如果觉得学校推荐的单位和公司不适合自己的兴趣和专业，可以考虑来我们软件行业，做一名职业程序员。。。 
 
     软件行业的开发工具中，对初学者最友好的就是JAVA语言了，网络上不仅仅有大量的
      
                                
      • 
                                
    • PHP操作Excel – PHPExcel 基本用法详解
                                    cuiyadll
PHPExcel
                                    
      导出excel属性设置//Include classrequire_once('Classes/PHPExcel.php');require_once('Classes/PHPExcel/Writer/Excel2007.php');$objPHPExcel = new PHPExcel();//Set properties 设置文件属性$objPHPExcel->getProperties
      
                                
      • 
                                
    • IBM Webshpere MQ Client User Issue (MCAUSER)
                                    darrenzhu
IBMjmsuserMQMCAUSER
                                    
      IBM MQ JMS Client去连接远端MQ Server的时候，需要提供User和Password吗？ 
答案是根据情况而定，取决于所定义的Channel里面的属性Message channel agent user identifier (MCAUSER)的设置。 
 
 
http://stackoverflow.com/questions/20209429/how-mca-user-i
      
                                
      • 
                                
    • 网线的接法
                                    dcj3sjt126com

                                    
      一、PC连HUB (直连线)A端：（标准568B）：白橙，橙，白绿，蓝，白蓝，绿，白棕，棕。 B端：（标准568B）：白橙，橙，白绿，蓝，白蓝，绿，白棕，棕。 二、PC连PC （交叉线）A端：(568A)： 白绿，绿，白橙，蓝，白蓝，橙，白棕，棕； B端：（标准568B）：白橙，橙，白绿，蓝，白蓝，绿，白棕，棕。 三、HUB连HUB&nb
      
                                
      • 
                                
    • Vimium插件让键盘党像操作Vim一样操作Chrome
                                    dcj3sjt126com
chromevim
                                    
      什么是键盘党？ 
 
 键盘党是指尽可能将所有电脑操作用键盘来完成，而不去动鼠标的人。鼠标应该说是新手们的最爱，很直观，指哪点哪，很听话！不过常常使用电脑的人，如果一直使用鼠标的话，手会发酸，因为操作鼠标的时候，手臂不是在一个自然的状态，臂肌会处于绷紧状态。而使用键盘则双手是放松状态，只有手指在动。而且尽量少的从鼠标移动到键盘来回操作，也省不少事。 
 在chrome里安装 vimium 插件 

      
                                
      • 
                                
    • MongoDB查询（2）——数组查询[六]
                                    eksliang
mongodbMongoDB查询数组
                                    
      MongoDB查询数组 
转载请出自出处：http://eksliang.iteye.com/blog/2177292 一、概述 
 MongoDB查询数组与查询标量值是一样的，例如，有一个水果列表，如下所示： 
> db.food.find()
{ "_id" : "001", "fruits" : [ "苹
      
                                
      • 
                                
    • cordova读写文件（1）
                                    gundumw100
JavaScriptCordova
                                    
      使用cordova可以很方便的在手机sdcard中读写文件。 
 
首先需要安装cordova插件：file 
命令为： 
 
cordova plugin add org.apache.cordova.file 
 
然后就可以读写文件了，这里我先是写入一个文件，具体的JS代码为： 
 


var datas=null;//datas need write
var directory=&
      
                                
      • 
                                
    • HTML5 FormData 进行文件jquery ajax 上传 到又拍云
                                    ileson
jqueryAjaxhtml5FormData
                                    
      html5 新东西：FormData  可以提交二进制数据。 
 
 
页面test.html 
 

<!DOCTYPE>
<html>
<head>
<title> formdata file jquery ajax upload</title>
</head>

<body>
<
      
                                
      • 
                                
    • swift appearanceWhenContainedIn:(version1.2 xcode6.4)
                                    啸笑天
version
                                    
        
swift1.2中没有oc中对应的方法： 
+ (instancetype)appearanceWhenContainedIn:(Class <UIAppearanceContainer>)ContainerClass, ... NS_REQUIRES_NIL_TERMINATION; 
 解决方法： 
在swift项目中新建oc类如下： 
#import &
      
                                
      • 
                                
    • java实现SMTP邮件服务器
                                    macroli
java编程
                                    
      电子邮件传递可以由多种协议来实现。目前，在Internet 网上最流行的三种电子邮件协议是SMTP、POP3 和 IMAP，下面分别简单介绍。 
　　◆ SMTP 协议 
　　简单邮件传输协议(Simple Mail Transfer Protocol,SMTP)是一个运行在TCP/IP之上的协议，用它发送和接收电子邮件。SMTP 服务器在默认端口25上监听。SMTP客户使用一组简单的、基于文本的
      
                                
      • 
                                
    • mongodb group by having where 查询sql
                                    qiaolevip
每天进步一点点学习永无止境mongo纵观千象
                                    
      SELECT cust_id,
       SUM(price) as total
FROM orders
WHERE status = 'A'
GROUP BY cust_id
HAVING total > 250

db.orders.aggregate( [
   { $match: { status: 'A' } },
   {
     $group: {

      
                                
      • 
                                
    • Struts2 Pojo（六）
                                    Luob.
POJOstrust2
                                    
      注意：附件中有完整案例 
1.采用POJO对象的方法进行赋值和传值 
2.web配置 
 

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee&q
      
                                
      • 
                                
    • struts2步骤
                                    wuai
struts
                                    
      1、添加jar包 
2、在web.xml中配置过滤器 
 <filter> 
       <filter-name>struts2</filter-name> 
       <filter-class>org.apache.st
      
                                
      •