1.直到有观察者订阅时才创建Observable，并且为每个观察者创建一个全新的Observable

defer操作符会一直等待直到有观察者订阅它，然后它使用Observable工厂方法生成一个Observable。它对每个观察者都这样做，因此尽管每个订阅者都以为自己订阅的是同一个Observable，但事实上每个订阅者获取的是它们自己单独的数据序列。

在某些情况下，直到最后一分钟（订阅发生时）才生产Observable，以确保Observable包含最新的数据。

        Observable observable = Observable.defer(new Callable<ObservableSource<? extends String>>() {
            @Override
            public ObservableSource<? extends String> call() throws Exception {
                return Observable.just("hello defer1", "hello defer2", "haha", "nihao", "xixi", "hehe");
            }
        });
        observable.subscribe(new Consumer<String>() {
            @Override
            public void accept(String str) throws Exception {
                System.out.println(str);
            }
        });

2.底层源码分析

首先调用Observable的静态方法defer()方法，即：

    /**
    通过工厂方法为每个观察者创建一个ObservableSource对象，并返回个Observable。
    
     * Returns an Observable that calls an ObservableSource factory to create an ObservableSource for each new Observer
     * that subscribes. That is, for each subscriber, the actual ObservableSource that subscriber observes is
     * determined by the factory function.
     * @param supplier
     *            the ObservableSource factory function to invoke for each {@link Observer} that subscribes to the
     *            resulting ObservableSource
     * @param <T>
     *            the type of the items emitted by the ObservableSource
     * @return an Observable whose {@link Observer}s'' subscriptions trigger an invocation of the given
     *         ObservableSource factory function
     */
     
    @CheckReturnValue
    @SchedulerSupport(SchedulerSupport.NONE)
    public static <T> Observable<T> defer(Callable<? extends ObservableSource<? extends T>> supplier) {
        ObjectHelper.requireNonNull(supplier, "supplier is null");
        return RxJavaPlugins.onAssembly(new ObservableDefer<T>(supplier));
    }

其后创建ObservableDefer对象，并进行赋值

该类只有一个重写方法，即subscribeActual方法，即：

public final class ObservableDefer<T> extends Observable<T> {
    final Callable<? extends ObservableSource<? extends T>> supplier;
    public ObservableDefer(Callable<? extends ObservableSource<? extends T>> supplier) {
        this.supplier = supplier;
    }
    
    //该方法是RxJava中调用的核心，几乎每个类都会重写该方法！！
    @Override
    public void subscribeActual(Observer<? super T> s) {
        ObservableSource<? extends T> pub;
        try {
            pub = ObjectHelper.requireNonNull(supplier.call(), "null publisher supplied");
        } catch (Throwable t) {
            Exceptions.throwIfFatal(t);
            EmptyDisposable.error(t, s);
            return;
        }

        pub.subscribe(s);
    }
}

之后observable通过subscribe()方法调用ObservableDefer类中的subscribeActual方法，从而实现调用用户自定义的方法，Observable.just()方法，实现调用，即：pub = ObjectHelper.requireNonNull(supplier.call(), "null publisher supplied");，即可实现defer()方法的功能。