封装一个RxCondition,告别if else和switch case

通常而言,Rx如果遇到if条件语句、switch case语句时需要先选择分支条件,然后再进行链式调用。RxCondition产生的目的就是为了在这些情况下也能顺利地使用链式调用。

我在查找RxJava的条件、布尔操作符时,没有找到符合我需求的操作符。于是,我在网上找到了RxJavaComputationExpressions, 做了一些修改将RxJava1升级到RxJava2,增加了对Flowable的支持。

下载安装

下载地址: https://github.com/fengzhizi715/RxCondition

使用方法:

1.ifThen用法

if条件语句传统的写法:

        Observable<String> observable = null;
        if (flag) {

            observable = Observable.create(new ObservableOnSubscribe<String>() {
                @Override
                public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                    e.onNext("this is true");
                }
            });
        } else {
            observable = Observable.create(new ObservableOnSubscribe<String>() {
                @Override
                public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                    e.onNext("this is false");
                }
            });
        }

        observable.subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                System.out.println("s="+s);
            }
        });

使用了ifThen()以后的写法:

        Statement.ifThen(new BooleanSupplier() {
            @Override
            public boolean getAsBoolean() throws Exception {
                return flag;
            }
        }, Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("this is true");
            }
        }),Observable.create(new ObservableOnSubscribe<String>() {
            @Override
            public void subscribe(@NonNull ObservableEmitter<String> e) throws Exception {
                e.onNext("this is false");
            }
        })).subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                System.out.println("s="+s);
            }
        });

ifThen(BooleanSupplier condition, Observable<? extends R> then,Observable<? extends R> orElse),其中第一个Observable是条件为true时执行的,第二个Observable则是条件为false时执行。

使用lambda表达式,进一步简化写法:

        Statement.ifThen(()->{
             return flag;
        },Observable.create((e)->{
             e.onNext("this is true");
        }),Observable.create((e)->{
             e.onNext("this is false");
        })).subscribe((Consume) (s) -> {System.out.println("s="+s)});

当然,ifThen也支持Flowable:

        Statement.ifThen(()->{
              return flag;
        },Flowable.just("this is true"), Flowable.just("this is false"))
        .subscribe((Consume) (s) -> {System.out.println("s="+s)});

2.switchCase用法

switch case语句传统的写法:

        Flowable<String> flowable = null;
        switch(type) {
            case 0:
                flowable = Flowable.just("this is 0");
                break;
            case 1:
                flowable = Flowable.just("this is 1");
                break;
            case 2:
                flowable = Flowable.just("this is 2");
                break;
            case 3:
                flowable = Flowable.just("this is 3");
                break;

            default:
                flowable = Flowable.just("this is default");
                break;
        }
        flowable.subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                System.out.println("s="+s);
            }
        });

使用了switchCase()以后的写法:

        Map<Integer,Flowable<String>> maps = new HashMap<>();
        maps.put(0,Flowable.just("this is 0"));
        maps.put(1,Flowable.just("this is 1"));
        maps.put(2,Flowable.just("this is 2"));
        maps.put(3,Flowable.just("this is 3"));
        
        Statement.switchCase(new Callable<Integer>() {

            @Override
            public Integer call() throws Exception {
                return type;
            }
        },maps,Flowable.just("this is default"))
        .subscribe(new Consumer<String>() {
            @Override
            public void accept(@NonNull String s) throws Exception {
                System.out.println("s="+s);
            }
        });

首先,将各个分支情况放入maps中。 其次,switchCase()的第一个参数是caseSelector,用于返回maps的key。最后一个参数是defaultCase,相当于switch case语句中的default语句。

改成lambda表达:

        Map<Integer,Flowable<String>> maps = new HashMap<>();
        maps.put(0,Flowable.just("this is 0"));
        maps.put(1,Flowable.just("this is 1"));
        maps.put(2,Flowable.just("this is 2"));
        maps.put(3,Flowable.just("this is 3"));
        
        Statement.switchCase((Callable)()-> {return type;},maps,Flowable.just("this is default"))
        .subscribe((Consumer)(s) -> {System.out.println("s="+s);});

switchCase()中,第一个参数返回的是Map<K, R>中的key,它支持范型,所以switchCase()相对于switch case语句而已能够支持更多种类型。

