类的使用
hprose.util.concurrent.Promise

使用Promise的程序包

程序包	说明
hprose.client
hprose.common
hprose.server
hprose.util.concurrent

hprose.client中Promise的使用

返回Promise的hprose.client中的方法

限定符和类型	方法和说明
protected Promise<ByteBuffer>	HproseClient.afterFilterHandler(ByteBuffer request, HproseContext context)
protected Promise<ByteBuffer>	HproseClient.beforeFilterHandler(ByteBuffer request, HproseContext context)
protected Promise<Object>	HproseClient.invokeHandler(String name, Object[] args, HproseContext context)
protected Promise<ByteBuffer>	HproseTcpClient.sendAndReceive(ByteBuffer request, ClientContext context)
protected abstract Promise<ByteBuffer>	HproseClient.sendAndReceive(ByteBuffer request, ClientContext context)
protected Promise<ByteBuffer>	HproseHttpClient.sendAndReceive(ByteBuffer request, ClientContext context)

hprose.common中Promise的使用

返回Promise的hprose.common中的方法

限定符和类型	方法和说明
protected abstract Promise<ByteBuffer>	HandlerManager.afterFilterHandler(ByteBuffer request, HproseContext context)
protected abstract Promise<ByteBuffer>	HandlerManager.beforeFilterHandler(ByteBuffer request, HproseContext context)
Promise<ByteBuffer>	NextFilterHandler.handle(ByteBuffer request, HproseContext context)
Promise<ByteBuffer>	FilterHandler.handle(ByteBuffer request, HproseContext context, NextFilterHandler next)
Promise<Object>	NextInvokeHandler.handle(String name, Object[] args, HproseContext context)
Promise<Object>	InvokeHandler.handle(String name, Object[] args, HproseContext context, NextInvokeHandler next)
protected abstract Promise<Object>	HandlerManager.invokeHandler(String name, Object[] args, HproseContext context)

hprose.server中Promise的使用

返回Promise的hprose.server中的方法

限定符和类型	方法和说明
protected Promise<ByteBuffer>	HproseService.afterFilterHandler(ByteBuffer request, HproseContext context)
protected Promise<ByteBuffer>	HproseService.beforeFilterHandler(ByteBuffer request, HproseContext context)
protected Promise<ByteBuffer>	HproseService.doInvoke(ByteBufferStream stream, ServiceContext context)
protected Promise<ByteBuffer>	HproseService.handle(ByteBuffer buffer, HproseMethods methods, ServiceContext context)
protected Promise<ByteBuffer>	HproseService.handle(ByteBuffer buffer, ServiceContext context)
protected Promise<Object>	HproseService.invokeHandler(String name, Object[] args, HproseContext context)
Promise<String[]>	HproseService.push(String topic, Object result)
Promise<String[]>	HproseClients.push(String topic, Object result)
Promise<String[]>	HproseService.push(String topic, String[] ids, Object result)
Promise<String[]>	HproseClients.push(String topic, String[] ids, Object result)
Promise<Boolean>	HproseService.push(String topic, String id, Object result)
Promise<Boolean>	HproseClients.push(String topic, String id, Object result)

hprose.util.concurrent中Promise的使用

返回Promise的hprose.util.concurrent中的方法

