RxJava源码剖析

前言
本篇的文章是基于Rxjava 2.1.2。从下面的一段代码中，我们从源码的角度分析 RxJava 的实现原理：

ObservableOnSubscribe oos = new ObservableOnSubscribe() { 
    @Override 
    public void subscribe(ObservableEmitter e) throws Exception { 
        final int max = 100; 
        for (int i = 1; i <= max; i++) { 
            e.onNext(max); 
        } 
        e.onComplete(); 
    } 
}; 
Observer o = new Observer() { 
    @Override 
    public void onSubscribe(Disposable d) { 
    } 
    @Override 
    public void onNext(Integer integer) { 
    } 
    @Override 
    public void onError(Throwable e) { 
    } 
    @Override 
    public void onComplete() { 
    } 
}; 
Observable.create(oos) 
        .observeOn(AndroidSchedulers.mainThread()) 
        .subscribeOn(Schedulers.computation()) 
        .subscribe(o);

分析源码之前，我们先定义一下名词，RxJava 是基于观察者模式的，这里将被观察者叫做主题（Source），观察者叫做观察者（Observer）。

上面的代码首先创建了一个主题对象，然后又创建了一个观察者对象，最后将两者关联起来，并且最重要的一点，指定了主题对象和观察者对象执行的线程。

正文
Observable.create(oos)

首先分析这行代码做了什么事情：

public static  Observable create(ObservableOnSubscribe source) { 
    ObjectHelper.requireNonNull(source, "source is null"); 
    return RxJavaPlugins.onAssembly(new ObservableCreate(source)); 
}

ObjectHelper 只是用来做非空判断，这里就不用管它了。看看 RxJavaPlugins 做了什么：

/** 
 * Calls the associated hook function. 
 * @param  the value type 
 * @param source the hook's input value 
 * @return the value returned by the hook 
 */ 
