频道栏目
首页 > 程序开发 > 移动开发 > Android > 正文
Android中基于RxJava的响应式编程
2017-07-17 11:13:15      个评论    来源:逆水行舟  
收藏   我要投稿

Android中基于RxJava的响应式编程,在你的Android应用中,每一个UI控件都在不停的产生事件。而你所写的代码也正是用来处理这些事件的,例如用户点击按钮或者一个从后端返回的一个REST响应。通常情况下,我们会通过对应的事件Listener来捕获并处理这些事件,例如OnClickListener。这个模式并没有问题,但是,当你尝试跟踪并处理多种状态的时候,就会显得不那么优雅了。注册页面以及表单中多个字段的校验就是一个很常见的场景。为了解决这个问题,Netflix开发了一个小巧的library——RxJava,而它对应在android的library叫作RxAndroid。这个library提供了函数式响应式编程的扩展,可以用来在android应用中处理复杂的异步事件处理。

函数式响应编程(Functional Reactive Programming)

函数式响应编程是由两种编程模式组合而成。简而言之,它们是:

函数式编程:一种通过map,filter和reduce等操作来转换或者组合一系列的事件流。而事件本身是不可变的。 响应式编程:这种编程模式主要用来简化数据流动和变换传播。

通俗的来说,函数式响应编程就是电子表格(Excel)应用。你可以设计一系列公式,当任意一个时刻,某一个单元格的数据改变的时候,结果也会相应的发生改变。公式本身并不发生改变,但是某一单元格发生的变动会立即传播到结果的单元格上去。

RxJava

在Java环境(包括Android)中,RxJava提供了函数式响应编程的框架。RxJava是基于微软的.NET的响应式框架Rx,并将其移植到了JVM中。

Observable(观察事件)和Observer(观察者)

RxJava使用了观察者模式。RxJava中,最基本的模块就是Observer。一个Observable会产生数据,而Subscriber(订阅者)会消耗这些数据。RxJava和通常的观察者模式不同的是:一个观察事件在被订阅之前,是不会开始任何工作的。

下面是RxJava中一个最基本的“Hello World”代码:

package com.ykode.belajar;

import rx.Observable;
import rx.Subscriber;
import rx.functions.Action1;

public class Hello {
  public static void main(String [] args) {
    Observable helloObservable = Observable.create( // .... [1]
      new Observable.OnSubscribe() {
        @Override
        public void call(Subscriber sub) {
          sub.onNext("Hello, World!");
          sub.onCompleted();
        };
    });

    helloObservable.subscribe( new Action1() {      // .... [2]
      @Override
      public void call(String s) {
        System.out.println("Subscriber : " + s);
      }
    });
  }
}

WTF! 一个hello world程序居然需要26行代码!但是,这段代码是使用Java7的风格写的,因此会很冗长。暂且先不考虑其冗余性。那么这段代码到底给做了什么?

helloObservable会产生”Hello World”数据。 helloObservable被订阅了。这个Subscriber实现了Action1。它会接受一个String参数并打印出来。

我们可以添加一个Subscriber,也同样打印接受到的信息。

    helloObservable.subscribe( new Action1 {
      @Override
      public void call(String s) {
        System.out.println("Sub1 : " + s);
      }
    });

    helloObservable.subscriber( new Action1 {
      @Override
      public void call(String s) {
        System.out.println("Sub2 : " + s);
      }
    });

这段代码会添加两个Subscriber并且都打印”Hello World!”。

Sub1 : Hello, World!
Sub2 : Hello, World!

如果把”Hello World!”改成”Bonjour Monde!”。那么所有的Subscriber都会打印修改后的信息。这就是构成响应式编程的一个特性:变换传播(change propagation)

转换(Transformation)

函数响应式编程提供了转换Observable的功能,例如map和filter。为了更清晰的说明这个功能,让我们修改Observabled部分,让它从Iterable中读取数据。

package com.ykode.belajar;

import rx.Observable;
import rx.Subscriber;
import rx.schedulers.Schedulers;
import rx.functions.Action1;

import java.util.Arrays;
import java.util.List;

public class Hello {

  // Getting current thread name
  public static String currentThreadName() {
    return Thread.currentThread().getName();
  }