限定符和类型	方法和说明
Promise<Object[]>	Promise.all()
<T> Promise<T[]>	Promise.all(Class<T> type)
static Promise<Object[]>	Promise.all(Object[] array)
static <T> Promise<T[]>	Promise.all(Object[] array, Class<T> type)
static Promise<Object[]>	Promise.all(Promise<Object[]> promise)
static <T> Promise<T[]>	Promise.all(Promise<Object[]> promise, Class<T> type)
Promise<?>	Promise.any()
<T> Promise<T>	Promise.any(Class<T> type)
static Promise<?>	Promise.any(Object[] array)
static <T> Promise<T>	Promise.any(Object[] array, Class<T> type)
static Promise<?>	Promise.any(Promise<Object[]> promise)
static <T> Promise<T>	Promise.any(Promise<Object[]> promise, Class<T> type)
Promise<T>	AsyncCall.call()
Promise<R>	AsyncFunc.call(V value)
Promise<?>	Promise.catchError(Action<Throwable> onreject)
Promise<?>	Promise.catchError(Action<Throwable> onreject, AsyncFunc<Boolean,Throwable> test)
Promise<?>	Promise.catchError(Action<Throwable> onreject, Func<Boolean,Throwable> test)
<R> Promise<R>	Promise.catchError(AsyncFunc<R,Throwable> onreject)
<R> Promise<R>	Promise.catchError(AsyncFunc<R,Throwable> onreject, AsyncFunc<Boolean,Throwable> test)
<R> Promise<R>	Promise.catchError(AsyncFunc<R,Throwable> onreject, Func<Boolean,Throwable> test)
<R> Promise<R>	Promise.catchError(Func<R,Throwable> onreject)
<R> Promise<R>	Promise.catchError(Func<R,Throwable> onreject, AsyncFunc<Boolean,Throwable> test)
<R> Promise<R>	Promise.catchError(Func<R,Throwable> onreject, Func<Boolean,Throwable> test)
Promise<?>	Promise.complete(Action<?> oncomplete)
<R> Promise<R>	Promise.complete(AsyncFunc<R,?> oncomplete)
<R> Promise<R>	Promise.complete(Func<R,?> oncomplete)
Promise<V>	Promise.delay(long duration)
Promise<V>	Promise.delay(long duration, TimeUnit timeunit)
static <T> Promise<T>	Promise.delayed(long duration, AsyncCall<T> computation)
static <T> Promise<T>	Promise.delayed(long duration, Call<T> computation)
static <T> Promise<T>	Promise.delayed(long duration, Promise<T> value)
static <T> Promise<T>	Promise.delayed(long duration, T value)
static <T> Promise<T>	Promise.delayed(long duration, TimeUnit timeunit, AsyncCall<T> computation)
static <T> Promise<T>	Promise.delayed(long duration, TimeUnit timeunit, Call<T> computation)
static <T> Promise<T>	Promise.delayed(long duration, TimeUnit timeunit, Promise<T> value)
static <T> Promise<T>	Promise.delayed(long duration, TimeUnit timeunit, T value)
static <T> Promise<T>	Promise.error(Throwable reason)
static <V> Promise<Boolean>	Promise.every(Func<Boolean,V> callback, Object... args)
<V> Promise<Boolean>	Promise.every(Handler<Boolean,V> callback)
static <V> Promise<Boolean>	Promise.every(Object[] array, Handler<Boolean,V> callback)
static <V> Promise<Boolean>	Promise.every(Promise<Object[]> array, Handler<Boolean,V> callback)
static <V> Promise<Object[]>	Promise.filter(Func<Boolean,V> callback, Object... args)
<V> Promise<Object[]>	Promise.filter(Handler<Boolean,V> callback)
<V,T> Promise<T[]>	Promise.filter(Handler<Boolean,V> callback, Class<T> type)
static <V> Promise<Object[]>	Promise.filter(Object[] array, Handler<Boolean,V> callback)
static <V,T> Promise<T[]>	Promise.filter(Object[] array, Handler<Boolean,V> callback, Class<T> type)
static <V> Promise<Object[]>	Promise.filter(Promise<Object[]> array, Handler<Boolean,V> callback)
static <V,T> Promise<T[]>	Promise.filter(Promise<Object[]> array, Handler<Boolean,V> callback, Class<T> type)
static <V> Promise<?>	Promise.forEach(Action<V> callback, Object... args)
Promise<?>	Promise.forEach(Handler<?,V> callback)
static <V> Promise<?>	Promise.forEach(Object[] array, Handler<?,V> callback)
static <V> Promise<?>	Promise.forEach(Promise<Object[]> array, Handler<?,V> callback)
static Promise<Object[]>	Promise.join(Object... args)
static <V> Promise<Object[]>	Promise.map(Func<?,V> callback, Object... args)
<V> Promise<Object[]>	Promise.map(Handler<?,V> callback)
<V,T> Promise<T[]>	Promise.map(Handler<T,V> callback, Class<T> type)
static <V> Promise<Object[]>	Promise.map(Object[] array, Handler<?,V> callback)
static <V,T> Promise<T[]>	Promise.map(Object[] array, Handler<T,V> callback, Class<T> type)
static <V> Promise<Object[]>	Promise.map(Promise<Object[]> array, Handler<?,V> callback)
static <V,T> Promise<T[]>	Promise.map(Promise<Object[]> array, Handler<T,V> callback, Class<T> type)
Promise<?>	Promise.race()
<T> Promise<T>	Promise.race(Class<T> type)
static Promise<?>	Promise.race(Object[] array)
static <T> Promise<T>	Promise.race(Object[] array, Class<T> type)
static Promise<?>	Promise.race(Promise<Object[]> promise)
static <T> Promise<T>	Promise.race(Promise<Object[]> promise, Class<T> type)
static <R,V> Promise<R>	Promise.reduce(Object[] array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	Promise.reduce(Object[] array, Reducer<V,V> callback)
static <R,V> Promise<R>	Promise.reduce(Promise<Object[]> array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	Promise.reduce(Promise<Object[]> array, Reducer<V,V> callback)
<R,V> Promise<R>	Promise.reduce(Reducer<R,V> callback, R initialValue)
<V> Promise<V>	Promise.reduce(Reducer<V,V> callback)
static <R,V> Promise<R>	Promise.reduceRight(Object[] array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	Promise.reduceRight(Object[] array, Reducer<V,V> callback)
static <R,V> Promise<R>	Promise.reduceRight(Promise<Object[]> array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	Promise.reduceRight(Promise<Object[]> array, Reducer<V,V> callback)
<R,V> Promise<R>	Promise.reduceRight(Reducer<R,V> callback, R initialValue)
<V> Promise<V>	Promise.reduceRight(Reducer<V,V> callback)
static Promise<?>	Promise.run(Action<Object[]> handler, Object... args)
static <V> Promise<V>	Promise.run(AsyncFunc<V,Object[]> handler, Object... args)
static <T> Promise<?>	Promise.run(Class<T> type, Action<T[]> handler, Object... args)
static <V,T> Promise<V>	Promise.run(Class<T> type, AsyncFunc<V,T[]> handler, Object... args)
static <V,T> Promise<V>	Promise.run(Class<T> type, Func<V,T[]> handler, Object... args)
static <V> Promise<V>	Promise.run(Func<V,Object[]> handler, Object... args)
static <V> Promise<Boolean>	Promise.some(Func<Boolean,V> callback, Object... args)
<V> Promise<Boolean>	Promise.some(Handler<Boolean,V> callback)
static <V> Promise<Boolean>	Promise.some(Object[] array, Handler<Boolean,V> callback)
static <V> Promise<Boolean>	Promise.some(Promise<Object[]> array, Handler<Boolean,V> callback)
static <T> Promise<T>	Promise.sync(AsyncCall<T> computation)
static <T> Promise<T>	Promise.sync(Call<T> computation)
Promise<V>	Promise.tap(Action<V> onfulfilledSideEffect)
Promise<?>	Promise.then(Action<V> onfulfill)
Promise<?>	Thenable.then(Action<V> onfulfill, Action<Throwable> onreject)
Promise<?>	Promise.then(Action<V> onfulfill, Action<Throwable> onreject)
<R> Promise<R>	Promise.then(AsyncFunc<R,V> onfulfill)
<R> Promise<R>	Thenable.then(AsyncFunc<R,V> onfulfill, AsyncFunc<R,Throwable> onreject)
<R> Promise<R>	Promise.then(AsyncFunc<R,V> onfulfill, AsyncFunc<R,Throwable> onreject)
<R> Promise<R>	Thenable.then(AsyncFunc<R,V> onfulfill, Func<R,Throwable> onreject)
<R> Promise<R>	Promise.then(AsyncFunc<R,V> onfulfill, Func<R,Throwable> onreject)
<R> Promise<R>	Promise.then(Func<R,V> onfulfill)
<R> Promise<R>	Thenable.then(Func<R,V> onfulfill, AsyncFunc<R,Throwable> onreject)
<R> Promise<R>	Promise.then(Func<R,V> onfulfill, AsyncFunc<R,Throwable> onreject)
<R> Promise<R>	Thenable.then(Func<R,V> onfulfill, Func<R,Throwable> onreject)
<R> Promise<R>	Promise.then(Func<R,V> onfulfill, Func<R,Throwable> onreject)
Promise<V>	Promise.timeout(long duration)
Promise<V>	Promise.timeout(long duration, Throwable reason)
Promise<V>	Promise.timeout(long duration, TimeUnit timeunit, Throwable reason)
static Promise<?>	Promise.toPromise(Object value)
static <T> Promise<T>	Promise.value(Promise<T> value)
static <T> Promise<T>	Promise.value(T value)
static <T> Promise<T>	Promise.value(Thenable<T> value)
Promise<V>	Promise.whenComplete(Action<?> action)
Promise<V>	Promise.whenComplete(Runnable action)

参数类型为Promise的hprose.util.concurrent中的方法

限定符和类型	方法和说明
static Promise<Object[]>	Promise.all(Promise<Object[]> promise)
static <T> Promise<T[]>	Promise.all(Promise<Object[]> promise, Class<T> type)
static Promise<?>	Promise.any(Promise<Object[]> promise)
static <T> Promise<T>	Promise.any(Promise<Object[]> promise, Class<T> type)
static <T> Promise<T>	Promise.delayed(long duration, Promise<T> value)
static <T> Promise<T>	Promise.delayed(long duration, TimeUnit timeunit, Promise<T> value)
static <V> Promise<Boolean>	Promise.every(Promise<Object[]> array, Handler<Boolean,V> callback)
void	Promise.fill(Promise<V> promise)
static <V> Promise<Object[]>	Promise.filter(Promise<Object[]> array, Handler<Boolean,V> callback)
static <V,T> Promise<T[]>	Promise.filter(Promise<Object[]> array, Handler<Boolean,V> callback, Class<T> type)
static <V> Promise<?>	Promise.forEach(Promise<Object[]> array, Handler<?,V> callback)
static <V> Promise<Object[]>	Promise.map(Promise<Object[]> array, Handler<?,V> callback)
static <V,T> Promise<T[]>	Promise.map(Promise<Object[]> array, Handler<T,V> callback, Class<T> type)
static Promise<?>	Promise.race(Promise<Object[]> promise)
static <T> Promise<T>	Promise.race(Promise<Object[]> promise, Class<T> type)
static <R,V> Promise<R>	Promise.reduce(Promise<Object[]> array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	Promise.reduce(Promise<Object[]> array, Reducer<V,V> callback)
static <R,V> Promise<R>	Promise.reduceRight(Promise<Object[]> array, Reducer<R,V> callback, R initialValue)
static <V> Promise<V>	Promise.reduceRight(Promise<Object[]> array, Reducer<V,V> callback)
void	Resolver.resolve(Promise<V> value)
void	Promise.resolve(Promise<V> value)
static <V> Promise<Boolean>	Promise.some(Promise<Object[]> array, Handler<Boolean,V> callback)
static <T> Promise<T>	Promise.value(Promise<T> value)

参数类型为Promise的hprose.util.concurrent中的构造器

构造器和说明
PromiseFuture(Promise<V> promise)