Comment obtenir Futures d'invocation d'acteur dans un contexte non-acteur

Question

J'intègre Akka dans un logiciel existant, principalement pour rendre les choses asynchrones là où elles ne devraient pas être synchrones.

J'ai un service qui fait des appels de base de données, pour le moment, tout est synchrone, le thread appelant est juste assis ici et d'attendre le résultat ...

Mon idée est de remplacer le DAO interface pour avoir Future<T> (Akka) en tant que résultats au lieu des types de résultats réels, ainsi, mon implémentation DAO est en train de transformer ces appels en messages et les achemine vers les acteurs appropriés (locaux et/ou distants).

Maintenant, je suis un peu perplexe quand il s'agit de savoir comment retourner un Future<T> quand j'appelle l'acteur. Y a-t-il un autre moyen que d'utiliser Patterns.ask()? Est-ce la meilleure solution en termes de performances (sans tout réécrire en utilisant des acteurs)?

En utilisant Patterns.ask(), comment puis-je retourner une erreur sans attendre le délai d'expiration? Si l'acteur que j'appelle ne fait que répéter l'erreur, cela déclenchera un succès, quand je veux déclencher un échec.

Edits

j'utilise Java.

À l'heure actuelle, je suis venu avec une construction comme celle ci-dessous, mais, il implique que mon acteur doit tell() l'exception à l'expéditeur.

final Future<Object> f = Patterns.ask(..., ..., ...); 
f.flatMap(new Mapper<Object, Future<List<Element>>>() { 
    public Future<List<Element>> apply(Object response) { 
     if (response instanceof SuccessfulResult) { 
      return Futures.successful(response, f.executor()); 
     } else if (response instanceof Throwable) { 
      return Futures.failed((Throwable) response, f.executor()); 
     } else { 
      return Futures.failed(..., f.executor()); 
    } 
} 

Answer 1

Pour différencier le succès de l'échec, vous devez utiliser scala.Either. Ainsi, le type de réponse pourrait ressembler à ceci:

type Result = Future[Either[SQLException, MyDataType]]