  public static void main(String [] args) {

    List names = Arrays.asList("Didiet", "Doni", "Asep", "Reza", 
        "Sari", "Rendi", "Akbar");

    Observable helloObservable = Observable.from(names); // ... [1]

    helloObservable.subscribe( new Action1() {
      @Override
      public void call( String s ) {
        String greet = "Sub 1 on " + currentThreadName() + 
            ": Hello " + s + "!";
        System.out.println(greet);                               // ... [2]
      }
    });     
}

这个代码会把names中的每一条数据都打印一遍。

这个Observable是通过from方法来构造的。Subscriber会一条接一条的获取到Utterable中的数据。 Subscriber会把这些数据打印出来。

结果如下:

Sub 1 on main: Hello Didiet!
Sub 1 on main: Hello Doni!
Sub 1 on main: Hello Asep!
Sub 1 on main: Hello Reza!
Sub 1 on main: Hello Sari!
Sub 1 on main: Hello Rendi!
Sub 1 on main: Hello Akbar!

如果想把字符串都变成大写的,那么使用Observable的map方法。

import rx.functions.Func1;  // ..... [1]

// ... code redacted ...

    helloObservable.map( new Func1() {
      @Override
      public String call( String s ) {
        return s.toUpperCase();
      }
    }).subscribe( new Action1() {
      @Override
      public void call( String s ) {
        String greet = "Sub 1 on " + currentThreadName() + 
            ": Hello " + s + "!";
        System.out.println(greet);
      }
    });

Subscriber会打印大写的字符串:

Sub 1 on main: Hello DIDIET!
Sub 1 on main: Hello DONI!
Sub 1 on main: Hello ASEP!
Sub 1 on main: Hello REZA!
Sub 1 on main: Hello SARI!
Sub 1 on main: Hello RENDI!
Sub 1 on main: Hello AKBAR!

Lambda表达式

从上面的代码可以看到,转换和订阅的代码都十分冗余。你必须实现Action类(Action1Action2等),如果你想返回一个值,就必须实现Func类(Func1Func2等)。这些类都是范型,你必须制定参数和返回类型来构建它们。它们也都只提供一个方法。这种冗余的代码恶心的不少人,包括我在内。不过在Java 8中,我们可以使用lambda表达式。通过lambda表达式,我们的代码会精简很多:

    helloObservable.map( s -> s.toUpperCase() )
      .subscribe( s -> {
        String greet = "Sub 1 on " + currentThreadName() +
          ": Hello" + s + "!";
        System.out.println(greet);
      });

为了使代码可读性更强,我们可以通过map来构造字符串。

    helloObservable.map( s -> s.toUpperCase() )
      .map( s -> "Sub 1 on " + currentThreadName() + ": Hello " + s + "!")
      .subscribe( s -> System.out.println(s));

我们把greet变量缩短成了s。新的代码可读性甚至更强。

Android

重要更新这篇文章中的代码已经过时了,而且可能产生内存泄露。我已经新的博客中修改了泄露问题并且更新了编译脚本和依赖。

接下来用实际场景来介绍响应式编程在Android中的使用。假设有一个注册页面,包含两个注册信息。一个是邮箱,一个是用户名。这个注册页面包含如下行为:

两个注册信息的部分初始为空 如果注册信息符合标准格式,那么文本颜色为黑色
用户名必须包含4个以上的字符 邮箱必须满足规范的正则表达式 如果注册信息不符合标准格式,那么文本颜色为红色 只有当两个注册信息都合法的时候,注册按钮才会生效

如果你开发过Android程序,那么你可以想象到会需要实现很多匿名内部类来追踪文本的状态,和设置注册按钮的行为。

准备

使用Android Studio创建一个简单的程序。

创建程序

接着使用模版,新建一个Activity和一个Fragment,最低版本为Jelly Bean(API 16)。然后使用LinearLayout添加两个Edittext和一个注册Button。最终效果如下图所示。对应控件的id用红色文字标出。

效果图

添加RxAndroid和Retrolambda

想要在Android上使用RxJava,可以直接使用原生的RxJava。但是,RxAndroid提供了一个更加良好的封装。修改build.gradle并添加如下几个依赖:

dependencies {
  compile fileTree(dir: 'libs', include: ['*.jar'])
  compile 'com.android.support:appcompat-v7:21.0.3'
  compile 'io.reactivex:rxandroid:0.24.0'
}

这样一来,你就添加了RxAndroid的依赖病可以开始使用响应式编程的特性了。

那么lambda表达式呢?不幸的是,Android的SDK目前还不支持lambda表达式,因为它只兼容到Java 6,所以在编译成dex的时候会产生错误。如果想要保持兼容性的话,那么就必须使用传统的冗余方式来实现各种接口了。

RetroLambda可以用来将Java 8的代码转化为Java 6的代码,从而可以使用lambda表达式。需要提醒的是,想要更简洁的代码,就需要一定的风险。RetroLambda的实现方式比较投机,而且也无法保证在今后的Android SDK中可以继续适用。但是目前为止,直到SDK 5.0,它都没有出现问题。

在这里,让我们使用RetroLambda。只需要在build.gradle添加对应的依赖就可以了,不过这次是要在根目录的build.gradle添加,而不是模块的。

