jdeferred

JDiferido 2.x

JDeferred es una biblioteca Java Deferred/Promise similar al objeto diferido de JQuery.

Inspirado en JQuery y Android Deferred Object.

Si está utilizando JDeferred 1.x, consulte la documentación de JDeferred 1.x.

Características

• Objeto diferido y Promesa
• Devoluciones de llamada de promesa
  • .then(…)
  • .filter(…)
  • .pipe(…)
  • .done(…)
  • .fail(…)
  • .progress(…)
  • .always(…)
  • .pipeAlways(…)
• Múltiples promesas
  • .when(p1, p2, p3, …).then(…)
  • .race(p1, p2, p3, …).then(…)
  • .settle(p1, p2, p3, …).then(…)
• Envoltorios invocables y ejecutables
  • .when(new Runnable() {…})
  • .race(new Runnable() {…})
  • .settle(new Runnable() {…})
• Utiliza el servicio ejecutor
• Soporte de genéricos de Java
  • Deferred<Integer, Exception, Double> deferred;
  • deferred.resolve(10);
  • deferred.reject(new Exception());
  • deferred.notify(0.80);
• Soporte Android
• Compatible con Java 8 Lambda
• ¡Sí, está en el repositorio central de Maven!

experto

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

Gradle

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

Encuentre versiones disponibles en el repositorio central de Maven.

Compatibilidad

Informes de compatibilidad entre versiones:

• 1.2.6 a 2.0.0

Ejemplos rápidos

Objeto diferido y Promesa

 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 ) {
    ...
  }
});

Con la referencia al objeto diferido, puede activar acciones/actualizaciones:

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

Filtrar

Utilice .filter(...) en lugar de .then(...) desde 2.0.0-Beta2

 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. 

Tubo

Utilice .pipe(...) en lugar de .then(...) desde 2.0.0-Beta2

 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 !

Gerente diferido

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

También puede especificar un Servicio Ejecutor para su necesidad.

 DeferredManager dm = new DefaultDeferredManager(myExecutorService);

Ejecutable y invocable

Puede utilizar Callable y Runnable casi como una Promesa sin ningún trabajo adicional.

 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 ) {
    ...
  }
});

Si necesita notificar el progreso dentro de su Callable o Runnable, debe crear su propio objeto Deferred y Promise, o puede usar DeferredCallable y DeferredRunnable.

Utilice su propio objeto diferido

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

O extendiendo DeferredRunnable

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

Espere y espere con seguridad

Desde 1.0.1

Normalmente, al utilizar este marco, querrás hacer las cosas de forma asincrónica. Sin embargo, si es necesario esperar a que finalicen todas las tareas aplazadas, puede utilizar los métodos Object.wait o Promise.waitSafely.

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

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

Alternativamente, puedes usar un atajo más simplificado.

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

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

Java 8 Lambda

¡Esto es genial cuando se usa con 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 ()))
);

Cuando

Las llamadas a when con múltiples argumentos dan como resultado una Promise de que las señales fail en el primer rechazo o las señales done con todos los valores calculados.

Escenario de éxito

 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 );
});

Escenario de fracaso

 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!" ));

Desde 2.0.0

Las llamadas a when con múltiples argumentos (hasta cinco) producirán resultados con captadores de tipo seguro.

Carrera

Desde 2.0.0

Las llamadas a race con múltiples argumentos dan como resultado una Promise que las señales fail en el primer rechazo o las señales done en la primera resolución.

Escenario de éxito

 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 ));

Escenario de fracaso

 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!" ));

Asentarse

Desde 2.0.0

Las llamadas a settle con múltiples argumentos dan como resultado una Promise que recoge todas las resoluciones y rechazos.

 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 );
});

Controlador de cancelación

Desde 2.0.0

A veces, una tarea puede cancelarse mientras se está ejecutando y requeriría que limpie los recursos que haya asignado. Puede definir una tarea que implemente la interfaz org.jdeferred2.CancellationHandler o pasar un argumento adicional a DeferredFutureTask con dicha implementación, por ejemplo

 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 (...)

También puede pasar CancellationHandler como argumento adicional, por ejemplo

 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 (...)

maravilloso

¡También puedes usarlo fácilmente con 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 " )

Soporte Android

Desde 1.1.0-Beta1

jdeferred-android ya está disponible y se puede incluir como cualquier otra biblioteca de Android! También utiliza el complemento Android Maven y crea un archivo apklib. Si utiliza el complemento Android Maven, puede incluir la dependencia:

APKLIB con Maven:

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

AAR con Maven:

Desde 1.2.0-Beta1

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

AAR con Gradle:

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

Encuentre versiones disponibles en el repositorio central de Maven.

jdeferred-android presenta una nueva implementación DeferredManager llamada AndroidDeferredManager . AndroidDeferredManager se asegura de que las devoluciones de llamada se ejecuten en el subproceso de la interfaz de usuario en lugar de en el subproceso en segundo plano para que las devoluciones de llamada realicen actualizaciones de la interfaz de usuario. Alternativamente, las devoluciones de llamada también pueden implementar la interfaz AndroidExecutionScopeable para controlar detalladamente si la devolución de llamada debe ejecutarse en UI Thread o en segundo plano.

AndroidDeferredManager también admite el nuevo objeto DeferredAsyncTask . Este objeto se basa en AsyncTask de Android.

Si necesita ejecutar siempre devoluciones de llamada en un hilo en segundo plano, puede continuar usando DefaultDeferredManager .

Por último, debido a que JDeferred usa SLF4J, puede enrutar aún más los mensajes de registro usando slf4j-android .

Servlet asincrónico

¡Aquí hay un código de muestra sobre cómo usar JDeferred con servlet asíncrono!

 @ 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" );
      }
    });
  }
}

<script type="text/javascript"> /* */ </script> <script type="text/javascript" src="//www.googleadservices.com/pagead/conversion.js"> </script>

Depreciaciones

v1.2.5

• DeferredManager.StartPolicy.MANAUL está en desuso y se eliminará en la próxima versión menor. Utilice DeferredManager.StartPolicy.MANUAL en su lugar.