还是把demo贴过来
BehaviorSubject<Integer> s = BehaviorSubject.create(555);
s.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("1----" + integer);
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
System.out.println("onError");
}
}, new Action0() {
@Override
public void call() {
System.out.println("onComplete1");
}
});
System.out.println("------1------");
s.onNext(1);
System.out.println("--------2----");
s.onNext(2);
System.out.println("-------3-----");
s.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("2----" + integer);
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
System.out.println("onError");
}
}, new Action0() {
@Override
public void call() {
System.out.println("onComplete2");
}
});
System.out.println("----4-------");
s.onNext(3);
System.out.println("----5--------");
s.onNext(4);
System.out.println("-----6-------");
s.subscribe(new Action1<Integer>() {
@Override
public void call(Integer integer) {
System.out.println("3----" + integer);
}
}, new Action1<Throwable>() {
@Override
public void call(Throwable throwable) {
System.out.println("onError");
}
}, new Action0() {
@Override
public void call() {
System.out.println("3onComplete");
}
});
s.onCompleted();
类图
还是先看一下create函数
public static <T> BehaviorSubject<T> create(T defaultValue) {
return create(defaultValue, true);
}
private static <T> BehaviorSubject<T> create(T defaultValue, boolean hasDefault) {
final SubjectSubscriptionManager<T> state = new SubjectSubscriptionManager<T>();
if (hasDefault) {
state.setLatest(NotificationLite.next(defaultValue));
}
state.onAdded = new Action1<SubjectObserver<T>>() {
@Override
public void call(SubjectObserver<T> o) {
o.emitFirst(state.getLatest());
}
};
state.onTerminated = state.onAdded;
return new BehaviorSubject<T>(state, state);
}
把defaultValue设置到state,设置了state的onAdded
然后subscrib的时候根据前文分析会调用到SubjectSubscriptionManager的call函数,最终又调用到State的add函数
boolean add(SubjectObserver<T> o) {
do {
State oldState = get();
if (oldState.terminated) {
onTerminated.call(o);
return false;
}
State newState = oldState.add(o);
if (compareAndSet(oldState, newState)) {
onAdded.call(o);
return true;
}
} while (true);
}
这里会回调我们的onAdded,onAdded就是前面设置的
public void call(SubjectObserver<T> o) {
o.emitFirst(state.getLatest());
}
之类state.getLatest()就是我们刚设置的默认值
o则是SubjectObserver
看一下emitFirst函数
void emitFirst(Object n) {
synchronized (this) {
if (!first || emitting) {
return;
}
first = false;
emitting = n != null;
}
if (n != null) {
emitLoop(null, n);
}
}
第一次进来emitting=false,first=true
这里会把emitting设置为true,first设置为false
进入emitLoop
void emitLoop(List<Object> localQueue, Object current) {
boolean once = true;
boolean skipFinal = false;
try {
do {
if (localQueue != null) {
for (Object n : localQueue) {
accept(n);
}
}
if (once) {
once = false;
accept(current);
}
synchronized (this) {
localQueue = queue;
queue = null;
if (localQueue == null) {
emitting = false;
skipFinal = true;
break;
}
}
} while (true);
} finally {
if (!skipFinal) {
synchronized (this) {
emitting = false;
}
}
}
}
localQueue为Null
once为true调用accept,并把once设置为false
void accept(Object n) {
if (n != null) {
NotificationLite.accept(actual, n);
}
}
这里的actual就是我们的订阅者
public static <T> boolean accept(Observer<? super T> o, Object n) {
if (n == ON_COMPLETED_SENTINEL) {
o.onCompleted();
return true;
} else if (n == ON_NEXT_NULL_SENTINEL) {
o.onNext(null);
return false;
} else if (n != null) {
if (n.getClass() == OnErrorSentinel.class) {
o.onError(((OnErrorSentinel) n).e);
return true;
}
o.onNext((T) n);
return false;
} else {
throw new IllegalArgumentException("The lite notification can not be null");
}
}
这里走第二个else if分支,调用onNext
最终调用到demo中我们onNext函数
public void call(Integer integer) {
System.out.println("1----" + integer);
}
这样subscribe时就把默认值打印出来了
接着再分享onNext
public void onNext(T v) {
Object last = state.getLatest();
if (last == null || state.active) {
Object n = NotificationLite.next(v);
for (SubjectObserver<T> bo : state.next(n)) {
bo.emitNext(n);
}
}
}
这里last是前面的默认值,active为true
调用state的next
SubjectObserver<T>[] next(Object n) {
setLatest(n);
return get().observers;
}
设置当前值到state,返回当前的observers,这里就是我们前面订阅的一个
回到onNext调用emitNext
void emitNext(Object n) {
if (!fastPath) {
synchronized (this) {
first = false;
if (emitting) {
if (queue == null) {
queue = new ArrayList<Object>();
}
queue.add(n);
return;
}
}
fastPath = true;
}
NotificationLite.accept(actual, n);
}
fastPath为false
最终调用
NotificationLite.accept(actual, n)
这个我们前面分析过
最后看一下onCompleted
public void onCompleted() {
Object last = state.getLatest();
if (last == null || state.active) {
Object n = NotificationLite.completed();
for (SubjectObserver<T> bo : state.terminate(n)) {
bo.emitNext(n);
}
}
}
这里把n设置为NotificationLite.completed(),调用emitNext,后者又调用 NotificationLite.accept(actual, n);
public static <T> boolean accept(Observer<? super T> o, Object n) {
if (n == ON_COMPLETED_SENTINEL) {
o.onCompleted();
return true;
} else if (n == ON_NEXT_NULL_SENTINEL) {
o.onNext(null);
return false;
} else if (n != null) {
if (n.getClass() == OnErrorSentinel.class) {
o.onError(((OnErrorSentinel) n).e);
return true;
}
o.onNext((T) n);
return false;
} else {
throw new IllegalArgumentException("The lite notification can not be null");
}
}
n为
NotificationLite.completed()走第一个if分支,最终调用我们的onCompleted