@SuppressWarnings({ "rawtypes", "unchecked" }) 
@NonNull public static  Observable onAssembly(@NonNull Observable source) { 
    Function f = onObservableAssembly; 
    if (f != null) { 
        return apply(f, source); 
    } 
    return source;

注释上都说了，这是一个钩子函数，也就是说如果 onObservableAssembly 的值不为空，那么就调用这个钩子函数，onObservableAssembly 是一个静态变量，需要我们主动的去设置才会赋值，这里当做空来考虑，如果 onObservableAssembly 为空的话，也就是说这个方法啥都没做，直接返回 source 参数，也就是上面的 ObservableCreate 对象。

总结一下，Observable.create(oos) 只是创建了一个 ObservableCreate 对象。这个方法就暂时先分析到这里，至于这个对象内部有什么东西，我们后面会说到。

observeOn(AndroidSchedulers.mainThread())
既然之前的 create 方法创建了一个 ObservableCreate 对象并返回，也就是说 observeOn(Schedulers.computation()) 这个方法是调用的 ObservableCreate 这个对象上的方法。

public final class ObservableCreate extends Observable {

ObservableCreate 是继承至 Observable 的。

public final Observable observeOn(Scheduler scheduler) { 
    return observeOn(scheduler, false, bufferSize()); 
}

Observable 的 observeOn 是 final 的，所以走的父类的方法。继续跟踪 observeOn 调用的同名方法：

public final Observable observeOn(Scheduler scheduler, boolean delayError, int bufferSize) { 
    ObjectHelper.requireNonNull(scheduler, "scheduler is null"); 
    ObjectHelper.verifyPositive(bufferSize, "bufferSize"); 
    return RxJavaPlugins.onAssembly(new ObservableObserveOn(this, scheduler, delayError, bufferSize)); 
}

ObjectHelper 跳过。这里又是一个 onAssembly 方法的调用，我很好奇这个单词是什么意思。点进去看一下：

public static  Observable onAssembly(@NonNull Observable source) { 
    Function f = onObservableAssembly; 
    if (f != null) { 
        return apply(f, source); 
    } 
    return source; 
}

同样是一个钩子方法，现在也是有经验的人呢，再看到这个方法，就直接跳过，只关心它传递的参数和返回值就行了。它的返回值默认就是传递进来的参数。

所以，observeOn 方法就是创建并返回了一个 ObservableObserveOn 对象（大神教你起类名系列二），这里预警一下，之后像这样类似的类名差不多还有3个。

subscribeOn(Schedulers.computation())
由于 observeOn 创建并返回了一个 ObservableObserveOn 对象，所以这里调用的是 ObservableObserveOn 对象上的方法。

public final class ObservableObserveOn extends AbstractObservableWithUpstream { 
 
abstract class AbstractObservableWithUpstream extends Observable implements HasUpstreamObservableSource {

也是继承至 Observable 。

public final Observable subscribeOn(Scheduler scheduler) { 
    ObjectHelper.requireNonNull(scheduler, "scheduler is null"); 
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler)); 
}

不出意料，也是 final 的，创建了一个 ObservableSubscribeOn 对象（大神教你起类名系列三）并返回。

subscribe(o)
前面 subscribeOn 创建了一个 ObservableSubscribeOn 对象并返回，所以这里调用的是 ObservableSubscribeOn 这个对象上面的方法。

public final class ObservableSubscribeOn extends AbstractObservableWithUpstream { 
 
abstract class AbstractObservableWithUpstream extends Observable implements HasUpstreamObservableSource {

继承至 Observable 类。

public final void subscribe(Observer observer) { 
    ObjectHelper.requireNonNull(observer, "observer is null"); 
    try { 
        observer = RxJavaPlugins.onSubscribe(this, observer); 
        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer"); 
        subscribeActual(observer); 
    } catch (NullPointerException e) { // NOPMD 
        throw e; 
    } catch (Throwable e) { 
        Exceptions.throwIfFatal(e); 
        // can't call onError because no way to know if a Disposable has been set or not 
        // can't call onSubscribe because the call might have set a Subscription already 
        RxJavaPlugins.onError(e); 
        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS"); 
        npe.initCause(e); 
        throw npe; 
    } 
}

这个方法也是 final 的，所以是调用的这个方法。

public final void subscribe(Observer observer) { … }

这个方法是我们需要分析的重点，看看内部具体的代码吧先：

public final void subscribe(Observer observer) { 
    ObjectHelper.requireNonNull(observer, "observer is null"); 
    try { 
        observer = RxJavaPlugins.onSubscribe(this, observer); 
        ObjectHelper.requireNonNull(observer, "Plugin returned null Observer"); 
        subscribeActual(observer); 
    } catch (NullPointerException e) { // NOPMD 
        throw e; 
    } catch (Throwable e) { 
        Exceptions.throwIfFatal(e); 
        // can't call onError because no way to know if a Disposable has been set or not 
        // can't call onSubscribe because the call might have set a Subscription already 
        RxJavaPlugins.onError(e); 
        NullPointerException npe = new NullPointerException("Actually not, but can't throw other exceptions due to RS"); 
        npe.initCause(e); 
        throw npe; 
    } 
}

这里忽略 ObjectHelper 和异常处理的代码只有两行代码是关键。先看 observer = RxJavaPlugins.onSubscribe(this, observer):

public static  Observer onSubscribe(@NonNull Observable source, @NonNull Observer observer) { 
    BiFunction f = onObservableSubscribe; 
    if (f != null) { 
        return apply(f, source, observer); 
    } 
    return observer; 
}

没想到啊没想到，你这浓眉大眼的家伙也是一个钩子方法。所以这行代码相当于 obsever = observer。接着看，subscribeActual(observer):

protected abstract void subscribeActual(Observer observer);

这是一个抽象方法，没啥好分析的。接下来我们要进入正题了，根据我们编写的代码，是 ObservableSubscribeOn 这个对象调用了 subscribe 方法，所以我们看看这个类的 subscribeActual 方法。

@Override 
public void subscribeActual(final Observer s) { 
    final SubscribeOnObserver parent = new SubscribeOnObserver(s); 
    s.onSubscribe(parent); 
    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent))); 
}

这里需要注意的是 s 这个参数，后面会有很多地方看到这个参数，一定要搞清楚这个参数是谁传递过来的。比如说：

A.subscribe(B) 
那么，参数 s 就是 B。

在我们的代码中是 ObservableSubscribeOn.subscribe(o); 理解了这一点，我们详细分析代码里面的内容：首先创建了一个 SubscribeOnObserver （大神教你起类名系列四）。然后调用了我们创建的对象 o 的 onSubscribe 方法：

@Override 
public void onSubscribe(Disposable d) { 
}

我们的 onSubscribe 方法里面啥都没做。不过一般来说，你应该调用一下 onStart 方法。

接下来是调用 parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));，setDisposable 的方法不影响流程分析，这里就先跳过了，有兴趣的可以点进去看一下。然后就是 scheduler 变量，这个变量就是我们使用 subscribeOn 传递的参数：

public final Observable subscribeOn(Scheduler scheduler) { 
    ObjectHelper.requireNonNull(scheduler, "scheduler is null"); 
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler)); 
} 
 
public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) { 
    super(source); 
    this.scheduler = scheduler; 
}

这个 scheduler 就是 Schedulers.computation()。然后调用了它的 scheduleDirect 方法：

public Disposable scheduleDirect(@NonNull Runnable run) { 
    return scheduleDirect(run, 0L, TimeUnit.NANOSECONDS); 
} 
 
public Disposable scheduleDirect(@NonNull Runnable run, long delay, @NonNull TimeUnit unit) { 
    final Worker w = createWorker(); 
    final Runnable decoratedRun = RxJavaPlugins.onSchedule(run); 
    DisposeTask task = new DisposeTask(decoratedRun, w); 
    w.schedule(task, delay, unit); 
    return task; 
}

这两个方法是父类的，Schedulers.computation() 返回的是一个 ComputationScheduler 对象，这里找具体的实现类由于调用链比较长，就不给出了，自己点着点着就能找到了。看看 ComputationScheduler 有没有复写这两个方法：

@NonNull 
@Override 
public Disposable scheduleDirect(@NonNull Runnable run, long delay, TimeUnit unit) { 
    PoolWorker w = pool.get().getEventLoop(); 
    return w.scheduleDirect(run, delay, unit); 
}

它覆盖了父类的第2个 scheduleDirect 方法。这里就不深入分析里面的池了。看 w.scheduleDirect(run, delay, unit);：

public Disposable scheduleDirect(final Runnable run, long delayTime, TimeUnit unit) { 
    ScheduledDirectTask task = new ScheduledDirectTask(RxJavaPlugins.onSchedule(run)); 
    try { 
        Future f; 
        if (delayTime <= 0L) { 
            f = executor.submit(task); 
        } else { 
            f = executor.schedule(task, delayTime, unit); 
        } 
        task.setFuture(f); 
        return task; 
    } catch (RejectedExecutionException ex) { 
        RxJavaPlugins.onError(ex); 
        return EmptyDisposable.INSTANCE; 
    } 
}

熟悉的线程池使用代码。希望看到这里你还没有忘记我们要分析的是什么。简单的归纳一下，其实就是向我们创建的 scheduler 里面提交了一个 runnable。最终这个 Runnable 肯定会执行，那么看看这个 Runnable 里面有什么代码：

parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent)));

final class SubscribeTask implements Runnable { 
   private final SubscribeOnObserver parent; 
   SubscribeTask(SubscribeOnObserver parent) { 
       this.parent = parent; 
   } 
   @Override 
   public void run() { 
       source.subscribe(parent); 
   } 
}

run 方法里面就只有一句代码，但是我们需要搞清楚这里的 source 和 parent 分别是哪个对象。

parent 可以直接看到是 SubscribeOnObserver 对象。

source 是使用的外部类的变量。

public ObservableSubscribeOn(ObservableSource source, Scheduler scheduler) { 
    super(source); 
    this.scheduler = scheduler; 
}

这里调用了 super 方法，所以构造函数里传递的变量就是 source。

public final Observable subscribeOn(Scheduler scheduler) { 
    ObjectHelper.requireNonNull(scheduler, "scheduler is null"); 
    return RxJavaPlugins.onAssembly(new ObservableSubscribeOn(this, scheduler)); 
}

这里是我们之前分析过的创建 ObservableSubscribeOn 的代码，这里的 this 指的是 observeOn 创建的 ObservableObserveOn 对象。希望看到这里你没有搞晕，如果你是使用手机看的，并且看懂了，我是真的佩服。

也就是说，run 里面的代码就是调用了 ObservableObserveOn 对象的 subscribe 方法。之前我们分析过了，subscribe 方法实际上没有做什么，只是调用了 subscribeActual 方法，所以我们进入这个类内部看看：

@Override 
protected void subscribeActual(Observer observer) { 
    if (scheduler instanceof TrampolineScheduler) { 
        source.subscribe(observer); 
    } else { 
        Scheduler.Worker w = scheduler.createWorker(); 
        source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize)); 
    } 
}

我们在 observeOn 传递的 scheduler 不是 TrampolineScheduler 类型的，所以只需要看 else 的代码。这里是先创建了一个工作线程（由于我们使用的是 AndroidScheduler，所以这里是指的主线程），然后调用了 source 的 subscribe 方法。需要注意的是这里最后创建了一个 ObserveOnObserver 对象（大神教你起类名系列五）。

先看看 createWork，在 HandlerScheduler 中：

@Override 
public Worker createWorker() { 
    return new HandlerWorker(handler); 
}

返回了一个 HandlerWorker 对象。再看 source.subscribe()，首先这里的 source 指的是 create 方法创建的 ObservableCreate 对象，调用 subscribe 传递的是 ObserveOnObserver。看看这个对象的 subscribeActual 方法：

