likuangren
likuangren

RxJava与RxKotlin项目实践

What is Rx?

基本概念

RxJava – Reactive Extensions for the JVM – a library for composing asynchronous and event-based programs using observable sequences for the Java VM.

按照官方介绍RxJava是一个在JVM平台上以Observable序列来处理异步和时间的代码库

Netflix发起

Why Rx?

现在Android社区都在广泛的推广和使用RxJava，但是为什么用它以及使用它能带来什么样的好处，我们通过一个具体的案例来研究

用户登录系统需求

假设现在我们有一个微信用户第三方登录功能的需求，这个需求呢很简单，就是实现一个登录界面，用户点击登录跳转到微信进行用户认证，拿到微信的openId然后再接入到自己后台服务器进行登录。这里我们设计一个AccountManager类，这个类里面有2个方法，首先是requestWxOpenId()方法用于跳转微信获得微信的openId,另外一个就是通过openId登录认证的login()

interface AccountManager {
    fun requestWxOpenId(): String

    fun login(wxOpenId: String): User
}

传统代码实现

因为AccountManager这些方法都是服务器访问的接口，是个异步任务，如果直接调用堵塞主线程肯定是不行的，所以我们会封装一个callback出来,回调方法用来处理当接口请求结束后的操作，因为接口请求有可能成功也有可能失败，所以回调接口中包含了两个方法onSuccess和onFaillure

interface OpenIdCallback {
    fun onSuccess(openId: String)
    fun onFailure()
}

interface AccountCallback {
    fun onSuccess(resultl: String)

    fun onFailure()
}

interface AccountManager {
    fun requestWxOpenId(callback: OpenIdCallback): String

    fun login(wxOpenId: String, callback: AccountCallback)
}

AccountManager的实现很简单首先调用requestWxOpenId方法获取到openId后再调用login方法获取用户信息，调用代码如下所示

 private fun clickLogin() {
        val accountManager = AccountManagerIml()
        accountManager.requestWxOpenId(object : OpenIdCallback {
            override fun onSuccess(openId: String) {
                accountManager.login(openId, object : AccountCallback {
                    override fun onSuccess(user: User) {
                        if (!isActivityDestroyed) {
                            runOnUiThread {
                                //update UI
                            }
                        }
                    }

                    override fun onFailure() {
                        //handle error
                    }

                })
            }

            override fun onFailure() {
                //handle error
            }
        })
    }

可以看到整套流程下来，有几个痛点，一个是每一个异步请求我们都需要生命一个callback借口，另外一个是callback嵌套使得代码不清晰，如果再嵌套多几层会使得代码很难看，这就是有名的回调地狱（callback hell），再就是像在Android应用开发中需要在主线程操作UI和相关组件生命周期的判断,这就需要在各个回调中加上各种判断。为了解决这些问题Rx应运而生

使用RX的实现

为了解决上述提到哪些问题，我们看看Rx怎么解决的，首先为了解决不同的callback问题，Rx定义了统一的回调接口Observer

public interface Observer {
    void onCompleted();

    void onError(Throwable e);

    void onNext(T t);
}

通过泛型包装来统一回调接口，Observer回调中封装了三个方法onErro用来处理错误情况，onNext用来处理正常情况下返回结果的回调，onComplete表示整个流程结束的回调。

通过统一泛型回调接口解决了声明多个回调的问题，那么如何解决回调嵌套的问题呢,因为回调嵌套产生的原因是由于数据的链式处理，如果把数据处理都能直接反映链式处理上，最终结果返回给最终的observer就行了，这个Rx使用Observable和对应的操作符来处理链式数据处理

Observable表示一个数据源，在AccountManager的方法中，我们对应的接口就需要修改

interface AccountManager {
    fun requestWxOpenId(): Observable<String>

    fun login(wxOpenId: String):Observable
}

我们调用代码就只需要一个subscriber就行了

    private fun clickLogin(){
        val accountManager = AccountManagerIml2()
        accountManager.requestWxOpenId()
                .flatMap { accountManager.login(it) }
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(object: Subscriber() {
                    override fun onNext(t: User?) {
                        //update ui
                    }

                    override fun onCompleted() {
                    }

                    override fun onError(e: Throwable?) {
                    }
                })
    }

看到上面的代码是不是变得清晰了，如果使用RxKotlin，会更加清晰

    private fun clickLogin() {
        val accountManager = AccountManagerIml2()
        accountManager.requestWxOpenId()
                .flatMap { accountManager.login(it) }
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribeBy(
                        onError = {},
                        onNext = {
                            //update ui 
                        })
    }

可以看到，使用RxJava来封装这些异步操作后，整个代码跟同步操作的代码都非常接近，结构很清晰和明了

What Rx inside is？

要想更好的使用RxJava，就有必要更好更深入的了解RxJava的api，这一部分将深入了解RxJava和RxKotlin的api和部分实现原理

RxJava1 Api探究

事件源

Observable

Observable是最为常用的数据源，Observable对象提供了常用的创建方法,create,just,from等方法

Observable.just("hello")

Observable.from(arrayOf(1, 2, 3, 4, 5))

Observable.create(Observable.OnSubscribe { t ->
        try {
            t.onNext("hello")
            t.onStart()
        } catch (e: Exception) {
            t.onError(e)
        }
    })

Completable

Completable数据源只会触发onComplete和onError回调，通过from()方法可以创建Completable数据源

Completable.fromAction { println("action done") }

Single

Single数据源只会发射一条数据，Single类也有create，just，from等方法用来床架Single数据源对象，subscribe方法只有onSuccess和onError，比方说如下代码

    Single.just(1)
            .subscribeBy(
                    onSuccess ={ println(it) },
                    onError = {}
            )

操作符

