jdeferred下载 - jdeferred源码下载

JDeferred 2.x

JDeferred 是一个 Java Deferred/Promise 库，类似于 JQuery 的 Deferred Object。

受到 JQuery 和 Android 延迟对象的启发。

如果您使用 JDeferred 1.x，请参阅 JDeferred 1.x 文档

特征

延迟对象和 Promise
承诺回调
- .then(…)
- .filter(…)
- .pipe(…)
- .done(…)
- .fail(…)
- .progress(…)
- .always(…)
- .pipeAlways(…)
多重承诺
- .when(p1, p2, p3, …).then(…)
- .race(p1, p2, p3, …).then(…)
- .settle(p1, p2, p3, …).then(…)
可调用和可运行包装器
- .when(new Runnable() {…})
- .race(new Runnable() {…})
- .settle(new Runnable() {…})
使用执行者服务
Java 泛型支持
- Deferred<Integer, Exception, Double> deferred;
- deferred.resolve(10);
- deferred.reject(new Exception());
- deferred.notify(0.80);
安卓支持
Java 8 Lambda 友好
是的，它位于 Maven 中央存储库上！

梅文

< dependency >
    < groupId >org.jdeferred.v2</ groupId >
    < artifactId >jdeferred-core</ artifactId >
    < version >${version}</ version >
</ dependency >

摇篮

 compile 'org.jdeferred.v2:jdeferred-core:${version}'

在 Maven 中央存储库上查找可用版本。

兼容性

版本之间的兼容性报告：

1.2.6 至 2.0.0

简单示例

延迟对象和 Promise

 Deferred deferred = new DeferredObject ();
Promise promise = deferred . promise ();
promise . done ( new DoneCallback () {
  public void onDone ( Object result ) {
    ...
  }
}). fail ( new FailCallback () {
  public void onFail ( Object rejection ) {
    ...
  }
}). progress ( new ProgressCallback () {
  public void onProgress ( Object progress ) {
    ...
  }
}). always ( new AlwaysCallback () {
  public void onAlways ( State state , Object result , Object rejection ) {
    ...
  }
});

通过引用延迟对象，您可以触发操作/更新：

 deferred . resolve ( "done" );
deferred . reject ( "oops" );
deferred . notify ( "100%" );

筛选

从 2.0.0-Beta2 开始使用.filter(...)代替.then(...)

 Deferred d = …;
Promise p = d . promise ();
Promise filtered = p . filter ( new DoneFilter < Integer , Integer >() {
  public Integer filterDone ( Integer result )
    return result * 10 ;
  }
});

filtered . done ( new DoneCallback < Integer >() {
  public void onDone ( Integer result ) {
    // result would be original * 10
    System . out . println ( result );
  }
});

d . resolve ( 3 ) -> 30.

管道

从 2.0.0-Beta2 开始使用.pipe(...)代替.then(...)

 Deferred d = ...;
Promise p = d . promise ();

p . pipe ( new DonePipe < Integer , Integer , Exception , Void >() {
  public Deferred < Integer , Exception , Void > pipeDone ( Integer result ) {
    if ( result < 100 ) {
      return new DeferredObject < Integer , Void , Void >(). resolve ( result );
    } else {
      return new DeferredObject < Integer , Void , Void >(). reject ( new Exception (...));
    }
  }
}). done (...). fail (...);

d . resolve ( 80 ) -> done !
d . resolve ( 100 ) -> fail !

延期经理

 DeferredManager dm = new DefaultDeferredManager ();
Promise p1 , p2 , p3 ;
// initialize p1, p2, p3
dm . when ( p1 , p2 , p3 )
  . done (…)
  . fail (…)

您还可以根据需要指定执行程序服务。

 DeferredManager dm = new DefaultDeferredManager(myExecutorService);

可运行和可调用

您几乎可以像使用 Promise 一样使用 Callable 和 Runnable，而无需任何额外的工作。

 DeferredManager dm = new DefaultDeferredManager ();
dm . when ( new Callable < Integer >(){
  public Integer call () {
    // return something
    // or throw a new exception
  }
}). done ( new DoneCallback < Integer >() {
  public void onDone ( Integer result ) {
    ...
  }
}). fail ( new FailCallback < Throwable >() {
  public void onFail ( Throwable e ) {
    ...
  }
});

如果您需要在 Callable 或 Runnable 中通知进度，则需要创建自己的 Deferred 对象和 Promise，或者可以使用 DeferredCallable 和 DeferredRunnable。

使用您自己的延迟对象

 final Deferred deferred = ...
Promise promise = deferred . promise ();
promise . then (…);
Runnable r = new Runnable () {
  public void run () {
    while (…) {
      deferred . notify ( myProgress );
    }
    deferred . resolve ( "done" );
  }
}

或者，扩展 DeferredRunnable

 DeferredManager dm = …;
dm . when ( new DeferredRunnable < Double >(){
  public void run () {
    while (…) {
      notify ( myProgress );
    }
  }
}). then (…);