    dependencies {
        classpath 'com.android.tools.build:gradle:1.0.1'
        classpath 'me.tatarka:gradle-retrolambda:2.5.0'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }

接下来,我们在模块中使用对应的插件:

apply plugin: 'com.android.application'
apply plugin: 'me.tatarka.retrolambda'

如果你使用了Android Studio,那么它默认使用Java 7来编译,无法支持lambda表达式。为了避免这一点,在build.gradleandroid部分添加相关的设置

  compileOptions {
    sourceCompatibility JavaVersion.VERSION_1_8
    targetCompatibility JavaVersion.VERSION_1_8
  }

这会强制IDE使用Java 8去做语法高亮和解析。最后,我们需要在proguard-rules.pro中,添加相应防止混淆的规则。

-dontwarn java.lang.invoke.*

捕获事件

在之前的例子中,我们的观察事件是一个单一的值和一组存放在iterable中的值。在Android中,观察事件是一组响应事件。我们从edtUserName开始事件。我们希望捕获用户输入的字符并在ADB中打印出来。Android观察者的设置应该在onStart中完成。

@Override
protected void onStart() {
  super.onStart();

  Observable userNameText = 
    WidgetObservable.text((EditText) findViewById(R.id.edtUserName));

  userNameText.subscribe( e -> Log.d("[Rx]", e.text().toString()));
}

当我们启动app的时候,会得到如下输出:

监听

过滤事件

来做一点点修改。只有在输入的字符大于4的时候,我们才打印信息。这也是用户名合法的基本条件。

userNameText.filter( e -> e.text().length() > 4)
  .subscribe( e -> Log.d("[Rx]", e.text().toString()));

再次启动app就可以看到不同之处了:

过滤

到这里,我们就已经建立了一个非常简单的数据流。这也是响应式编程的一种独特的展现方式。为了让它更好理解,可以用下面这个图来表示:

流程

映射(Mapping)/转换(Transforming)事件

现在,我们来为每一个信息(邮箱和用户名)添加校验逻辑。和上面的逻辑类似,构造一个数据流来实现。在这里,使用map来实现代码。

校验管道

为了实现这个功能,我们为每一个EditText定义一个Observables。校验规则为:

用户名必须包含4个以上的字符 邮箱必须满足规范的正则表达式
    @Override
    protected void onStart() {
        super.onStart();

        final Pattern emailPattern = Pattern.compile(
                "^[_A-Za-z0-9-\\+]+(\\.[_A-Za-z0-9-]+)*@"
                + "[A-Za-z0-9-]+(\\.[A-Za-z0-9]+)*(\\.[A-Za-z]{2,})$"); // ..... [1]

        EditText unameEdit = (EditText) findViewById(R.id.edtUserName);
        EditText emailEdit = (EditText) findViewById(R.id.edtEmail);

        Observable userNameValid = WidgetObservable.text(unameEdit) //  [2]
                .map(e -> e.text())
                .map(t -> t.length() > 4);                                     

        Observable emailValid = WidgetObservable.text(emailEdit) 
                .map(e -> e.text())
                .map(t -> emailPattern.matcher(t).matches());

        emailValid.map(b -> b ? Color.BLACK : Color.RED)
                .subscribe( color -> emailEdit.setTextColor(color));     // ... [3]

        userNameValid.map( b -> b ? Color.BLACK : Color.RED)
                .subscribe( color -> userNameEdit.setTextColor(color));  


    }

代码的主要逻辑如下:

使用java.util.regex包来对邮箱作正则判断。 给用户名和邮箱添加Observable。 我们将校验的Observable映射到颜色的Observable,然后订阅它们来改变颜色。

结果如下:

校验

分裂和合并事件

最后,我们希望实现,当两个输入信息都合法的时候,注册按钮能够自动开启。为了实现这个效果,我们需要把两个Observable合并成一个。在这里,我们使用combineLatest方法。在OnStart中添加代码。

Button registerButton = (Button) findViewById(R.id.buttonRegister);

Observable registerEnabled = 
  Observable.combineLatest(userNameValid, emailValid, (a,b) -> a && b);
registerEnabled.subscribe( enabled -> registerButton.setEnabled(enabled));

combineLatest的参数是多个Observable以及一个Func2实例(或者lambda表达式),这个Func2实例用来定义怎么合并两个Observable。合并之后,会产生一个新的Observable。

合并

如效果所示,两个文本部分保持了原有的效果,并且它们的结果能够影响到注册按钮的开启或关闭。最终的流程图如下:

合并流程

从流程图可以看出,我们把原来的数据源分开成了两个,并且把它们合并成了一个新的数据源。这个新的数据源可以控制注册按钮的状态。如果你使用RxAndroid和lambda表达式的话,所有的逻辑只用20行代码就可以完成了。

优化

我们的应用已经实现了所有的功能了。但是,仍然有一个细节的点可能会造成不必要的性能开销。已有的几个Subscirber(用户名校验,邮箱校验和注册按钮设置)都从两个EditText接受数据,这就没次用户输入都会需要处理订阅事件。我们可以稍微修改一下代码来改进这一点。

emailValid.doOnNext( b -> Log.d("[Rx]", "Email " + (b ? "Valid" : "Invalid")))
  .map(b -> b ? Color.BLACK : Color.RED)
  .subscribe(color -> emailEdit.setTextColor(color));

userNameValid.doOnNext( b -> Log.d("[Rx]", "Uname " + (b ? "Valid" : "Invalid")))
  .map(b -> b ? Color.BLACK : Color.RED)
  .subscribe(color -> userNameEdit.setTextColor(color));

// and the registerenabled

registerEnabled.doOnNext( b -> Log.d("[Rx]", "Button " + (b ? "Enabled" : "Disabled")))
  .subscribe( enabled -> registerButton.setEnabled(enabled));

当我们运行app的时候,可以发现,每次用户输入了信息,都会打印出对应的日志。即使在信息的合法性并没有发生改变的情况下,也同样会打印出来。

效果

这不是理想的状态。正常情况下,只有当输入信息的合法性发生改变的时候,Subscriber才需要被调用。为了做到这一点,我们需要使用distinctUntilChanged方法。示例如下:

emailValid.distinctUntilChanged()
  .doOnNext( b -> Log.d("[Rx]", "Email " + (b ? "Valid" : "Invalid")))
  .map(b -> b ? Color.BLACK : Color.RED)
  .subscribe(color -> emailEdit.setTextColor(color));

userNameValid.distinctUntilChanged()
  .doOnNext( b -> Log.d("[Rx]", "Uname " + (b ? "Valid" : "Invalid")))
  .map(b -> b ? Color.BLACK : Color.RED)
  .subscribe(color -> userNameEdit.setTextColor(color));

// and registerEnabled

registerEnabled.distinctUntilChanged()
  .doOnNext( b -> Log.d("[Rx]", "Button " + (b ? "Enabled" : "Disabled")))
  .subscribe( enabled -> registerButton.setEnabled(enabled));

这种情况下,Subscriber只会在真正发生改变的情况下才会被调用。

优化效果

结论

函数式响应编程是目前的热点,它在处理并发事件的时候有很大的优势。RxJava和RxAndroid更是一个高效的工具,这篇文章只是简单的介绍了一下这两个工具的使用方式。希望你能够通过这篇文章获得一定的了解,它们的思维方式可能需要一定的时间才能够理解。但是一旦理解了,就可以发现它其实很简单。Observable是一系列的事件,我们通过各种各样的操作(map, transform, combine等)来定义它们的最终行为。

Rx最主要的目标是使你的代码更加简洁,方便测试,且可读性更强。lambda表达式可以让代码可读性更强。通过连接Observer,我们可以规划出整体的流程。我认为这比定义handler以及内部匿名类要简洁很多。

点击复制链接 与好友分享!回本站首页
上一篇:Android二维码扫描
下一篇:android面试题目
相关文章
图文推荐

关于我们 | 联系我们 | 广告服务 | 投资合作 | 版权申明 | 在线帮助 | 网站地图 | 作品发布 | Vip技术培训

版权所有: 红黑联盟--致力于做实用的IT技术学习网站