@Override 
protected void subscribeActual(Observer observer) { 
    CreateEmitter parent = new CreateEmitter(observer); 
    observer.onSubscribe(parent); 
    try { 
        source.subscribe(parent); 
    } catch (Throwable ex) { 
        Exceptions.throwIfFatal(ex); 
        parent.onError(ex); 
    } 
}

这里的参数 observer 是 ObserveOnObserver，source 是我们代码中创建的 oos 对象。

首先创建了一个 CreateEmitter 对象。接着看 ObserveOnObserver 的 onSubscribe 方法做了啥：

@Override 
public void onSubscribe(Disposable s) { 
    if (DisposableHelper.validate(this.s, s)) { 
        this.s = s; 
        if (s instanceof QueueDisposable) { 
            @SuppressWarnings("unchecked") 
            QueueDisposable qd = (QueueDisposable) s; 
            int m = qd.requestFusion(QueueDisposable.ANY | QueueDisposable.BOUNDARY); 
            if (m == QueueDisposable.SYNC) { 
                sourceMode = m; 
                queue = qd; 
                done = true; 
                actual.onSubscribe(this); 
                schedule(); 
                return; 
            } 
            if (m == QueueDisposable.ASYNC) { 
                sourceMode = m; 
                queue = qd; 
                actual.onSubscribe(this); 
                return; 
            } 
        } 
        queue = new SpscLinkedArrayQueue(bufferSize); 
        actual.onSubscribe(this); 
    } 
}

这里代码比较长，只分析重要的代码，就是 actual.onSubscribe 这句。actual 是构造函数中赋值的，所以我们回到创建 ObserveOnObserver 的地方，actual 指的是 SubscribeOnObserver 对象。所以它调用了 SubscribeOnObserver 的 onSubscribe 方法。接下来分析一下它的 onSubscribe 方法做了什么，这里不看也不会影响流程。

SubscribeOnObserver(Observer actual) { 
    this.actual = actual; 
    this.s = new AtomicReference(); 
} 
@Override 
public void onSubscribe(Disposable s) { 
    DisposableHelper.setOnce(this.s, s); 
}

这个方法调用了 setOnce 方法：

public static boolean setOnce(AtomicReference field, Disposable d) { 
    ObjectHelper.requireNonNull(d, "d is null"); 
    if (!field.compareAndSet(null, d)) { 
        d.dispose(); 
        if (field.get() != DISPOSED) { 
            reportDisposableSet(); 
        } 
        return false; 
    } 
    return true; 
}

这里涉及到了乐观锁等玩意，简单来说就是先判断 field 的值是否为空，如果为空则设置为 d，不为空则将 d dispose。然后判断 field 的值，由于 field 的值只能设定一次非 DISPOSED 值，所以如果不为 DISPOSED，说明已经被设置过了，再报出异常，如果为 DISPOSED 是可以再次设置的。按照正常的流程，这里只是将 field 的值设置为 d，然后返回true。这个方法可以先不用管。

回到主线流程上，source.subscribe(parent); 这是最重要的一句代码。source 是在构造函数赋值的，看看构造方法：

public static  Observable create(ObservableOnSubscribe source) { 
    ObjectHelper.requireNonNull(source, "source is null"); 
    return RxJavaPlugins.onAssembly(new ObservableCreate(source)); 
}

也就是说这里的 source 是我们代码中创建的 oos 对象。parent 是新创建的 CreateEmitter 对象。看看我们 oos 的 subscribe 方法：

@Override 
public void subscribe(ObservableEmitter e) throws Exception { 
    Log.e("aprz", Thread.currentThread().getName()); 
    final int max = 100; 
    for (int i = 1; i <= max; i++) { 
        e.onNext(i); 
    } 
    e.onComplete(); 
}

这里就是事件开始的起点。所有的事件都由 ObservableEmitter 开始发送，看看它的代码，它是一个接口，在我们的例子中，它的实现类是 CreateEmitter，所有我们分析这个类的 onNext 方法：

@Override 
public void onNext(T t) { 
    if (t == null) { 
        onError(new NullPointerException("onNext called with null. Null values are generally not allowed in 2.x operators and sources.")); 
        return; 
    } 
    if (!isDisposed()) { 
        observer.onNext(t); 
    } 
}

isDisposed 方法返回 false 才会去调用 observer 的 onNext 方法，这个 observer 是谁呢? 看到这里我们就要从后往前推一遍之前的代码了，不管你绝不绝望，反正我是很绝望。这的 observer 是 ObserveOnObserver 对象。

