用Kotlin写响应式编程RxAndroid

用Kotlin写响应式编程RxAndroid

http://blog.csdn.net/u014134488/article/details/50888240

1.关于kotlin

先贴上官网的地址https://kotlinlang.org/ 
Kotlin是一门实用的编程语言，可用于JVM和Android程序开发，Kotlin结合了面向对象和函数式特性，致力于互操作性、安全、简洁和工具支持。 
Kotlin是一门通用的语言，只要能用Java的地方就能用Kotlin，包含：服务器程序开发、移动应用开发（Android）、桌面客户端程序开发。 Kotlin支持所有主要的开发工具以及服务，比如： 
* IntelliJ IDEA、Android Studio和Eclipse； 
* Maven、Gradle和Ant； 
* Spring Boot（Kotlin 支持今天正式发布！）； 
* GitHub，Slack，甚至Minecraft。 
* Kotlin的主要特点之一是Java+Kotlin混合工程的互操作性以及无缝兼容，使引入Kotlin的过程简单容易，并达成更少的重复性代码（boilerplate code）和更佳的类型安全（type-safety）。 
Kotlin还有一个扩展标准库（extensive standard library）能让日常工作变得简单顺畅，它能帮助保持低字节码足迹 (bytecode footprint)。当然，Kotlin 中自然可以使用 Java 库，反之亦然。 
还是多看看资料了解吧!

2.关于RxAndroid

还是自己去看吧，相信大神不少，不要为难菜逼了。 
都闪开，我要装逼了！ 
这里写图片描述

3.让Kotlin与Android结合一下

我用的开发IDE是AndroidStudio，要先在AndroidStudio里面安装kotlin的插件： 
这里写图片描述 
然后重启一下AS就好了 
接下来要在app的build.gradle里面加上这两个库： 
compile “org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version” 
compile ‘io.reactivex:rxandroid:0.24.0’ 
再sync一下gradle就好了

函数响应式编程基本特点

1、函数响应式编程 
2、异步 
3、事件驱动（事件作为可观察序列） 
4、基于观察者模式 
5、组合式 
6、专门出错处理 
7、适用于处理并发问题

基本概念

RxJava最核心的两个东西是Observables（被观察者，事件源）和Subscribers（观察者）。Observables发出一系列事件，Subscribers处理这些事件。这里的事件可以是任何你感兴趣的东西（触摸事件，web接口调用返回的数据。。。） 
一个Observable可以发出零个或者多个事件，知道结束或者出错。每发出一个事件，就会调用它的Subscriber的onNext方法，最后调用Subscriber.onCompleted()或者Subscriber.onError()结束。 
我们主要关心的是 onNext 函数来处理业务逻辑

基本使用实例