操作符可以说是是RxJava中的核心了，通过不同的操作符来实现数据的拼接，转换等等操作从而达到最终的数据结果，RxJava提过了很多的操作符，这里就不一一讲解，主要列出一些常用的

map

用于数据转换，常见的应用场景比方说id应设成名称


Observable.just(1, 2, 3, 4)
.map {
when (it) {
1 -> "Jane"
2 -> "Mike"
3 -> "Mary"
4 -> "tom"
else -> "noName"
}
}
.subscribeBy(onNext = { println(it) })

输出内容为

Jane
Mike
Mary
tom

flatMap

flatMap操作类似于Map，但是Map转换是T -> D，但是flatMap是T -> Observable\

fun getInfoById(id: Int): Observable {
    //模拟耗时请求
    return Observable.just(id)
}

Observable.just(1, 2, 3, 4)
            .flatMap { getInfoById(it) }
            .subscribeBy(onNext = { println(it)})

这里getInfoById我们假设是一个网络请求或者数据库操作之类的耗时操作，它返回Observable对象，最后subscriber中onNext中接受到的还是Int数据

输出结果

1
2
3
4

filter

filter用于过滤数据

Observable.just(1,2,3,4)
            .filter {  it > 2 }
            .subscribeBy(onNext = { println(it)})

输出结果

3
4

….

RxJava中操作符可以说是非常非常多，想了解更多可以查看官方文档Rx操作符

线程调度

线程调度在RxJava可以说是非常精简，简单到一两行代码来实现线程切换

    Observable.just(1,2,3,4)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeBy(onNext = { println(it)})

上面代码中通过切换android ui线程和io线程是的回调方法都运行在ui线程，Observable数据源操作在io线程中运行

Transformer

我们在使用RxJava的过程中，通常都会用到线程切换，耗时操作在io线程，subscriber回调在主线程

    Observable.just(1,2,3,4)
            .subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
            .subscribeBy(onNext = { println(it)})

对于多个地方都总是要重复调用subscirbeOn和observeOn这两个方法，我们会想到去封装一下，比方说增加一个方法

fun schedule(observable: Observable): Observable {
    return observable.subscribeOn(Schedulers.io())
            .observeOn(AndroidSchedulers.mainThread())
}

这样我们就可以这样调用

schedule(observable)
            .subscribeBy(onNext = { println(it)})

这样做虽然加了一层封装，但是打破了整个Observable的链式调用，这就显得不太好看

好在RxJava有Transformer，通过与Observable的compose()操作符使用来组合Observable操作

Transformer就是一个Func1

fun  applySchedulers(): Observable.Transformer {
    return Observable.Transformer { observable ->
        observable.subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
    }
}

我们创建一个applySchedulers方法返回一个Transformer对象，这时候我们就可以直接链式切换线程了

observable.compose(applySchedulers())
            .subscribeBy(onNext = { println(it)})

Subject

Subject是一个很特殊的接口，它即实现了Observable接口又实现了Observer接口，也就是说它既是一个数据发射方又是一个数据接收方

AsyncSubject

AsyncSubject注册到的Observer只会在onComplete回调之后接收到最后一个onNext发射出来的数据

  // observer不会接收到数据，因为subject没有调用onComplete
  AsyncSubject subject = AsyncSubject.create();
  subject.subscribe(observer);
  subject.onNext("one");
  subject.onNext("two");
  subject.onNext("three");

  // observer只会接收到最后一个数据，也就是“three”
  AsyncSubject subject = AsyncSubject.create();
  subject.subscribe(observer);
  subject.onNext("one");
  subject.onNext("two");
  subject.onNext("three");
  subject.onCompleted();

BehaviorSubject


注册到BehaviorSubject的observer只会接收到subscribe之前发射的最后一个item和之后发射的所有item


  // observer会接收到所有4个事件(包括"default").
  BehaviorSubject subject = BehaviorSubject.create("default");
  subject.subscribe(observer);
  subject.onNext("one");
  subject.onNext("two");
  subject.onNext("three");

  // observer will receive the "one", "two" and "three" events, but not "default" and "zero"
  BehaviorSubject subject = BehaviorSubject.create("default");
  subject.onNext("zero");
  subject.onNext("one");
  subject.subscribe(observer);
  subject.onNext("two");
  subject.onNext("three");

  // observer will receive only onCompleted
  BehaviorSubject subject = BehaviorSubject.create("default");
  subject.onNext("zero");
  subject.onNext("one");
  subject.onCompleted();
  subject.subscribe(observer);

  // observer will receive only onError
  BehaviorSubject subject = BehaviorSubject.create("default");
  subject.onNext("zero");
  subject.onNext("one");
  subject.onError(new RuntimeException("error"));
  subject.subscribe(observer);

PublishSubject


observer会接收到subscribe后所有发射出来的item


  PublishSubject subject = PublishSubject.create();
  // observer1 will receive all onNext and onCompleted events
  subject.subscribe(observer1);
  subject.onNext("one");
  subject.onNext("two");
  // observer2 will only receive "three" and onCompleted
  subject.subscribe(observer2);
  subject.onNext("three");
  subject.onCompleted();

TestSubject


TestSubject是专门为单元测试开发而来的


@Test
public void cancelShouldUnsubscribe() {
    TestSubject observable = TestSubject.create(new TestScheduler());
    assertFalse(observable.hasObservers());

    T future = toFuture(observable);
    assertTrue(observable.hasObservers());

    future.cancel(true);

    assertFalse(observable.hasObservers());
}


RxJava2


Reactive Streams


Reactive Streams是一套在JVM上建立的响应式标准协议，旨在标准化以无阻塞式back pressre的形式来处理异步事件流协议，类似于网络的标准http协议一样，只是Reactive Streams是在JVM和JavaScript平台上的响应式协议


规范概览


    

  • Publisher
     
    public interface Publisher {
    public void subscribe(Subscriber s);
}
     
    Publisher接口用来定义发射事件对象，通过subscribe方法接收想要接收事件的subscriber
    • 

  • Subscriber
    • 



public interface Subscriber {
    public void onSubscribe(Subscription s);
    public void onNext(T t);
    public void onError(Throwable t);
    public void onComplete();
}


    

  • Subscription
    • 



public interface Subscription {
    public void request(long n);
    public void cancel();
}


    

  • Processor
    • 



public interface Processor<T, R> extends Subscriber<T>, Publisher<R> {
}


Java9 Flow


Reactive Streams定义了规范，JDK也实现了这个规范，在最新的Java9中引入了一个java.util.concurrent.Flow模块，这就意味着如果你使用Java9,可以直接引用Flow模块来应用响应式api，而不必须引入第三方的RxJava包


api变动


数据源


    

  • Observable和Flowable两种数据源，Observable是没有back pressure支持的，Flowable是需要设置back pressure选项的，也就是说对于事件发射方是否会产生back pressure问题需要使用者来决定，使用Flowable就必须要指定back pressure模式，不指定会直接报错
    • 

  • Single数据源的subscriber在RxJava2中改为SingleObserver,增加了onSubscribe方法
    • 



interface SingleObserver {
    void onSubscribe(Disposable d);
    void onSuccess(T value);
    void onError(Throwable error);
}


    

  • Completable的Subscriber在RxJava2中改为CompletableObserver
    • 



interface CompletableObserver<T> {
    void onSubscribe(Disposable d);
    void onComplete();
    void onError(Throwable error);
}


    

  • Maybe: Maybe是在RxJava2中新加的一种数据类型，他是Single和Completable的结合体Maybe可能会发射0或者1个事件或者error
    • 



Subject和Processor


在RxJava1中的Subject，在RxJava2中新增了Processor，Processor与Subject类似，Processor支持back pressure而Subject不支持back pressure


Subscriber和Subscription


Subscriber增加了一个onSubscribe(Subscription)的回调方法，因为原有的Observable在subscribe一个Subscriber的时候会返回Subscription，但是在RxJava2中subscribe方法返回的是void，所以对应在Subscriber中增加了Subscription的回调方法


其他


    

  • RxJava2中不再接收直接发射null，例如Observable.just(null)如果发射的对象是null,在RxJava2中会直接报错或者将error传到onError中
    • 

  • Schedules将immediate改为trampoline
    • 

  • 增加了test的操作符
    • 



RxJava2还有许多变更，这里未能一一讲述，更详细文档请参考官方What’s-different-in-2.0


RxKotlin


RxKotlin是基于RxJava轻量级框架，在基于Kotlin的项目中，本身可以直接使用RxJava，但是RxKotlin通过增加各类扩展函数和规范使得RxJava在Kotlin项目中更易使用和标准化


import io.reactivex.rxkotlin.subscribeBy
import io.reactivex.rxkotlin.toObservable

fun main(args: Array) {

    val list = listOf("Alpha", "Beta", "Gamma", "Delta", "Epsilon")

    list.toObservable() // extension function for Iterables
            .filter { it.length >= 5 }
            .subscribeBy(  // named arguments for lambda Subscribers
                    onNext = { println(it) },
                    onError =  { it.printStackTrace() },
                    onComplete = { println("Done!") }
            )

}


completable扩展


fun Action0.toCompletable(): Completable = Completable.fromAction(this)
fun  Callable.toCompletable(): Completable = Completable.fromCallable { this.call() }
fun  Future.toCompletable(): Completable = Completable.fromFuture(this)
fun (() -> Any).toCompletable(): Completable = Completable.fromCallable(this)


completable扩展主要是为各种对象增加toCompletable()的转换方法


observables扩展


observabled扩展方法主要是对各个对象增加toObservable对象，包括各个Array对象，iterator对象，Sequence对象等


operators扩展


fun <T> ObservableT>>.mergeAll() = flatMap { it }

fun <T> ObservableT>>.concatAll() = concatMap { it }

fun <T> ObservableT>>.switchLatest() = switchMap { it }

fun <T> ObservableT>>.switchOnNext(): Observable<T> = Observable.switchOnNext(this)


操作符主要增加了对Observable


single扩展


fun <T> T.toSingle(): Single<T> = Single.just(this)
fun <T> Future<T>.toSingle(): Single<T> = Single.from(this)
fun <T> Callable<T>.toSingle(): Single<T> = Single.fromCallable { this.call() }


single扩展增加了Future，Callable和T的toSingle方法


subscribers扩展


subscribers增加了subscribeBy及其相应的重构方法,使用方法可参考如下代码


list.toObservable() // extension function for Iterables
            .filter { it.length >= 5 }
            .subscribeBy(  // named arguments for lambda Subscribers
                    onNext = { println(it) },
                    onError =  { it.printStackTrace() },
                    onComplete = { println("Done!") }
            )


subscription扩展


subscription增加了两个扩展方法


operator fun CompositeSubscription.plusAssign(subscription: Subscription) = add(subscription)

fun Subscription.addTo(compositeSubscription: CompositeSubscription) : Subscription {
    compositeSubscription.add(this)
    return this
}


一个是kotlin符号重载,可以直接使用+=将subscription添加到CompositeSubscription中


subscription += observable.subscribe{}


另外一个是在Subscription中增加了addTo方法


list.toObservable()
            .subscribeBy(  // named arguments for lambda Subscribers
                    onNext = { println(it) },
                    onError =  { it.printStackTrace() },
                    onComplete = { println("Done!") }
            )
            .addTo(compositeSubscription)


