just操作符

just操作符

1. 作用

将参数转为Observable对象，并将参数逐个发送出来。其订阅过程与create一样，均是在执行subscribe(observer)时产生时间。

2. 用法

Observalbe<Integer> observable = Observable.just(1, 2, 3, 4); 

    observalbe.subscribe(new Observer<Integer>(){
            @Override
            public void onCompleted() {
                System.out.println("Complete");
            }

            @Override
            public void onError(Throwable e) {
                System.out.println("e = [" + e + "]");
            }

            @Override
            public void onNext(Integer s) {
                System.out.println("s = [" + s + "sss" + "]");
            }
    });

3. 事件流分析

public final static <T> Observable<T> just(T t1, T t2, T t3, T t4) {
        return from(Arrays.asList(t1, t2, t3, t4));
    }//just方法

    public final static <T> Observable<T> from(Iterable<? extends T> iterable) {
        return create(new OnSubscribeFromIterable<T>(iterable)); //创建Obsubscribe对象。在此进行说明：Rx中所有的Observable事件均由ObSubscribe对象执行。
    }

至此，Observalbe对象创建完毕，just与create操作符的唯一不同点就是上面的OnSubscribeFromIterable，其订阅过程及call方法的回调均与create操作符一样，下面我们来看一下OnSubscribeFromIterable与OnSubscribe的不同点。

    //OnSubscribeFromIterable的call方法。
    @Override
    public void call(final Subscriber<? super T> o) {
        final Iterator<? extends T> it = is.iterator();
        if (!it.hasNext() && !o.isUnsubscribed())
            o.onCompleted();
        else 
            o.setProducer(new IterableProducer<T>(o, it)); //给observer设置producer; 
    }

    //observer的setProducer(producer)方法，**注意1**
    public void setProducer(Producer p) {
        //在此之前，判断该Observer是够已经设置producer（该代码块在synchronized中执行）
        // do after releasing lock

            if (toRequest == NOT_SET) {
                producer.request(Long.MAX_VALUE); //执行request方法
            } else {
                producer.request(toRequest);
            }
        }
    }

    private static final class IterableProducer<T> extends AtomicLong implements Producer {
        /** */
        private static final long serialVersionUID = -8730475647105475802L;
        private final Subscriber<? super T> o;
        private final Iterator<? extends T> it;

        private IterableProducer(Subscriber<? super T> o, Iterator<? extends T> it) {
            this.o = o;
            this.it = it;
        }

        @Override
        public void request(long n) { //遍历数据源，发送给observer
            if (get() == Long.MAX_VALUE) {
                // already started with fast-path
                return;
            }
            if (n == Long.MAX_VALUE && compareAndSet(0, Long.MAX_VALUE)) {
                fastpath();
            } else 
            if (n > 0 && BackpressureUtils.getAndAddRequest(this, n) == 0L) {
                slowpath(n);
            }

        }
    }

请注意上面的setProducer方法，当使用默认构造函数时，其成员subscriber为空。也就是说，当observer调用setPresenter时就开始执行迭代。其完整版如下：

    public void setProducer(Producer p) {
        long toRequest;
        boolean passToSubscriber = false;
        synchronized (this) {
            toRequest = requested;
            producer = p;
            if (subscriber != null) {//该subscriber不是当前的subscriber，当且仅当当前的subscriber没有使用默认构造函数时不为空
                // middle operator ... we pass thru unless a request has been made
                if (toRequest == NOT_SET) {
                    // we pass-thru 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);
            }
        }
    }

总结

1. 使用just时，Observable会将参数包装成Iterable，当subscriber订阅Observable时，开始回调onSubscribeFromIterable的call方法，在call方法中调用了当前subscriber的setPresenter方法，至此开始迭代just中的参数。
2. 如果当前Observer使用Action1或Observer，则首先会将Action1保障为Subscriber。