Java Promise.async方法代码示例

import ratpack.exec.Promise; //导入方法依赖的package包/类
/**
 * Converts an {@link Observable} into a {@link Promise}, for all of the observable's items.
 * <p>
 * This method can be used to simply adapt an observable to a promise, but can also be used to bind an observable to the current execution.
 * It is sometimes more convenient to use {@link #promise(ObservableOnSubscribe)} over this method.
 * <p>
 * <pre class="java">{@code
 * import ratpack.rx.RxRatpack;
 * import ratpack.test.exec.ExecHarness;
 * import rx.Observable;
 * import java.util.List;
 * import java.util.Arrays;
 * import public static org.junit.Assert.assertEquals;
 * <p>
 * public class Example {
 * public static class AsyncService {
 * public <T> Observable<T> observe(final T value) {
 * return Observable.create(subscriber ->
 * new Thread(() -> {
 * subscriber.onNext(value);
 * subscriber.onCompleted();
 * }).start()
 * );
 * }
 * }
 * <p>
 * public static void main(String[] args) throws Throwable {
 * List<String> results = ExecHarness.yieldSingle(execution ->
 * RxRatpack.promise(new AsyncService().observe("foo"))
 * ).getValue();
 * <p>
 * assertEquals(Arrays.asList("foo"), results);
 * }
 * }
 * }</pre>
 * <p>
 * <p>
 * This method uses {@link Observable#toList()} to collect the observable's contents into a list.
 * It therefore should not be used with observables with many or infinite items.
 * <p>
 * If it is expected that the observable only emits one element, it is typically more convenient to use {@link #promiseSingle(Observable)}.
 * <p>
 * If the observable emits an error, the returned promise will fail with that error.
 * <p>
 * This method must be called during an execution.
 *
 * @param observable the observable
 * @param <T>        the type of the value observed
 * @return a promise that returns all values from the observable
 * @throws UnmanagedThreadException if called outside of an execution
 * @see #promiseSingle(Observable)
 */
public static <T> Promise<List<T>> promise(Observable<T> observable) throws UnmanagedThreadException {
  return Promise.async(f -> observable.toList().subscribe(f::success, f::error));
}
 

import ratpack.exec.Promise; //导入方法依赖的package包/类
/**
 * Converts an {@link Observable} into a {@link Promise}, for the observable's single item.
 * <p>
 * This method can be used to simply adapt an observable to a promise, but can also be used to bind an observable to the current execution.
 * It is sometimes more convenient to use {@link #promiseSingle(ObservableOnSubscribe)} over this method.
 * <p>
 * <pre class="java">{@code
 * import ratpack.rx.RxRatpack;
 * import ratpack.test.exec.ExecHarness;
 * import rx.Observable;
 * import public static org.junit.Assert.assertEquals;
 * <p>
 * public class Example {
 * public static class AsyncService {
 * public <T> Observable<T> observe(final T value) {
 * return Observable.create(subscriber ->
 * new Thread(() -> {
 * subscriber.onNext(value);
 * subscriber.onCompleted();
 * }).start()
 * );
 * }
 * }
 * <p>
 * public static void main(String[] args) throws Throwable {
 * String result = ExecHarness.yieldSingle(execution ->
 * RxRatpack.promiseSingle(new AsyncService().observe("foo"))
 * ).getValue();
 * <p>
 * assertEquals("foo", result);
 * }
 * }
 * }</pre>
 * <p>
 * <p>
 * This method uses {@link Observable#singleElement()} to enforce that the observable only emits one item.
 * If the observable may be empty, then use {@link Observable#single(Object)} to provide a default value.
 * <p>
 * <pre class="java">{@code
 * import ratpack.rx.RxRatpack;
 * import ratpack.test.exec.ExecHarness;
 * import rx.Observable;
 * import public static org.junit.Assert.assertEquals;
 * <p>
 * public class Example {
 * public static void main(String[] args) throws Throwable {
 * String result = ExecHarness.yieldSingle(execution ->
 * RxRatpack.promiseSingle(Observable.<String>empty().singleOrDefault("foo"))
 * ).getValue();
 * assertEquals("foo", result);
 * }
 * }
 * }</pre>
 * <p>
 * <p>
 * If it is expected that the observable may emit more than one element, use {@link #promise(Observable)}.
 * <p>
 * If the observable emits an error, the returned promise will fail with that error.
 * If the observable emits no items, the returned promise will fail with a {@link java.util.NoSuchElementException}.
 * If the observable emits more than one item, the returned promise will fail with an {@link IllegalStateException}.
 * <p>
 * This method must be called during an execution.
 *
 * @param observable the observable
 * @param <T>        the type of the value observed
 * @return a promise that returns the sole value from the observable
 * @see #promise(Observable)
 * @see #promiseSingle(ObservableOnSubscribe)
 */
public static <T> Promise<T> promiseSingle(Observable<T> observable) throws UnmanagedThreadException {
  return Promise.async(f -> observable.singleElement().subscribe(f::success, f::error));
}