How to apply Rx?


Android Project Architecture




上图是Google IO 2017上新提出的Android Architecture,旨在帮助开发者如何更快更稳定的基于此架构开发应用


从上面的架构图中，我们可以看到数据源的处理统一是通过Repository来封装，不管是数据库的数据还是服务器接口的数据，通过通过Repository封装再以LiveData的形式提供，注意这里的LiveData其实可以理解为RxJava的Observable。所以对于Android项目结构中数据源的封装，建议都采用Repository的形式，如果采用Android Architecture那可以采用LiveData，如果采用RxJava就以Observable来组合Repository


Rx应用


Retrofit


Retrofit是一个基于RestFul Api的Java框架，我们可以直接使用Observable返回


public interface GitHubService {
  @GET("users/{user}/repos")
  Observable> listRepos(@Path("user") String user);
}


定义接口请求后，我们就可以通过Retrofit获取service实例做请求


Retrofit retrofit = new Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build();

GitHubService service = retrofit.create(GitHubService.class);

service.listRepost("test")
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribeBy(onNext={})


Retrofit具体介绍可查看其项目https://github.com/square/retrofit 这里就不一一介绍了


RxBinding


RxBinding是一个将Android UI控件事件转换为Rx事件的Java库


Button button = ...;
RxView.clickEvents(button) 
    .subscribe(new Action1() {
        @Override
        public void call(ViewClickEvent event) {
            // Click handling
        }
    });


上面的代码中就是通过RxBinding将按钮的点击事件转换为Observable发射，这么做就可以通过一些操作符来显示快速点击或屏蔽指定的点击动作等等


RxLifecycle


RxLifecycle是一个管理Android Activity或Fragment组件周期的应用库


myObservable
    .compose(RxLifecycle.bind(lifecycle))
    .subscribe();


通过RxLifecycle的绑定到指定生命周期来处理比方说在Activity 
 destroy的时候unsubscribe，在Activity onCreate的时候进行绑定


RxBus


RxBus是一个通过RxJava来实现时间总线的开源库，使用方式与大多是EventBus库类似，只是内部是通过RxJava来处理事件，这里就不做篇幅讲解了，有兴趣的同学可以参考https://github.com/AndroidKnife/RxBus


注意事项


    

  • 在使用RxJava的时候，有时候会遇到小伙伴如下代码
    • 



fun getUser(uId: String, subscriber: Subscriber<User>)


在调用是传入Subscriber，这种方式还是传统的callback形式，这种方式完全背弃了Rx的初衷,这样修正会更贴切


fun getUser(uId: String):Observable


    

  • 在使用RxJava的时候忽视back pressure问题，可能会产生莫名的问题，需要注意实际事件发射场景是否会产生back pressure然后采用正确的操作符或者Flowable源来处理
    • 



总结


至此，整个RxJava的学习过程结束了，本篇文章站在RxJava应用的角度去分析，没有太过深入源码解析，这也不是本篇文章的目的，后续可能会再出一些源码解析类的文章，再就是随着Kotlin coroutine(协程)出现，对于异步任务的影响有哪些也是可以探索的地方。最后送大家一张图



























你可能感兴趣的:(RxJava)






    

  • RxJava学习笔记
ztzt123

    之前有过一次学习笔记，发现长时间不经常用Rx的一些操作已经忘得差不多了，经常的复习是多么的重要啊，这次会在上一次不足的部分补充一下。上一次的学习笔记：http://wiki.sankuai.com/pages/viewpage.action?pageId=405485429Rx操作符补充flatMap使用flatMap时将原本发送的数据进行转换，再返回转换后数据的Observable，flatMa
    

    • 

  • Rxjava Transtorming Observables
shiyuzhe

    OperatorsthattransformitemsthatareemittedbyanObservable.Buffer—periodicallygatheritemsfromanObservableintobundlesandemitthesebundlesratherthanemittingtheitemsoneatatimeFlatMap—transformtheitemsemitted
    

    • 

  • LiveData 迁移到 Kotlin Flow详解

kotlin

    LiveData，是Android2017推出的一个东西，配合MVVM使用。观察者模式，的确简化了我们的工作方式，但RxJava等选项，对于当时的初学者来说实在是太复杂了。因此ArchitectureComponents团队创建了LiveData：这是个非常“有主见的”可观察数据持有者类，并且是专门为Android设计的。它保持简单明了，这让它易于上手，建议是将RxJava用于更复杂的响应流案例，
    

    • 

  • retrofit+rxjava+okhttp网络框架之二次封装
nade_s

    retrofit+rxjava的是这几年很流行的一种网络框架，开发者也提供了丰富的方法。之所以进行二次封装，就是因为retrofit+rxjava的链式调用太方便了，不符合单一性原则，管理起来比较麻烦。主要目的是二次封装后，和项目有很高的契合度更高。说一下封装思路，由于其本身调用方便，具体方法就不做封装了。第一retrofit对象封装。第二封装okhttp拦截器，用于添加头参数，拦截错误日志。第三
    

    • 

  • RxJava常用的操作符
emmmmsuperdan
rxjavaandroidjava

    ZipZip:把两个流返回结果一起调用；Zip(a,b,newFunction(b的类型，结合结果的返回类型));
    

    • 

  • Android混淆-基本混淆模板+自定义混淆类NotProguard
MonkeyLei

    proguard-rules.pro-第三方就增加了一个glide+rxjava+retrofit，别的按需添加即可#AddprojectspecificProGuardruleshere.#Youcancontrolthesetofappliedconfigurationfilesusingthe#proguardFilessettinginbuild.gradle.##Formoredetai
    

    • 

  • RxJava-使用详解与背压原理2
Laughing_G

    一、RxJava1与RxJava2的区别前提：RxJava是响应式编程，基于事件流开发。区别：1.RxJava2不再支持null值，如果传入一个null会抛出NullPointerException；2.Observable.just(null)不支持；3.RxJava2所有的函数接口（Function、Action、Consumer）均设计为可抛出Exception，同时支持自己去解决编译异常需
    

    • 

  • MVP步骤
I_Am_Legend

    T-MVP步骤：1.添加依赖implementation'com.squareup.okhttp3:okhttp:3.8.1'implementation'com.squareup.okhttp3:logging-interceptor:3.4.1'implementation'io.reactivex:rxjava:1.1.6'//Retrofit的rx解析库implementation'com
    

    • 

  • 手把手带你入门神秘的RxJava
可以写但没有必要

    近两年来国内的技术圈子中越来越多的开始提及RxJava，越来越多的应用和面试中都会有RxJava，而就目前的情况，Android的网络库基本被Retrofit+OkHttp一统天下了，而配合上响应式编程RxJava可谓如鱼得水。什么是RxJava•Rx是ReactiveExtensions的简写，翻译为响应的扩展。也就是通过由一方发出信息，另一方响应信息并作出处理的核心框架代码。•该框架由微软的架
    

    • 

  • Hystrix系列之执行原理分析