事件源发出一个字符串

  1. in java 
    Observable observable = Observable.create(new OnSubscribe<String>({ 
    @Override 
    public void call(Subscriber<? super String>subscriber) { 
    subscriber.onNext(“hello rx android”); 
    subscriber.onCompleted(); 
    } });

  2. in kotlin 
    Observable.create(object : Observable.OnSubscribe<String> { 
    override fun call(subscriber: Subscriber<in String>) { 
    subscriber.onNext(“hello rx android”) 
    subscriber.onCompleted() 
    } 
    })

    订阅着处理 onNext

    1. in java 
      Subscriber<String> subscriber = new Subscriber<String>() {

    @Override 
    public void onCompleted() { 
    Log.i(TAG, “onCompleted”); 
    }

    @Override 
    public void onError(Throwable e) { 
    //handler the error

    }

    @Override 
    public void onNext(String t) { 
    Log.i(TAG, t); 
    } 
    }; 
    2 in kotlin 
    var subscriber = object : Subscriber<String>() { 
    override fun onCompleted() { 
    Log.i(“android”, “onCompleted”) 
    } 
    override fun onError(e: Throwable) {//handler the error 
    } 
    override fun onNext(t: String) { 
    Log.i(“android”, t) 
    } 
    }

    注意一点：在kotlin中Throwable的源代码是public open class Throwable { 
    }这样的，是一个空实现，其中open修饰符与final的意义相反，它允许别的类继承，就像Effective java中说的：设计并显示标注继承，否则就禁止它。相应的允许继承重写的方法前也应该加上open

绑定事件和订阅者

1 in java 
observable.subscribe(subscriber); 
2 in kotlin 
ob.subscribe(subscriber) 
这里写图片描述

简单使用

1 in java 
Observable.just(“hello rx Android 2”).subscribe(new Action<String>() { 
@Override 
public void call(String t) { 
Log.i(TAG, t); 
} 
}); 
2 in Android 
Observable.just(“hello rx Android 2”).subscribe({ t -> 
Log.i(TAG, t); 
}); 
这里写图片描述

轻量化

Observable只发出的事件 
Subscribers只做事情是“响应”

操作符

操作符就是为了解决对Observable对象的变换的问题，操作符用于在Observable和最终的Subscriber之间修改Observable发出的事件

字符串拼接实例

1 in java 
Observable.just(“hello rx Android 3”) 
.map(new Func1<String, String>() { 
@Override 
public String call(String t) { 
return t + ” map 操作赋”; 
} 
}) 
.subscribe(new Action1<String>() { 
@Override 
public void call(String t) { 
Log.i(TAG, t); //hello rx Android 3 map 操作赋 
} 
}); 
2 in kotlin 
Observable.just(“hello rx Android 3”) 
.map({ t -> return@map t + ” map 操作赋”; }) 
.subscribe({ t -> Log.i(TAG, t); }); 
这里写图片描述

类型转换

1 in java 
Observable.just(“hello rx Android 4”) 
.map(new Func1<String, Integer>() { 
@Override 
public Integer call(String t) { 
return t.hashCode(); 
} 
}) 
.subscribe(new Action1() { 
@Override 
public void call(Integer t) { 
Log.i(TAG, t + ” = ” + “hello rx Android 4”.hashCode()); 
} 
}); 
2 in kotlin 
Observable.just(“hello rx Android 4”) 
.map { sg -> return@map sg.hashCode() } 
.subscribe({ 
i -> 
Log.i(TAG,i.toString()+ ” = ” + “hello rx Android 4”.hashCode()) 
}) 
这里写图片描述

from方法

Observable.from()方法，它接收一个集合作为输入，然后每次输出一个元素给subscriber 
1 in java 
Observable.from(new String[]{“hello rx Android 5”, “hello rx Android 6”}).subscribe(new Action1<String>() { 
@Override 
public void call(String t) { 
Log.i(TAG, t);//依次打印5， 6 
} 
}); 
2 in kotlin 
Observable.from(arrayOf(“hello rx Android 5”, “hello rx Android 6”)).subscribe({ 
t -> 
Log.i(TAG, t); 
}); 
这里写图片描述

flatMap

Observable.flatMap()接收一个Observable的输出作为输入，同时输出另外一个Observable 
1 in java 
List<String> list = new ArrayList<String>(); 
list.add(“hello rx Android 7”); 
list.add(“hello rx Android 8”); 
Observable.just(list) 
.flatMap(new Func1<List<String>, Observable<String>>() { 
@Override 
public Observable<String> call(List<String> t) { 
return Observable.from(t); 
} 
}) 
.subscribe(new Action1<String>() { 
@Override 
public void call(String t) { 
Log.d(TAG, t); // 依次打印7,8 
} 
}); 
2 in kotlin 
var list = ArrayList<String>() 
list.add(“hello rx Android 7”); 
list.add(“hello rx Android 8”); 
Observable.just(list) 
.flatMap({ 
t -> 
return@flatMap Observable.from(t); 
}) 
.subscribe({ 
t -> 
Log.i(TAG, t); // 依次打印7,8 
} 
); 
这里写图片描述

filter 过滤

filter()输出和输入相同的元素，并且会过滤掉那些不满足检查条件的。 
文／ben_speed（简书作者） 
原文链接：http://www.jianshu.com/p/51a8d2ff8697 
著作权归作者所有，转载请联系作者获得授权，并标注“简书作者”。 
1 in java 
.filter(new Func1<String, Boolean>() { 
@Override 
public Boolean call(String t) { 
return t != null; 
} 
}) 
2 in kotlin 
var sss = arrayOf(“one”, null, “three”, null) 
Observable.from(sss) 
.filter { t -> return@filter t != null } 
.subscribe({ t -> Log.i(TAG, t) }) 
这里写图片描述

take()

take()输出最多指定数量的

doOnNext()

doOnNext()允许我们在每次输出一个元素之前做一些额外的事情 
1 in java 
List<String> list = new ArrayList<String>(); 
list.add(“hello rx Android 7”); 
list.add(“hello rx Android 8”); 
list.add(null); 
Observable.just(list) 
.flatMap(new Func1<List<String>, Observable<String>>() {

    @Override
    public Observable&lt;String> call(List&lt;String> t) {
        return Observable.from(t);
    }

})
.filter(new Func1<String, Boolean>() {
    @Override
    public Boolean call(String t) {
        return t != null;
    }
})
.take(2)
.doOnNext(new Action1<String>() {

    @Override
    public void call(String t) {
        Log.e(TAG, t);
    }
})
.subscribe(new Action1<String>() {

    @Override
    public void call(String t) {
        Log.d(TAG, t);
    }
});

2 in kotlin 
var list = ArrayList<String?>(); 
list.add(“hello rx Android 7”); 
list.add(“hello rx Android 8”); 
list.add(null); 
Observable.just(list) 
.flatMap({ 
t -> 
return@flatMap Observable.from(t); 
}) 
.filter({ t -> 
return@filter t != null; 
}) 
.take(2) 
.doOnNext({ 
t -> 
Log.i(TAG, t); 
}) 
.subscribe({ 
t-> Log.i(TAG, t); 
}); 
这里写图片描述

总结

kotlin相对于java是简洁大量的代码量的，好了今天就到这里了

 

posted @ 2017-10-25 15:01  sky20080101  阅读(466)  评论(0)  编辑  收藏  举报