等待并安全等待

从1.0.1开始

通常，在使用此框架时，您会希望异步执行操作。但是，如果需要等待所有延迟任务完成，可以使用 Object.wait 或 Promise.waitSafely 方法。

 Promise p = dm . when (...)
  . done (...)
  . fail (...)

synchronized ( p )
  while ( p . isPending ()) {
    try {
      p . wait ();
    } catch ( InterruptedException e ) { ... }
  }
}

或者，您可以使用更简化的快捷方式

 Promise p = dm . when (...)
  . done (...)
  . fail (...)

try {
  p . waitSafely ();
} catch ( InterruptedException e ) {
  ... 
}

Java 8 拉姆达

现在，当与 Java 8 Lambda 一起使用时，这非常酷！

 dm . when (() -> {
  return "Hey!" ;
}). done ( r -> System . out . println ( r ));

dm . when (
  () -> { return "Hello" ; },
  () -> { return "World" ; }
). done ( rs ->
  rs . forEach ( r -> System . out . println ( r . getResult ()))
);

什么时候

使用多个参数调用when会导致Promise信号在第一次拒绝时fail ，或者信号done所有计算值。

成功场景

 Callable < Integer > c1 = () -> 1 ;
Callable < Integer > c2 = () -> 2 ;
Callable < Integer > c3 = () -> 3 ;
Promise < MultipleResults3 < Integer , Integer , Integer >, OneReject < Throwable >, MasterProgress > p = dm . when ( c1 , c2 , c3 );
p . done ( MultipleResults3 < Integer , Integer , Integer > r -> {
  Assert . assertEquals ( r . getFirst (), 1 );
  Assert . assertEquals ( r . getSecond (), 2 );
  Assert . assertEquals ( r . getThird (), 3 );
});

故障场景

 Callable < Integer > c1 = () -> 1 ;
Callable < Integer > c2 = () -> 2 ;
Callable < Integer > c3 = () -> throw new RuntimeException ( "boom!" );
Promise < MultipleResults3 < Integer , Integer , Integer >, OneReject < Throwable >, MasterProgress > p = dm . when ( c1 , c2 , c3 );
p . done ( MultipleResults3 < Integer , Integer , Integer > r -> Assert . fail ( "should not be called" ))
 . fail ( OneReject < Throwable > r -> Assert . assertEquals ( r . getReject (). getMessage (), "boom!" ));

从2.0.0开始

调用带有多个参数（最多五个）的when将产生具有类型安全 getter 的结果。

种族

从2.0.0开始

调用具有多个参数的race会导致Promise信号在第一次拒绝时fail或信号在第一次解决时done 。

成功场景

 Callable < Integer > c1 = () -> { Thread . sleep ( 200 ); return 1 ; };
Callable < Integer > c2 = () -> { Thread . sleep ( 100 ); return 2 ; };
Callable < Integer > c3 = () -> { Thread . sleep ( 200 ); return 3 ; };
Promise < OneResult <?>, OneReject < Throwable >, Void > p = dm . race ( c1 , c2 , c3 );
p . done ( OneResult <?> r -> Assert . assertEquals ( r . getResult (), 2 ));

故障场景

 Callable < Integer > c1 = () -> { Thread . sleep ( 200 ); return 1 ; };