接下来我们就进入 ObserveOnObserver 里面，看看它接受事件之后做了什么，上面的参数 e 就是：

@Override 
public void onNext(T t) { 
    if (done) { 
        return; 
    } 
    if (sourceMode != QueueDisposable.ASYNC) { 
        queue.offer(t); 
    } 
    schedule(); 
}

调用了 schedule 方法：

void schedule() { 
    if (getAndIncrement() == 0) { 
        worker.schedule(this); 
    } 
}

向 work 中提交了一个 Runnable，这里传递的是 this。说明它自己肯定实现了这个接口，我们看看它的 run 方法做了啥：

@Override 
public void run() { 
    if (outputFused) { 
        drainFused(); 
    } else { 
        drainNormal(); 
    } 
}

这里一般是走 drainNormal 吧，我猜的，我们分析这个方法吧。

void drainNormal() { 
    int missed = 1; 
    final SimpleQueue q = queue; 
    final Observer a = actual; 
    for (;;) { 
        if (checkTerminated(done, q.isEmpty(), a)) { 
            return; 
        } 
        for (;;) { 
            boolean d = done; 
            T v; 
            try { 
                v = q.poll(); 
            } catch (Throwable ex) { 
                Exceptions.throwIfFatal(ex); 
                s.dispose(); 
                q.clear(); 
                a.onError(ex); 
                worker.dispose(); 
                return; 
            } 
            boolean empty = v == null; 
            if (checkTerminated(d, empty, a)) { 
                return; 
            } 
            if (empty) { 
                break; 
            } 
            a.onNext(v); 
        } 
        missed = addAndGet(-missed); 
        if (missed == 0) { 
            break; 
        } 
    } 
}

代码很长，具体做了啥我们暂时不用关心，只需要注意到 a.onNexe(v) 这行代码，这个 a 是 actual 变量，actual 又是 SubscribeOnObserver 对象，我们看看它的 onNext 方法：

@Override 
public void onNext(T t) { 
    actual.onNext(t); 
}

很简单，这里的 actual 就是我们创建的 o 了，所以最终调用到了我们的代码里面。

好了，到这里一个完整的流程就整理出来了，但是还有一个问题没有解决，就是线程切换是发生在哪里。因为为了不影响整体流程的分析，所以上面并没有去分析线程切换的东西，下面开始分析。

直接从 subscribeOn 开始，看 ObservableSubscribeOn 的代码：

@Override 
public void subscribeActual(final Observer s) { 
    final SubscribeOnObserver parent = new SubscribeOnObserver(s); 
    s.onSubscribe(parent); 
    parent.setDisposable(scheduler.scheduleDirect(new SubscribeTask(parent))); 
}

从这里开始就进行了线程的切换，根据上面的分析我们知道这里是将 SubscribeTask 作为一个 Runnable 对象给提交进了我们指定的 scheduler （subscribeOn 传递的）中。所以后面的流程都是在 scheduler 所在的线程在运行。

再看 observeOn，看 ObservableObserveOn 的代码。

@Override 
protected void subscribeActual(Observer observer) { 
    if (scheduler instanceof TrampolineScheduler) { 
        source.subscribe(observer); 
    } else { 
        Scheduler.Worker w = scheduler.createWorker(); 
        source.subscribe(new ObserveOnObserver(observer, w, delayError, bufferSize)); 
    } 
}

这里的线程切换是发生在 ObserveOnObserver 这个对象的里面。

void schedule() { 
    if (getAndIncrement() == 0) { 
        worker.schedule(this); 
    } 
}

schedule 的流程，我们上面分析过，worker.schedule(this) 这行代码就发生了线程切换，是将 this 作为 Runnable 对象提交到了我们指定的（observerOn 传递的）scheduler 中。具体分析，由于之前的流程是在别的线程中，所以想要进行线程切换，最先想到的肯定是 Handler。由于我们传递的是 AndroidSchedulers.mainThread()，所以我们就分析这个吧。

AndroidSchedulers.mainThread() 的实现是 HandlerScheduler。看看它的 schedule 方法：

@Override 
public Disposable schedule(Runnable run, long delay, TimeUnit unit) { 
    if (run == null) throw new NullPointerException("run == null"); 
    if (unit == null) throw new NullPointerException("unit == null"); 
    if (disposed) { 
        return Disposables.disposed(); 
    } 
    run = RxJavaPlugins.onSchedule(run); 
    ScheduledRunnable scheduled = new ScheduledRunnable(handler, run); 
    Message message = Message.obtain(handler, scheduled); 
    message.obj = this; // Used as token for batch disposal of this worker's runnables. 
    handler.sendMessageDelayed(message, Math.max(0L, unit.toMillis(delay))); 
    // Re-check disposed state for removing in case we were racing a call to dispose(). 
    if (disposed) { 
        handler.removeCallbacks(scheduled); 
        return Disposables.disposed(); 
    } 
    return scheduled; 
}