原理

以ifThen为例,看看它某个方法是怎么运行的。

    public static <R> Observable<R> ifThen(BooleanSupplier condition, Observable<? extends R> then,
                                           Observable<? extends R> orElse) {
        return RxJavaPlugins.onAssembly(new ObservableIfThen<R>(condition, then, orElse));
    }

ifThen静态方法借助RxJavaPlugins.onAssembly()来生成一个新的Observable并返回。

ObservableIfThen是一个Observable的实现类。它的subscribeActual()方法是被订阅时真正执行的方法,用来衔接Observable和Observer(Subscriber)。在这里,subscribeActual()根据condition返回的bool值来判断是使用then还是使用orElse来做Observable。

import io.reactivex.Observable;
import io.reactivex.ObservableSource;
import io.reactivex.Observer;
import io.reactivex.functions.BooleanSupplier;
import io.reactivex.internal.disposables.EmptyDisposable;

/**
 * Created by Tony Shen on 2017/5/9.
 */

final class ObservableIfThen<T> extends Observable<T> {

    final BooleanSupplier condition;

    final ObservableSource<? extends T> then;

    final ObservableSource<? extends T> orElse;

    ObservableIfThen(BooleanSupplier condition, ObservableSource<? extends T> then,
                     ObservableSource<? extends T> orElse) {
        this.condition = condition;
        this.then = then;
        this.orElse = orElse;
    }

    @Override
    protected void subscribeActual(Observer<? super T> observer) {
        boolean b;

        try {
            b = condition.getAsBoolean();
        } catch (Throwable ex) {
            EmptyDisposable.error(ex, observer);
            return;
        }

        if (b) {
            then.subscribe(observer);
        } else {
            orElse.subscribe(observer);
        }
    }
}

switchCase的原理也是大同小异,区别在于订阅时需要根据key从map中取到对应的Observable/Flowable,取不到则使用defaultCase。

总结

这个库其实很简单,编写它的同时我加深了对RxJava中Observable/Flowable原理的认识。

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏wannshan(javaer,RPC)

dubbo序列化过程源码分析

先看下dubbo在serialize层的类设计方案 序列化方案的入口,是接口Serialization的实现类。 /** * Serialization. ...

8629
来自专栏java 成神之路

凯撒加密算法(最简单的对称加密)

52010
来自专栏闵开慧

java概念2

1 文件操作 public class FileTest { public static void main(String[] args) throw...

4258
来自专栏Play & Scala 技术分享

Java生成十六进制的MD5加密字符串

4253
来自专栏友弟技术工作室

golang之Struct什么是结构体struct?

最近在复习golang,学习的东西,如果不使用,很快就会忘记。所以,准备复习完golang,做一个练手的小项目,加深对golang的学习。今天开始公司,进入封闭...

5846
来自专栏拭心的安卓进阶之路

RxJava 1.x 笔记:过滤型操作符

我真的是奇怪,上下班的路上看书、看文章学习的劲头特别大,到了周末有大把的学习时间,反而不珍惜,总想打游戏,睡前才踏踏实实地写了篇文章,真是服了自己! 本文内容...

3099
来自专栏张泽旭的专栏

古典密码加密解密之多表代换

多表代换密码首先将明文M 分为由n 个字母组成的分组, , … ,对每个分组的加密为 ≡ + ( ), = , , … 其中,(A,B)是密钥,A 是 ...

1734
来自专栏菩提树下的杨过

java:POI导出excel

POI是一个开源项目,专用于java平台上操作MS OFFICE,企业应用开发中可用它方便导出Excel. 下面是使用示例: 1、maven中先添加依赖项 1 ...

3085
来自专栏Python小屋

Python实现字符串与指定密钥循环异或加解密

异或运算在很多密码学算法中都有不同程度的应用,其运算特定在于一个数和另一个数连续异或两次仍得到原来的数。在实际使用中,因为要加密的信息和所使用的密钥在大多数情况...

3626
来自专栏数据结构与算法

codevs 1213 解的个数

1213 解的个数 时间限制: 1 s 空间限制: 128000 KB 题目等级 : 黄金 Gold 题目描述 Description 已知整数x...

3394

扫码关注云+社区

领取腾讯云代金券