Página Inicial>Relacionado com a programação>Código fonte JAVA
Baixar

JDeferido 2.x

JDeferred é uma biblioteca Java Deferred/Promise semelhante ao Deferred Object do JQuery.

Inspirado em JQuery e Android Deferred Object.

Se você estiver usando JDeferred 1.x, consulte a documentação do JDeferred 1.x

Características

  • Objeto diferido e promessa
  • Promessa de retornos de chamada
    • .then(…)
    • .filter(…)
    • .pipe(…)
    • .done(…)
    • .fail(…)
    • .progress(…)
    • .always(…)
    • .pipeAlways(…)
  • Múltiplas promessas
    • .when(p1, p2, p3, …).then(…)
    • .race(p1, p2, p3, …).then(…)
    • .settle(p1, p2, p3, …).then(…)
  • Wrappers chamáveis ​​e executáveis
    • .when(new Runnable() {…})
    • .race(new Runnable() {…})
    • .settle(new Runnable() {…})
  • Usa serviço executor
  • Suporte a genéricos Java
    • Deferred<Integer, Exception, Double> deferred;
    • deferred.resolve(10);
    • deferred.reject(new Exception());
    • deferred.notify(0.80);
  • Suporte Android
  • Compatível com Java 8 Lambda
  • Sim, está no Repositório Central Maven!

Maven 

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

Gradle 

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

Encontre as versões disponíveis no Maven Central Repository.

Compatibilidade

Relatórios de compatibilidade entre versões:

  • 1.2.6 a 2.0.0

Exemplos rápidos

Objeto diferido e promessa 

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

Com a referência ao objeto adiado, você pode acionar ações/atualizações: 

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

Filtro

Use .filter(...) em vez 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.

Cano

Use .pipe(...) em vez 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 (…)

Você também pode especificar um serviço executor para sua necessidade. 

 DeferredManager dm = new DefaultDeferredManager(myExecutorService);

Executável e chamável

Você pode usar Callable e Runnable quase como uma promessa, sem nenhum trabalho 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 ) {
    ...
  }
});

Se precisar notificar o progresso em Callable ou Runnable, você precisará criar seu próprio objeto Deferred e Promise ou poderá usar DeferredCallable e DeferredRunnable.

Use seu próprio 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" );
  }
}

Ou estendendo DeferredRunnable 

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

Espere e espere com segurança

Desde 1.0.1

Normalmente, ao usar esta estrutura, você desejaria fazer as coisas de forma assíncrona. No entanto, se houver necessidade de aguardar a conclusão de todas as tarefas adiadas, você poderá usar os métodos Object.wait ou Promise.waitSafely. 

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

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

Alternativamente, você pode usar um atalho mais simplificado 

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

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

Java 8 Lambda

Agora, isso é muito legal quando usado com 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 ()))
);

Quando

Chamadas para when com vários argumentos resultam em uma Promise de que os sinais fail na primeira rejeição ou sinalizam done com todos os valores computados.

Cenário de sucesso 

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

Cenário de falha 

 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

Chamadas para when com múltiplos argumentos (até cinco) produzirão resultados com getters typesafe.

Corrida

Desde 2.0.0

Chamadas para race com vários argumentos resultam em uma Promise que sinaliza fail na primeira rejeição ou sinaliza done na primeira resolução.

Cenário de sucesso 

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

Cenário de falha 

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

Resolver

Desde 2.0.0

Chamadas para settle com múltiplos argumentos resultam em uma Promise que reúne todas as resoluções e rejeições. 

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

Manipulador de cancelamento

Desde 2.0.0

Às vezes, uma tarefa pode ser cancelada durante sua execução e exigiria a limpeza de todos os recursos que ela possa ter alocado. Você pode definir uma tarefa que implemente a interface org.jdeferred2.CancellationHandler ou passar um argumento extra para DeferredFutureTask com tal implementação, por exemplo 

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

Você também pode passar CancellationHandler como um argumento adicional, por exemplo 

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

Legal

Você também pode usar facilmente com o 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 " )

Suporte Android

Desde 1.1.0-Beta1

jdeferred-android já está disponível e pode ser incluído como qualquer outra biblioteca Android! Ele também usa o plugin Android Maven e cria um arquivo apklib. Se você usar o plugin Android Maven, poderá incluir a dependência:

APKLIB com Maven: 

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

AAR com 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 com Gradle: 

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

Encontre as versões disponíveis no Maven Central Repository.

jdeferred-android apresenta uma nova implementação DeferredManager chamada AndroidDeferredManager . AndroidDeferredManager garante que os retornos de chamada sejam executados no thread da interface do usuário, em vez do thread em segundo plano, para que os retornos de chamada façam atualizações da interface do usuário. Como alternativa, os retornos de chamada também podem implementar a interface AndroidExecutionScopeable para controlar detalhadamente se o retorno de chamada deve ser executado no UI Thread ou no Thread de segundo plano.

AndroidDeferredManager também oferece suporte ao novo objeto DeferredAsyncTask . Este objeto é baseado no AsyncTask do Android.

Se você precisar sempre executar retornos de chamada no thread em segundo plano, poderá continuar a usar DefaultDeferredManager .

Por último, como o JDeferred usa SLF4J - você pode rotear ainda mais mensagens de log usando slf4j-android .

Servlet assíncrono

Aqui está um exemplo de código sobre como usar JDeferred com Servlet Assí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>

Depreciações

v1.2.5

  • DeferredManager.StartPolicy.MANAUL está obsoleto e será removido na próxima versão secundária. Use DeferredManager.StartPolicy.MANUAL .
Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos