Rxjava(创建类)--just1

just操作符跟Observable.create一样，同样是创建一个Observable,看一下just创建的流程。

    public static <T> Observable<T> just(final T value) {
        return ScalarSynchronousObservable.create(value);
    }

这里调用ScalarSynchronousObservable创建Observable

 public static <T> ScalarSynchronousObservable<T> create(T t) {
        return new ScalarSynchronousObservable<T>(t);
    }

这里创建了一个ScalarSynchronousObservable

    protected ScalarSynchronousObservable(final T t) {
        super(RxJavaHooks.onCreate(new JustOnSubscribe<T>(t)));
        this.t = t;
    }

同样忽略RxJavaHooks，这里创建了一个JustOnSubscribe

看super

  protected Observable(OnSubscribe<T> f) {
        this.onSubscribe = f;
    }

我们看一下这几个类的关系

然后订阅的时候，调用的是JustOnSubscribe的call,

  public void call(Subscriber<? super T> s) {
            s.setProducer(createProducer(s, value));
        }

这里同样被封装为SafeSubscriber，这里创建一个Producer并把它设置给观察者，首先分析一下Producer创建过程

   static <T> Producer createProducer(Subscriber<? super T> s, T v) {
        if (STRONG_MODE) {
            return new SingleProducer<T>(s, v);
        }
        return new WeakSingleProducer<T>(s, v);
    }

这里假设STRONG_MODE为false ,返回WeakSingleProducer

这两个Producer的request实现有店不一样，里面

然后调用Subscriber的setProducer

public void setProducer(Producer p) {
        long toRequest;
        boolean passToSubscriber = false;
        synchronized (this) {
            toRequest = requested;
            producer = p;
            if (subscriber != null) {
                // middle operator ... we pass through unless a request has been made
                if (toRequest == NOT_SET) {
                    // we pass through to the next producer as nothing has been requested
                    passToSubscriber = true;
                }
            }
        }
        // do after releasing lock
        if (passToSubscriber) {
            subscriber.setProducer(producer);
        } else {
            // we execute the request with whatever has been requested (or Long.MAX_VALUE)
            if (toRequest == NOT_SET) {
                producer.request(Long.MAX_VALUE);
            } else {
                producer.request(toRequest);
            }
        }
    }

这里把Producer保存到producer,这里如果requested没有设置且subscriber不为null，则递归调用subscriber的setProducer

再次进来的时候subscriber为null,由于没有设置toRequest，则请求最大数量MAX_VALUE

public void request(long n) {
            if (once) {
                return;
            }
            if (n < 0L) {
                throw new IllegalStateException("n >= required but it was " + n);
            }
            if (n == 0L) {
                return;
            }
            once = true;
            Subscriber<? super T> a = actual;
            if (a.isUnsubscribed()) {
                return;
            }
            T v = value;
            try {
                a.onNext(v);
            } catch (Throwable e) {
                Exceptions.throwOrReport(e, a, v);
                return;
            }

            if (a.isUnsubscribed()) {
                return;
            }
            a.onCompleted();
        }

请求数量如果大于0，则依次调用Subscriber的onNext和onComplete,后面的就跟上篇文章分析的一样这里的参数n只要大于0就会请求一次，具体的数值是没什么意义的。

从代码分析可以看出from传的参数不管是基本类型，还是数组，列表等，都只会调用onNext一次