post 了一个 msg，这样就完成了线程的切换。下面上一张图，有助于理解和记忆：

RxJava源码剖析_第1张图片

只需要理解，每次 observerOn 和 subscribeOn 的时候，内部都会创建一个新的 observable 和 observer。

。新创建的 observable 会引用前面的 observable，就是代码中我们分析的 source 变量。

。新创建的 observer 会引用前面的 observer，就是代码中我们分析的 actual 变量。

最后我们 subscribe 的时候，是调用的最后创建的 observable 的方法。而每个 observable 内部又调用了 source 的 subscribe 方法，这样就形成了一层一层往前传递的调用链。当调用到最前面的一个 observable 的时候，就是我们自己创建的 observable，在这里我们需要手动触发该与该 observable 对应的 observer 对象的 onNext 方法。而 observer 的 onNext 方法的内部又调用了 actual 的 onNext 方法，这样就形成了一层一层往后传递的调用链。

总结
虽然在我们的例子中，CreateEmitter 并不是一个 observer ，但是它也有 onNext 等方法，可以把它看做一个 observer。

如此，RxJava 的一个流程就理清楚了。这货的流程和 OkHttp 怎么有点像，只是稍微有点不一样。

补充一下关于背压的知识：在异步订阅的时候，使用 Observable，默认的缓冲大小是 128，超过 这个数量之后会 resize，也就是说会缓冲所有的事件，这样就会导致内存占用一直增加。

结语：后续会持续更新哦，喜欢的话点赞关注一下吧。
相关视频
【Android进阶】Rxjava与low响应式编程