美团Java

    上文中介绍了Hystrix的由来，本文会深入分析Hystrix的执行过程。Hystrix的大部分逻辑基于RxJava，其实现让很热多人望而却步，停留在了仅仅使用的地步，从一个简单的HelloWorld开始。publicclassCommandHelloWorldextendsHystrixCommand{privatefinalStringname;publicCommandHelloWorld(
    

    • 

  • RxJava之concatMap系列转换操作符源码介绍
103style

    转载请以链接形式标明出处：本文出自:103style的博客转换相关的操作符以及官方介绍RxJava之concatMap系列转换操作符官方介绍：TransformingObservablesconcatMapconcatMapCompletableconcatMapCompletableDelayErrorconcatMapDelayErrorconcatMapEagerconcatMapEager
    

    • 

  • Coroutines和Rxjava异步编程对比之二
小菜鸟程序媛

    原文地址：https://medium.com/@manuelvicnt/coroutines-and-rxjava-an-asynchronicity-comparison-part-2-cancelling-execution-199485cdf068在Android开发中，取消RxJava或Coroutines的执行时很重要的，因为在View即将被销毁的时候，取消网络请求或者对象的创建是必须
    

    • 

  • Rxjava2019-03-26
NullPointe_8e82

    每隔一秒执行list集合中的一条数据//ObservablelistObservable=Observable.fromIterable(Catetorys);////interval定时器，间隔1秒发射一次//ObservabletimerObservable=Observable.interval(1000,TimeUnit.MILLISECONDS);////使用zip操作符合并两个Obse
    

    • 

  • 【Android】RxJava系列01-基本概述和基本用法
Rose J
RxJavaandroidrxjava

    少年啊，要永远相信美好的事情即将发生【Android】RxJava系列01-基本概述和基本用法1.RxJava的概述2.RxJava的作用3.观察者和被观察者4.背压5.RxJava的基本用法步骤一，创建Observer（观察者）步骤二，创建Observable（被观察者）步骤三，Subscribe（订阅）1.RxJava的概述RxJava是什么？是ReactiveX的一种Java实现。那，Rea
    

    • 

  • RxSwift的使用详解
adaodao3056

    RxSwift的使用详解一.RxSwift简介推荐:RxSwift官方文档中文:RxSwift官方文档的中文翻译RxSwift是Swift函数响应式编程的一个开源库，由Github的ReactiveX组织开发、维护其他语言像C#,Java和JS也有，Rx.Net、RxJava、rxjsRxSwift的目的是让数据/事件流和异步任务能够更方便的序列化处理，能够使用Swift进行响应式编程1.RxSw
    

    • 

  • Retrofit2
穷极_d8f1

    Retrofit2的好处超级解耦解耦？解什么耦？我们在请求接口数据的时候，API接口定义和API接口使用总是相互影响，什么传参、回调等，耦合在一块。有时候我们会考虑一下怎么封装我们的代码让这两个东西不那么耦合，这个就是Retrofit的解耦目标，也是它的最大的特点。可以配置不同HttpClient来实现网络请求，如OkHttp、HttpClient...支持同步、异步和RxJava可以配置不同的反
    

    • 

  • Android应用开发进阶，flutter页面跳转防止页面重复刷新
m0_64604842
程序员面试android移动开发

    第三章通过Google官方的架构示例项目To-Do，详细介绍了Android的应用架构，包括MVP，MVP-Clean，MVP-Dagger，MVP-RxJava，MVVM-DataBinding，MVVM-Live。第四章介绍了实战项目AndroidPlus，AndroidPlus是一个专注于Andriod领域的知识问答与分享平台，遵循MaterialDesign，使用了MVP-Dagger架构
    

    • 

  • LiveData 迁移到 Kotlin Flow详解
xiangzhihong8
深入Android应用开发kotlin开发语言android

    LiveData，是Android2017推出的一个东西，配合MVVM使用。观察者模式，的确简化了我们的工作方式，但RxJava等选项，对于当时的初学者来说实在是太复杂了。因此ArchitectureComponents团队创建了LiveData：这是个非常“有主见的”可观察数据持有者类，并且是专门为Android设计的。它保持简单明了，这让它易于上手，建议是将RxJava用于更复杂的响应流案例，
    

    • 

  • Android Kotlin 基于RxJava的简单封装
水天滑稽天照八野滑稽石

    前言使用RxJava无非就是为了开异步任务，所以这儿简单按照个人使用习惯封装了下使用方法单个任务的异步valtask=Task.singleTask{//需要异步进行的任务}.success{//成功回调（这里是UI线程了）}.error{//失败回调（这里是UI线程了）}.interrupted{//被打断回调（这里是UI线程了）}.start()task.cancel()带有进度条的异步val
    

    • 

  • 关于 RxJava2CallAdapterFactory
Gubr

    今天在看谷歌最新的框架的时候发现有一段有些疑问的代码publicLiveData>loadUser(Stringlogin){returnnewNetworkBoundResource(appExecutors){//...@NonNull@OverrideprotectedLiveData>createCall(){//这里直接返回并没有像我们常写的那样需要拼接以下代码//subscribeOn
    

    • 

  • Rxjava3文档级教程链接
logan.gan
android

    许进进的博客地址：https://blog.csdn.net/LucasXu01Rxjava3文档级教程一：介绍和基本使用https://blog.csdn.net/LucasXu01/article/details/105279367Rxjava3文档级教程二：操作符全解https://blog.csdn.net/LucasXu01/article/details/105312731Rxjava
    

    • 

  • 半天学会RxJava的简单使用
reaiya

    参考文章：https://www.jianshu.com/p/031745744bfa1.准备安装依赖compile'io.reactivex.rxjava2:rxjava:2.0.2'compile'io.reactivex.rxjava2:rxandroid:2.0.2'2.使用创建一个按钮点击被观察者，且规定发射出来的sourse的类型为StringObservable.create(new
    

    • 

  • RxJava操作符---zip
风少侠

    简介zip操作符用于将多个数据源合并，并生成一个新的数据源。新生成的数据源严格按照合并前的数据源的数据发射顺序，并且新数据源的数据个数等于合并前发射数据个数最少的那个数据源的数据个数。zip（图片来源于官方文档）.png举个例子测试场景@Testfunzip(){valobservable_1=Observable.fromIterable(listOf(1,2))valobservable_2=
    

    • 

  • 【Kotlin学习】协程的基本概念(3)——Flow
Panic Lin
Kotlin学习android学习kotlin

    kotlinflow介绍它是kotlin协程与响应式编程模型结合的产物flow的使用flow的基本使用方式flow能够返回多个异步计算的值如果熟悉RxJava，可以吧collect()对应subscribe()，而emit()对应onNext()另外的创建flow方式1.flowOf()2.asFlow()3.channelFlow()channelFlowbuilder跟flowbuilder是
    

    • 

  • android--RXJava+Retrofit封装使用
袁震
android三方框架androidrxjavaretrofit网络框架

    在欲望的城市里，你就是我最后的信仰。目录前言一，方法封装二，okhttp+retrofit+rxjava实现网络请求前言关于RXJava的基本使用，请参考文章android--RXJava详细使用篇-CSDN博客下面我们讲一下RXJava在android中的相对比较高级的用法一，方法封装在上篇文章中，我们有个加载图片的案例：Observable.just(IMGPATH)//发送图片地址.map(
    

    • 

  • android--RXJava详细使用篇
袁震
android三方框架androidrxjava

    人性的背后是白云苍狗，愿我们都能做生活的高手目录一，定义二，RXJava的优势三，使用3.1添加依赖3.2事件产生3.2.1由Observable通过create操作符来创建3.2.2通过from发送事件3.2.3通过just发送事件3.3事件消费3.4Scheduler线程控制3.5map操作符3.6flatMap操作符3.7debounce和throttleFirst事件防抖3.8timer操
    

    • 

  • RxJava基础2
我要离开浪浪山

    Javadoc:scan(Func2)scanSeed有一个scan操作符的变体，你可以传递一个种子值给累加器函数的第一次调用（Observable发射的第一项数据）。如果你使用这个版本，scan将发射种子值作为自己的第一项数据。注意：传递null作为种子值与不传递是不同的，null种子值是合法的。Javadoc:scan(R,Func2)这个操作符默认不在任何特定的调度器上执行。Window定期
    

    • 

  • 从Java 8 stream 到 rxjava, 记录一次数据流的处理任务
黄大海

    在java8之前,一直都是用guava中的Iterables和FluentIterables来处理数据流。java8的lambda和方法引用极大的简化了内部类的处理。不过stream还是比较初级的，实际使用过程中只能处理简单的数据流任务。主要遇到的问题是，在调用消费方法（例如forEach,collect）之后。该流即为终结状态，无法再复用。无法优雅地需要处理大量中间结果的复杂计算。于是试用了一下
    

    • 

  • kotlin的一些资料（文档和视频）
tommyRen

    首次尝试使用Kotlin实现了项目其中的一个功能模块Kotlin已经作为Android官方开发语言并且Jakewarton大神（leakCanaryOkHttpRetrofitRxJava都是他的杰作）都评价很高在GoogleI/O大会分享了Kotlin的特色。毫无疑问Kotlin肯定有厉害之处。具体有哪些厉害之处呢？我给大家发几个图看下：我把我认识的App圈了出来大家可能会说微信怎么也是Kotl
    

    • 

  • Android-Retrofit2+Rxjava2之网络通用请求-再次修改完善
MonkeyLei

    目前采用的方式，目前项目重构版本用起来没什么问题，其他问题有待测试完善，然后有更新就同步到gitee上.参考地址：NetNut/DocPro-后续再精简完善，准备封装成库了（届时需要考虑支持不同的项目情况，目前针对小萌新自己的项目还做了一些特殊处理！）之前的一些学习尝试MonkeyLei：Android-Retrofit2+Rxjava2之网络通用请求-初步封装-相关关键类MonkeyLei：An
    

    • 

  • 多线程编程之理财
周凡杨
java多线程生产者消费者理财

          现实生活中，我们一边工作，一边消费，正常情况下会把多余的钱存起来，比如存到余额宝，还可以多挣点钱，现在就有这个情况：我每月可以发工资20000万元 （暂定每月的1号），每月消费5000（租房+生活费）元（暂定每月的1号），其中租金是大头占90%，交房租的方式可以选择（一月一交，两月一交、三月一交），理财：1万元存余额宝一天可以赚1元钱，
    

    • 

  • [Zookeeper学习笔记之三]Zookeeper会话超时机制
bit1129
zookeeper

    首先，会话超时是由Zookeeper服务端通知客户端会话已经超时，客户端不能自行决定会话已经超时，不过客户端可以通过调用Zookeeper.close()主动的发起会话结束请求，如下的代码输出内容
Created /zoo-739160015
CONNECTEDCONNECTED
.............CONNECTEDCONNECTED
CONNECTEDCLOSEDCLOSED

    

    • 

  • SecureCRT快捷键
daizj
secureCRT快捷键

    ctrl + a : 移动光标到行首ctrl + e ：移动光标到行尾crtl + b: 光标前移1个字符crtl + f: 光标后移1个字符crtl + h : 删除光标之前的一个字符ctrl + d ：删除光标之后的一个字符crtl + k ：删除光标到行尾所有字符crtl + u : 删除光标至行首所有字符crtl + w:  删除光标至行首
    

    • 

  • Java 子类与父类这间的转换
周凡杨
java 父类与子类的转换

        最近同事调的一个服务报错，查看后是日期之间转换出的问题。代码里是把 java.sql.Date 类型的对象 强制转换为 java.sql.Timestamp 类型的对象。报java.lang.ClassCastException。
 
    代码：
            
    

    • 

  • 可视化swing界面编辑
朱辉辉33
eclipseswing

          今天发现了一个WindowBuilder插件，功能好强大，啊哈哈，从此告别手动编辑swing界面代码，直接像VB那样编辑界面，代码会自动生成。
      首先在Eclipse中点击help，选择Install New Software,然后在Work with中输入WindowBui
    

    • 

  • web报表工具FineReport常用函数的用法总结（文本函数）
老A不折腾
finereportweb报表工具报表软件java报表

    文本函数
CHAR
CHAR(number):根据指定数字返回对应的字符。CHAR函数可将计算机其他类型的数字代码转换为字符。
Number:用于指定字符的数字，介于1Number:用于指定字符的数字，介于165535之间（包括1和65535）。
示例:
CHAR(88)等于“X”。
CHAR(45)等于“-”。
 
CODE
CODE(text):计算文本串中第一个字
    

    • 

  • mysql安装出错
林鹤霄
mysql安装

    [root@localhost ~]# rpm -ivh MySQL-server-5.5.24-1.linux2.6.x86_64.rpm Preparing...                #####################
    

    • 

  • linux下编译libuv
aigo
libuv

    下载最新版本的libuv源码，解压后执行：
./autogen.sh
 
这时会提醒找不到automake命令，通过一下命令执行安装（redhat系用yum，Debian系用apt-get）：
# yum -y install automake
# yum -y install libtool
 
 
如果提示错误：make: *** No targe
    

    • 

  • 中国行政区数据及三级联动菜单
alxw4616

    近期做项目需要三级联动菜单,上网查了半天竟然没有发现一个能直接用的!
呵呵,都要自己填数据....我了个去这东西麻烦就麻烦的数据上.
哎,自己没办法动手写吧.
现将这些数据共享出了,以方便大家.嗯,代码也可以直接使用
  文件说明
lib\area.sql -- 县及县以上行政区划分代码（截止2013年8月31日)来源：国家统计局 发布时间：2014-01-17 15:0
    

    • 

  • 哈夫曼加密文件
百合不是茶
哈夫曼压缩哈夫曼加密二叉树

     在上一篇介绍过哈夫曼编码的基础知识,下面就直接介绍使用哈夫曼编码怎么来做文件加密或者压缩与解压的软件,对于新手来是有点难度的,主要还是要理清楚步骤;
 
加密步骤:
 1,统计文件中字节出现的次数,作为权值
 
2,创建节点和哈夫曼树
 
3,得到每个子节点01串
 
4,使用哈夫曼编码表示每个字节
 

    

    • 

  • JDK1.5 Cyclicbarrier实例
bijian1013
javathreadjava多线程Cyclicbarrier

    CyclicBarrier类
一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用，所以称它为循环的 barrier。
CyclicBarrier支持一个可选的 Runnable 命令，
    

    • 

  • 九项重要的职业规划
bijian1013
工作学习

    一. 学习的步伐不停止        古人说，活到老，学到老。终身学习应该是您的座右铭。        世界在不断变化，每个人都在寻找各自的事业途径。        您只有保证了足够的技能储
    

    • 

  • 【Java范型四】范型方法
bit1129
java

    范型参数不仅仅可以用于类型的声明上，例如
 
package com.tom.lang.generics;
import java.util.List;
public class Generics<T> {
private T value;
public Generics(T value) {
this.value = 
    

    • 

  • 【Hadoop十三】HDFS Java API基本操作
bit1129
hadoop

     
package com.examples.hadoop;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileStatus;
import org.apache.hadoo
    

    • 

  • ua实现split字符串分隔
ronin47
lua split

    LUA并不象其它许多"大而全"的语言那样，包括很多功能，比如网络通讯、图形界面等。但是LUA可以很容易地被扩展：由宿主语言(通常是C或 C++)提供这些功能，LUA可以使用它们，就像是本来就内置的功能一样。LUA只包括一个精简的核心和最基本的库。这使得LUA体积小、启动速度快，从 而适合嵌入在别的程序里。因此在lua中并没有其他语言那样多的系统函数。习惯了其他语言的字符串分割函
    

    • 

  • java-从先序遍历和中序遍历重建二叉树
bylijinnan
java

    
public class BuildTreePreOrderInOrder {
/**
* Build Binary Tree from PreOrder and InOrder
* _______7______
/ \
__10__ ___2
/ \ /
4
    

    • 

  • openfire开发指南《连接和登陆》
开窍的石头
openfire开发指南smack

    第一步
    官网下载smack.jar包
    下载地址：http://www.igniterealtime.org/downloads/index.jsp#smack
第二步
    把smack里边的jar导入你新建的java项目中
开始编写smack连接openfire代码
p
    

    • 

  • [移动通讯]手机后盖应该按需要能够随时开启
comsci
移动

        看到新的手机，很多由金属材质做的外壳，内存和闪存容量越来越大，CPU速度越来越快，对于这些改进，我们非常高兴，也非常欢迎
     但是，对于手机的新设计，有几点我们也要注意
     第一：手机的后盖应该能够被用户自行取下来，手机的电池的可更换性应该是必须保留的设计,
    

    • 

  • 20款国外知名的php开源cms系统
cuiyadll
cms

    内容管理系统，简称CMS，是一种简易的发布和管理新闻的程序。用户可以在后端管理系统中发布，编辑和删除文章，即使您不需要懂得HTML和其他脚本语言，这就是CMS的优点。
在这里我决定介绍20款目前国外市面上最流行的开源的PHP内容管理系统，以便没有PHP知识的读者也可以通过国外内容管理系统建立自己的网站。
1. Wordpress
WordPress的是一个功能强大且易于使用的内容管
    

    • 

  • Java生成全局唯一标识符
darrenzhu
javauuiduniqueidentifierid

    How to generate a globally unique identifier in Java
http://stackoverflow.com/questions/21536572/generate-unique-id-in-java-to-label-groups-of-related-entries-in-a-log
http://stackoverflow
    

    • 

  • php安装模块检测是否已安装过, 使用的SQL语句
dcj3sjt126com
sql

    
SHOW [FULL] TABLES [FROM db_name] [LIKE 'pattern']
SHOW TABLES列举了给定数据库中的非TEMPORARY表。您也可以使用mysqlshow db_name命令得到此清单。
本命令也列举数据库中的其它视图。支持FULL修改符，这样SHOW FULL TABLES就可以显示第二个输出列。对于一个表，第二列的值为BASE T
    

    • 

  • 5天学会一种 web 开发框架
dcj3sjt126com
Web框架framework

    web framework层出不穷，特别是ruby/python,各有10+个,php/java也是一大堆 根据我自己的经验写了一个to do list,按照这个清单，一条一条的学习，事半功倍，很快就能掌握 一共25条，即便很磨蹭，2小时也能搞定一条，25*2=50。只需要50小时就能掌握任意一种web框架
各类web框架大同小异:现代web开发框架的6大元素，把握主线，就不会迷路
建议把本文
    

    • 

  • Gson使用三(Map集合的处理,一对多处理)
eksliang
jsongsonGson mapGson 集合处理

    转载请出自出处：http://eksliang.iteye.com/blog/2175532 一、概述
       Map保存的是键值对的形式，Json的格式也是键值对的，所以正常情况下，map跟json之间的转换应当是理所当然的事情。 二、Map参考实例
package com.ickes.json;
import java.lang.refl
    

    • 

  • cordova实现“再点击一次退出”效果
gundumw100
android

    基本的写法如下：
document.addEventListener("deviceready", onDeviceReady, false);
function onDeviceReady() {
//navigator.splashscreen.hide();
document.addEventListener("b
    

    • 

  • openldap configuration leaning note
iwindyforest
configuration

    hostname // to display the computer name
hostname <changed name> // to change
go to: /etc/sysconfig/network, add/modify HOSTNAME=NEWNAME to change permenately
dont forget to change /etc/hosts
    

    • 

  • Nullability and Objective-C
啸笑天
Objective-C

    https://developer.apple.com/swift/blog/?id=25
 
http://www.cocoachina.com/ios/20150601/11989.html
 
http://blog.csdn.net/zhangao0086/article/details/44409913
 
http://blog.sunnyxx
    

    • 

  • jsp中实现参数隐藏的两种方法
macroli
JavaScriptjsp

    在一个JSP页面有一个链接，//确定是一个链接?点击弹出一个页面，需要传给这个页面一些参数。//正常的方法是设置弹出页面的src="***.do?p1=aaa&p2=bbb&p3=ccc"//确定目标URL是Action来处理?但是这样会在页面上看到传过来的参数，可能会不安全。要求实现src="***.do"，参数通过其他方法传！//////
    

    • 

  • Bootstrap A标签关闭modal并打开新的链接解决方案
qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象

    Bootstrap里面的js modal控件使用起来很方便，关闭也很简单。只需添加标签 data-dismiss="modal" 即可。
可是偏偏有时候需要a标签既要关闭modal，有要打开新的链接，尝试多种方法未果。只好使用原始js来控制。
 
<a href="#/group-buy" class="btn bt
    

    • 

  • 二维数组在Java和C中的区别
流淚的芥末
javac二维数组数组

    Java代码：
 
public class test03 {
public static void main(String[] args) {
int[][] a = {{1},{2,3},{4,5,6}};
System.out.println(a[0][1]);
}
}
 运行结果：
Exception in thread "mai
    

    • 

  • systemctl命令用法
wmlJava
linuxsystemctl

    对比表，以 apache / httpd 为例 任务 旧指令 新指令 使某服务自动启动 chkconfig --level 3 httpd on systemctl enable httpd.service 使某服务不自动启动 chkconfig --level 3 httpd off systemctl disable httpd.service 检查服务状态 service h
    

    •