Akka: comment faire des requêtes JDBC non bloquantes

Je suis nouveau dans Akka ( Java Lib ) et j’essaie de comprendre si Akka peut être utilisé pour envoyer des requêtes non bloquantes à JDBC et, le cas échéant, à quoi il pourrait ressembler. Je pense que la plupart des pilotes JDBC ouvrent une connexion socket et bloquent le thread qui l’a créé jusqu’à ce qu’une réponse JDBC particulière soit reçue. Akka ne peut donc pas faire grand chose pour aider ici, mais je me demande s’il existe un moyen Futurs ou agents?) Qu’Akka pourrait aider à améliorer les performances et permettre au système acteur de continuer à traiter les données tout en effectuant un appel JDBC existant et en attente d’une réponse.

J’ai trouvé cet article qui est un peu vague / cryptique, mais il semble que les avenirs pourraient être la clé ici. Cependant, cet article ne montre pas vraiment d’exemples de code significatifs (dans le monde réel) et je suis donc toujours perdue. sp_make_expensive_calculation donc que nous ayons une procédure stockée, sp_make_expensive_calculation , qui prend normalement 10 à 30 secondes pour renvoyer une réponse et qui est normalement appelée via JDBC comme suit:

 Ssortingng makeExpensiveCalculationSql = "{call sp_make_expensive_calculation(?)}"; callableStatement = dbConnection.prepareCall(makeExpensiveCalculationSql); callableStatement.setInt(1, 10); // Could take up to 30 seconds to complete. callableStatement.executeUpdate(); int answer = callableStatement.getSsortingng(2);

Akka peut-il intervenir pour que le système d’acteurs puisse continuer à traiter les données (et même effectuer d’autres appels sp_make_expensive_calculation ) en attendant le retour du premier appel?

Le modèle général consiste à utiliser des contextes d’exécution distincts: l’un pour l’access synchrone à la firebase database via JDBC, l’autre pour le traitement réactif. Voir également la documentation sur les contrats à terme Akka .

Lorsque vous créez un système d’acteurs, il crée son propre contexte d’exécution – c’est celui que vous utilisez pour votre traitement réactif normal avec des acteurs. Vous devez créer un deuxième contexte d’exécution pour les appels JDBC. Vous transmettez ensuite ce contexte d’exécution à la future usine, comme indiqué ici dans la documentation Akka .

Pour être averti lorsque le futur est terminé, vous pouvez (éventuellement) utiliser la construction de tuyau (également présenté dans le lien précédent, mais dans la section précédente de la documentation). L’effet de la construction de canal est de prendre la valeur de retour du futur, dont le type est celui du paramètre de type générique du futur (par exemple, le résultat de votre requête), et de l’envoyer à la boîte aux lettres de l’acteur spécifié.

Le code exécuté par le futur ne doit pas modifier ni même lire les données mutables appartenant à l’acteur initiateur (ou à tout acteur d’ailleurs). Vous aurez besoin de baliser le résultat du futur pour que l’acteur puisse l’associer à la requête JDBC initiale lorsqu’il arrivera dans la boîte aux lettres de l’acteur. Enfin, votre acteur finira par recevoir le résultat et vous pourrez continuer à le traiter (sous réserve des garanties de livraison d’Akka au plus une fois).

Notez que vous ne devez pas utiliser deux contextes d’exécution: l’un fonctionnera également, mais vos requêtes de firebase database risqueraient de consumr tous les threads disponibles dans le contexte d’exécution.

Vous avez raison de dire que la connexion JDBC sera bloquée jusqu’à ce que la demande soit traitée, mais si vous l’enveloppez dans un processeur asynchrone, vous pouvez la laisser se terminer et laisser le thread principal continuer.

Un moyen d’accorder au demandeur l’access au résultat de la demande JDBC consiste à fournir un rappel appelé à la fin du processus de firebase database asynchrone.