你可能感兴趣的:(rxjavaandroid)

  • RxJavaAndroid学习笔记 封夕罡
    当子线程处理某个逻辑要在主线程显示的时候使用。Observable.just(currentBytesCount).observeOn(AndroidSchedulers.mainThread()).subscribe(newAction1(){@Overridepublicvoidcall(LongaLong){tvMsg.setText("提示:上传中");progressBar.setMax
  • android 学习RxJava+Retrofit的资料 jifashihan
    最近这段时间在看RxJava+Retrofit的使用方法，现在把参考的资料记录一下给Android开发者的RxJava详解谜之RxJavaAndroid中Retrofit结合RxJava使用Android中RxJava+Retrofit2.0+MVP模式的整合android中使用Retrofit调用https接口及缓存详细解析RxAndroid的使用方式
  • scala的option和some 矮蛋蛋 编程scala
    原文地址： http://blog.sina.com.cn/s/blog_68af3f090100qkt8.html 对于学习 Scala 的 Java™ 开发人员来说，对象是一个比较自然、简单的入口点。在 本系列 前几期文章中，我介绍了 Scala 中一些面向对象的编程方法，这些方法实际上与 Java 编程的区别不是很大。我还向您展示了 Scala 如何重新应用传统的面向对象概念，找到其缺点
  • NullPointerException Cb123456 androidBaseAdapter
        java.lang.NullPointerException: Attempt to invoke virtual method 'int android.view.View.getImportantForAccessibility()' on a null object reference     出现以上异常.然后就在baidu上
  • PHP使用文件和目录 天子之骄 php文件和目录读取和写入php验证文件php锁定文件
    PHP使用文件和目录 1.使用include()包含文件 (1)：使用include()从一个被包含文档返回一个值 (2)：在控制结构中使用include()   include_once()函数需要一个包含文件的路径，此外，第一次调用它的情况和include()一样，如果在脚本执行中再次对同一个文件调用，那么这个文件不会再次包含。   在php.ini文件中设置
  • SQL SELECT DISTINCT 语句 何必如此 sql
    SELECT DISTINCT 语句用于返回唯一不同的值。 SQL SELECT DISTINCT 语句 在表中，一个列可能会包含多个重复值，有时您也许希望仅仅列出不同（distinct）的值。 DISTINCT 关键词用于返回唯一不同的值。 SQL SELECT DISTINCT 语法 SELECT DISTINCT column_name,column_name F
  • java冒泡排序 3213213333332132 java冒泡排序
    package com.algorithm; /** * @Description 冒泡 * @author FuJianyong * 2015-1-22上午09:58:39 */ public class MaoPao { public static void main(String[] args) { int[] mao = {17,50,26,18,9,10
  • struts2.18 +json,struts2-json-plugin-2.1.8.1.jar配置及问题！ 7454103 DAOspringAjaxjsonqq
    struts2.18  出来有段时间了！ （貌似是 稳定版）   闲时研究下下！  貌似 sruts2 搭配 json 做 ajax 很吃香！   实践了下下！ 不当之处请绕过！ 呵呵   网上一大堆 struts2+json  不过大多的json 插件 都是 jsonplugin.34.jar   strut
  • struts2 数据标签说明 darkranger jspbeanstrutsservletScheme
    数据标签主要用于提供各种数据访问相关的功能，包括显示一个Action里的属性，以及生成国际化输出等功能 数据标签主要包括： action ：该标签用于在JSP页面中直接调用一个Action，通过指定executeResult参数，还可将该Action的处理结果包含到本页面来。 bean ：该标签用于创建一个javabean实例。如果指定了id属性，则可以将创建的javabean实例放入Sta
  • 链表.简单的链表节点构建 aijuans 编程技巧
    /*编程环境WIN-TC*/ #include "stdio.h" #include "conio.h" #define NODE(name, key_word, help) \  Node name[1]={{NULL, NULL, NULL, key_word, help}} typedef struct node {  &nbs
  • tomcat下jndi的三种配置方式 avords tomcat
    jndi(Java Naming and Directory Interface，Java命名和目录接口)是一组在Java应用中访问命名和目录服务的API。命名服务将名称和对象联系起来，使得我们可以用名称 访问对象。目录服务是一种命名服务，在这种服务里，对象不但有名称，还有属性。          tomcat配置
  • 关于敏捷的一些想法 houxinyou 敏捷
    从网上看到这样一句话：“敏捷开发的最重要目标就是：满足用户多变的需求，说白了就是最大程度的让客户满意。” 感觉表达的不太清楚。 感觉容易被人误解的地方主要在“用户多变的需求”上。 第一种多变，实际上就是没有从根本上了解了用户的需求。用户的需求实际是稳定的，只是比较多，也比较混乱，用户一般只能了解自己的那一小部分，所以没有用户能清楚的表达出整体需求。而由于各种条件的，用户表达自己那一部分时也有
  • 富养还是穷养，决定孩子的一生 bijian1013 教育人生
    是什么决定孩子未来物质能否丰盛？为什么说寒门很难出贵子，三代才能出贵族？真的是父母必须有钱，才能大概率保证孩子未来富有吗？-----作者：@李雪爱与自由 事实并非由物质决定，而是由心灵决定。一朋友富有而且修养气质很好，兄弟姐妹也都如此。她的童年时代，物质上大家都很贫乏，但妈妈总是保持生活中的美感，时不时给孩子们带回一些美好小玩意，从来不对孩子传递生活艰辛、金钱来之不易、要懂得珍惜
  • oracle 日期时间格式转化 征客丶 oracle
    oracle 系统时间有 SYSDATE 与 SYSTIMESTAMP； SYSDATE：不支持毫秒，取的是系统时间； SYSTIMESTAMP：支持毫秒，日期，时间是给时区转换的，秒和毫秒是取的系统的。 日期转字符窜： 一、不取毫秒： TO_CHAR(SYSDATE, 'YYYY-MM-DD HH24:MI:SS') 简要说明， YYYY 年 MM   月
  • 【Scala六】分析Spark源代码总结的Scala语法四 bit1129 scala
    1. apply语法   FileShuffleBlockManager中定义的类ShuffleFileGroup，定义：   private class ShuffleFileGroup(val shuffleId: Int, val fileId: Int, val files: Array[File]) { ... def apply(bucketId
  • Erlang中有意思的bug bookjovi erlang
      代码中常有一些很搞笑的bug，如下面的一行代码被调用两次（Erlang beam） commit f667e4a47b07b07ed035073b94d699ff5fe0ba9b Author: Jovi Zhang <[email protected]> Date: Fri Dec 2 16:19:22 2011 +0100 erts:
  • 移位打印10进制数转16进制-2008-08-18 ljy325 java基础
    /** * Description 移位打印10进制的16进制形式 * Creation Date 15-08-2008 9:00 * @author 卢俊宇 * @version 1.0 * */ public class PrintHex { // 备选字符 static final char di
  • 读《研磨设计模式》-代码笔记-组合模式 bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; abstract class Component { public abstract void printStruct(Str
  • 利用cmd命令将.class文件打包成jar chenyu19891124 cmdjar
    cmd命令打jar是如下实现： 在运行里输入cmd，利用cmd命令进入到本地的工作盘符。(如我的是D盘下的文件有此路径 D:\workspace\prpall\WEB-INF\classes) 现在是想把D:\workspace\prpall\WEB-INF\classes路径下所有的文件打包成prpall.jar。然后继续如下操作： cd D: 回车 cd workspace/prpal
  • [原创]JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明 comsci eclipse设计模式算法工作swing
                           JWFD v0.96 工作流系统二次开发包 for Eclipse 简要说明     &nb
  • SecureCRT右键粘贴的设置 daizj secureCRT右键粘贴
    一般都习惯鼠标右键自动粘贴的功能，对于SecureCRT6.7.5 ，这个功能也已经是默认配置了。 老版本的SecureCRT其实也有这个功能，只是不是默认设置，很多人不知道罢了。 菜单： Options->Global Options ...->Terminal 右边有个Mouse的选项块。 Copy on Select Paste on Right/Middle
  • Linux 软链接和硬链接 dongwei_6688 linux
    1.Linux链接概念Linux链接分两种，一种被称为硬链接（Hard Link），另一种被称为符号链接（Symbolic Link）。默认情况下，ln命令产生硬链接。 【硬连接】硬连接指通过索引节点来进行连接。在Linux的文件系统中，保存在磁盘分区中的文件不管是什么类型都给它分配一个编号，称为索引节点号(Inode Index)。在Linux中，多个文件名指向同一索引节点是存在的。一般这种连
  • DIV底部自适应 dcj3sjt126com JavaScript
    <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml&q
  • Centos6.5使用yum安装mysql——快速上手必备 dcj3sjt126com mysql
    第1步、yum安装mysql [root@stonex ~]#  yum -y install mysql-server 安装结果： Installed:     mysql-server.x86_64 0:5.1.73-3.el6_5                   &nb
  • 如何调试JDK源码 frank1234 jdk
    相信各位小伙伴们跟我一样，想通过JDK源码来学习Java，比如collections包，java.util.concurrent包。 可惜的是sun提供的jdk并不能查看运行中的局部变量，需要重新编译一下rt.jar。 下面是编译jdk的具体步骤：         1.把C:\java\jdk1.6.0_26\sr
  • Maximal Rectangle hcx2013 max
    Given a 2D binary matrix filled with 0's and 1's, find the largest rectangle containing all ones and return its area.   public class Solution { public int maximalRectangle(char[][] matrix)
  • Spring MVC测试框架详解——服务端测试 jinnianshilongnian spring mvc test
    随着RESTful Web Service的流行，测试对外的Service是否满足期望也变的必要的。从Spring 3.2开始Spring了Spring Web测试框架，如果版本低于3.2，请使用spring-test-mvc项目（合并到spring3.2中了）。   Spring MVC测试框架提供了对服务器端和客户端（基于RestTemplate的客户端）提供了支持。 &nbs
  • Linux64位操作系统（CentOS6.6）上如何编译hadoop2.4.0 liyong0802 hadoop
    一、准备编译软件   1.在官网下载jdk1.7、maven3.2.1、ant1.9.4，解压设置好环境变量就可以用。     环境变量设置如下：   （1）执行vim /etc/profile （2）在文件尾部加入: export JAVA_HOME=/home/spark/jdk1.7 export MAVEN_HOME=/ho
  • StatusBar 字体白色 pangyulei status
    [[UIApplication sharedApplication] setStatusBarStyle:UIStatusBarStyleLightContent]; /*you'll also need to set UIViewControllerBasedStatusBarAppearance to NO in the plist file if you use this method
  • 如何分析Java虚拟机死锁 sesame javathreadoracle虚拟机jdbc
    英文资料： Thread Dump and Concurrency Locks   Thread dumps are very useful for diagnosing synchronization related problems such as deadlocks on object monitors. Ctrl-\ on Solaris/Linux or Ctrl-B
  • 位运算简介及实用技巧（一）：基础篇 tw_wangzhengquan 位运算
    http://www.matrix67.com/blog/archives/263    去年年底写的关于位运算的日志是这个Blog里少数大受欢迎的文章之一，很多人都希望我能不断完善那篇文章。后来我看到了不少其它的资料，学习到了更多关于位运算的知识，有了重新整理位运算技巧的想法。从今天起我就开始写这一系列位运算讲解文章，与其说是原来那篇文章的follow-up，不如说是一个r
  • jsearch的索引文件结构 yangshangchuan 搜索引擎jsearch全文检索信息检索word分词
    jsearch是一个高性能的全文检索工具包，基于倒排索引，基于java8，类似于lucene，但更轻量级。   jsearch的索引文件结构定义如下：     1、一个词的索引由=分割的三部分组成：        第一部分是词        第二部分是这个词在多少
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他