RxJava使用介绍

RxJava介绍

RxJava 是一个响应式编程框架，采用观察者设计模式。所以自然少不了 Observable 和 Subscriber 这两个东东了。用于通过使用观察序列构成异步和基于事件的程序库.

RxJava 是一个开源项目，地址：https://github.com/ReactiveX/RxJava

RxJava 扩展了观察者模式，以支持数据、事件序列，并增加了参数，让你编写的序列一起同时申明抽象事物，如低级别的线程、同步，提高线程安全和避免因为并发导致的数据担忧；

Java

public static void hello(String... names) {
    Observable.from(names).subscribe(new Action1<String>() {

        @Override
        public void call(String s) {
            System.out.println("Hello " + s + "!");
        }

    });
}

输出

hello("Ben", "George");

Hello Ben!
Hello George!

基础知识

响应式代码的基本组成部分是Observables和Subscribers（事实上Observer才是最小的构建块，但实践中使用最多的是Subscriber，因为Subscriber才是和Observables的对应的。）。Observable发送消息，而Subscriber则用于消费消息。

消息的发送是有固定模式的。Observable可以发送任意数量的消息（包括空消息），当消息被成功处理或者出错时，流程结束。Observable会调用它的每个Subscriber的Subscriber.onNext()函数，并最终以Subscriber.onComplete()或者Subscriber.onError()结束。

这看起来像标准的观察者模式，但不同的一个关键点是：Observables一般只有等到有Subscriber订阅它，才会开始发送消息（术语上讲就是热启动Observable和冷启动Observable。热启动Observable任何时候都会发送消息，即使没有任何观察者监听它。冷启动Observable只有在至少有一个订阅者的时候才会发送消息（我的例子中都是只有一个订阅者）。这个区别对于开始学习RxJava来说并不重要。）。换句话说，如果没有订阅者观察它，那么将不会起什么作用。

如何设计使用RXJAVA

使用RxJava创建观测者（其中操作参数），变换各种方式的观测者，以获得精确的数据项你感兴趣的（通过使用可观察到的参数），然后观察，并实施观察员反应的有趣的项目，这些序列（或订户然后订阅他们得到的变换观测者）。

添加

Maven

<dependency>
    <groupId>io.reactivex</groupId>
    <artifactId>rxjava</artifactId>
    <version>x.y.z</version>
</dependency>

Ivy

<dependency org="io.reactivex" name="rxjava" rev="x.y.z" />

实际项目代码举例程序：

    List<Map> paraList = new ArrayList<Map>();
    paraList = (List<Map>) map.get("paraMap");
    for (Map paraMap : paraList) {
        Iterator<String> mapIter = map.keySet().iterator();
        while (mapIter.hasNext()) {
            String key = mapIter.next();
            if (map.get(key) instanceof String) {
                paraMap.put(key, map.get(key));
            }
        }
    }

    final List<Map> resultList = new ArrayList<Map>();
    //Func1(from,to) 
    Observable.from(paraList).parallel(new Func1<Observable<Map>, Observable<Map>>() {
        @Override
        public Observable<Map> call(Observable<Map> request) {
            return request.map(new Func1<Map, Map>() {
                @Override
                public Map call(Map paraMap) {
                    Map resultMap = new HashMap();
                    try {
                        resultMap = commonCalculateQueryService.commonCalculate(paraMap);
                    } catch (Exception e) {
                        logger.debug(" execute Query : " + e.toString());
                        Map exceptionMap = new HashMap();
                        exceptionMap.put("request_uuid", (String) paraMap.get("requestUuid"));
                        exceptionMap.put("process_unit", Result.NOR);
                        exceptionMap.put("exception_text", e.toString());
                        exceptionMap.put("insert_by", "Lenvon");
                        commonCalculateQueryService.insertResultProcessException(exceptionMap);
                        resultMap.put("replyCode", ReplyCode.ERROR);
                        resultMap.put("replyText", e.toString());
                        resultMap.put("status", StatusCode.N);
                        logger.error(" FreightCalculator Exception : ", e);
                    }
                    return resultMap;
                }
            });
        }
    }, Schedulers.threadPoolForComputation()).toBlockingObservable().forEach(new Action1<Map>() {
        @Override
        public void call(Map resultMap) {
            resultList.add(resultMap);
        }
    });

其中

paraList：操作参数队列；

resultList：结果队列；

实际处理图序：