Callable < Integer > c2 = () -> { Thread . sleep ( 100 ); throw new RuntimeException ( "boom!" ); };
Callable < Integer > c3 = () -> { Thread . sleep ( 200 ); return 3 ; };
Promise < OneResult <?>, OneReject < Throwable >, Void > p = dm . race ( c1 , c2 , c3 );
p . done ( OneResult <?> r -> Assert . fail ( "should not be called" )
  . fail ( OneReject < Throwable > r -> Assert . assertEquals ( r . getReject (). getMessage (), "boom!" ));

定居

从2.0.0开始

调用多个参数来settle会产生一个收集所有解决方案和拒绝的Promise 。

 Callable < Integer > c1 = () -> { Thread . sleep ( 200 ); return 1 ; };
Callable < Integer > c2 = () -> { Thread . sleep ( 100 ); throw new RuntimeException ( "boom!" ); };
Callable < Integer > c3 = () -> { Thread . sleep ( 200 ); return 3 ; };
Promise < AllValues , Throwable , MasterProgress >, Void > p = dm . race ( c1 , c2 , c3 );
p . done ( AllValues r -> {
  Assert . assertEquals ( r . get ( 0 ). getValue (), 1 );
  Assert . assertTrue ( r . get ( 1 ). getValue () instanceof RuntimeException );
  Assert . assertEquals ( r . get ( 2 ). getValue (), 3 );
});

取消处理程序

从2.0.0开始

有时，任务可能在运行时被取消，并且需要清理它可能分配的任何资源。您可以定义一个实现org.jdeferred2.CancellationHandler接口的任务，或者通过这样的实现将额外的参数传递给DeferredFutureTask ，例如

 final DataSource datasource = ...;
class DatabaseTask extends Runnable , CancellationHandler {
  @ Override
  public void run () {
    // perform computation with datasource
  }

  @ Override
  public void onCancel () {
    try {
      datasource . close ();
    } catch ( Exception e ) {
      throw new IllegalStateException ( e );
    }
  }
}

DeferredFutureTask < X > task = new DeferredFutureTask ( new DatabaseTask ());
dm . when ( task ). done (...)

您还可以将CancellationHandler作为附加参数传递，例如

 final DataSource datasource = ...;
class DatabaseTask extends Runnable {
  @ Override
  public void run () {
    // perform computation with datasource
  }
}

class DatabaseCancellationHandler implements CancellationHandler {
  @ Override
  public void onCancel () {
    try {
      datasource . close ();
    } catch ( Exception e ) {
      throw new IllegalStateException ( e );
    }
  }
}

DeferredFutureTask < X > task = new DeferredFutureTask ( new DatabaseTask (), new DatabaseCancellationHandler ());
dm . when ( task ). done (...)

格罗维

您还可以轻松地与 Groovy 一起使用！

 @Grab ( ' org.jdeferred.v2:jdeferred-core:2.0.0 ' )
import org.jdeferred2.*
import org.jdeferred2.impl.*

def deferred = new DeferredObject ()
def promise = deferred . promise()

promise . done { result ->
  println " done: $r esult " 
} . fail { rejection ->
  println " fail: $r ejection "
} . always { state , result , rejection ->
  println " always "
}

deferred . resolve( " done " )

安卓支持

自 1.1.0-Beta1 起

jdeferred-android现已推出，并且可以像任何其他 Android 库一样包含它！它还使用 Android Maven 插件并构建 apklib 文件。如果您使用 Android Maven 插件，则可以包含依赖项：

APKLIB 与 Maven：

< dependency >
  < groupId >org.jdeferred.v2</ groupId >
  < artifactId >jdeferred-android</ artifactId >
  < version >${version}</ version >
  < type >apklib</ type >
</ dependency >

AAR 与 Maven：

自 1.2.0-Beta1 起

< dependency >
  < groupId >org.jdeferred.v2</ groupId >
  < artifactId >jdeferred-android-aar</ artifactId >
  < version >${version}</ version >
  < type >aar</ type >
</ dependency >

AAR 与 Gradle：

 compile 'org.jdeferred.v2:jdeferred-android-aar:${version}'
// or
compile 'org.jdeferred.v2:jdeferred-android-aar:${version}@aar'

在 Maven 中央存储库上查找可用版本。

jdeferred-android引入了一个新的DeferredManager实现，称为AndroidDeferredManager 。 AndroidDeferredManager确保回调在 UI 线程而不是后台线程中执行，以便回调进行 UI 更新。或者，回调还可以实现AndroidExecutionScopeable接口，以细粒度控制回调是否应在 UI 线程或后台线程中执行。

AndroidDeferredManager还支持新的DeferredAsyncTask对象。该对象基于 Android 的AsyncTask 。

如果您需要始终在后台线程中执行回调，那么您可以继续使用DefaultDeferredManager 。

最后，因为 JDeferred 使用 SLF4J - 您可以使用slf4j-android进一步路由日志消息。

异步Servlet

以下是有关如何将 JDeferred 与异步 Servlet 结合使用的示例代码！

 @ WebServlet ( value = "/AsyncServlet" , asyncSupported = true )
public class AsyncServlet extends HttpServlet {
  private static final long serialVersionUID = 1L ;
  private ExecutorService executorService = Executors . newCachedThreadPool ();
  private DeferredManager dm = new DefaultDeferredManager ( executorService );

  protected void doGet ( HttpServletRequest request ,
                       HttpServletResponse response ) throws ServletException , IOException {
    final AsyncContext actx = request . startAsync ( request , response );
    
    dm . when ( new Callable < String >() {
      @ Override
      public String call () throws Exception {
        if ( actx . getRequest (). getParameter ( "fail" ) != null ) {
          throw new Exception ( "oops!" );
        }
        Thread . sleep ( 2000 );
        return "Hello World!" ;
      }
    }). then ( new DoneCallback < String >() {
      @ Override
      public void onDone ( String result ) {
        actx . getRequest (). setAttribute ( "message" , result );
        actx . dispatch ( "/hello.jsp" );
      }
    }). fail ( new FailCallback < Throwable >() {
      @ Override
      public void onFail ( Throwable exception ) {
        actx . getRequest (). setAttribute ( "exception" , exception );
        actx . dispatch ( "/error.jsp" );
      }
    });
  }
}

弃用

v1.2.5

~~DeferredManager.StartPolicy.MANAUL~~已弃用并将在下一个小版本中删除。请改用DeferredManager.StartPolicy.MANUAL 。

展开