Intégration des services de décision Corticon | Progrès

Introduction

Lors de l’intégration d’un service de décision Corticon Progress dans vos applications JavaScript, la gestion des opérations asynchrones (asynchrones) est critique, car les services de décision sont une fonction asynchrone.

Ce blog présente trois schémas d’invocation asynchronisés communs – en utilisant Async / Aide Propagationun FADADE SYNCHRONE avec une fonction asynchrone immédiatement invoquée (IIAFE) et Promettre un chaînage de .Then ()– Tous enveloppés dans une conception simple axée sur les événements qui informe à la fin du service de décision.

Ces modèles sont démontrés Dans cet échantillon sur le Corticon Public Github.

En tant que note historique, les services de décision sont devenus asynchrones lorsque nous Présentation de la prise en charge du service de service dans Corticon v2.0.

Le cœur de l’intégration: RundecisionService

Avant de plonger dans les modèles, regardons la fonction asynchrone principale qui exécute le moteur des règles de Corticon – un élément commun aux trois modèles présentés ci-dessous:

async function runDecisionService() {

try {

…

// Await the async decision service execution
const result = await window.corticonEngine.execute(payload, configuration);

…

} catch (e) {

alert('Unexpected exception executing the rules: ’ + e);

throw e;

}

}

Cette fonction utilise l’async / attendre moderne pour les appels asynchrones propres et lisibles et implémente la gestion des erreurs. Le code se lit séquentiellement et l’exécution est également séquentielle. Autrement dit, cette fonction reviendra à la fin du service de décision.

Trois façons d’invoquer le service de décision

1. Propagation async / attend – Asynchrone tout le long

Vous avez généralement une pile d’appels de fonctions qui s’exécute avant l’invoquer le service de décision. Dans cet échantillon, nous illustrons cette condition avec F1 () appelant F2 () appelant RundecisionService.

async function f1() {
console.log(“In f1 (async)”);
await f2();
}

async function f2() {
console.log(“In f2 (async)”);
await runDecisionService();
}

Comment ça marche:

• Chaque fonction de la pile d’appels est déclarée asynchrone
• Chacun attend le suivant, créant un flux séquentiel clair qui se lit
  de manière synchrone
• Les erreurs se propagent naturellement via Try / Catch

Avantages:

• Code propre et lisible
• Gestion des erreurs faciles
• Meilleures pratiques javascript modernes

Inconvénients:

• Nécessite une propagation asynchrone dans toute la chaîne d’appels, qui peut être
  intrusif dans les bases de code héritées ou synchrones
• Le thread principal est bloqué jusqu’à la fin du service de décision
  (généralement, les services de décision s’exécutent très rapidement, mais si le vôtre est
  Bloquer l’interface utilisateur trop longtemps, vous voudrez peut-être considérer les options ci-dessous)

2. Faade synchrone avec un IIAFE

function f1Sync() {

console.log(“In f1Sync (sync)”);

f2Sync();

console.log(“Exiting f1Sync before decision service completes”);

}

function f2Sync() {

console.log(“In f2Sync (sync)”);

(async () => {

console.log(“Invoking decision service inside IIAFE”);

const result = await runDecisionService();

console.log(“Decision service completed inside IIAFE”);

eventEmitter.emit(‘dsDone’, result);

})();

}

Comment ça marche:

• La pile d’appels principale reste synchrone
• La logique asynchrone fonctionne à l’intérieur de l’IIAFE
• f2Sync () revient immédiatement, mais l’appel asynchronisé se produit en arrière-plan
• Une fois terminé, un événement personnalisé (DSDONE) est émis pour informer les auditeurs

Avantages:

• Intègre les opérations asynchrones sans marquer tous les appels asynchronisés
• Maintient les API synchrones intactes
• UI pas «gelé» jusqu’à la fin du service de décision
• La conception axée sur l’événement permet à d’autres parties de l’application de répondre lorsque le service de décision se termine

Inconvénients:

• Les appelants n’obtiennent pas le résultat asynchrone directement (doivent écouter les événements)
• Modèle légèrement plus complexe à comprendre initialement

3. Promesse de chaînage de. Puis ()

function f1SyncWithThen() {

console.log(“In f1SyncWithThen (sync)”);

f2SyncWithThen();

console.log(“Exiting f1SyncWithThen before decision service completes”);

}

function f2SyncWithThen() {

console.log(“In f2SyncWithThen (sync)”);

console.log(“Invoking decision service with .then()”);

runDecisionService()

.then(result => {

console.log(“Decision service completed with .then()”);

eventEmitter.emit(‘dsDone’, result);

})

.catch(error => {

console.error(“Error in decision service (with .then()):”, error);

alert("Error executing the decision service: " + error);

});

console.log(“Proceeding after invoking decision service with .then()”);

}

Comment ça marche:

• La pile d’appels reste synchrone
• Utilise Promise Chaining (.Then ()) pour gérer les résultats asynchrones
• Émet un événement à la fin
• Comprend la gestion des erreurs via .catch ()

Avantages:

• Modèle familier pour la manipulation des promesses
• Fonctionne bien dans les environnements sans async / attente
• Facile à ajouter une gestion des erreurs

Inconvénients:

• Un peu moins lisible que l’async / attendre
• Peut devenir imbriqué avec plusieurs étapes asynchrones

Notifications axées sur l’événement

Le Échantillon sur la page Corticon publique Github Présent également un événement simple pour permettre à votre application de répondre à la fin du service de décision:

class EventEmitter {

constructor() { this.events = {}; }

on(event, listener) {

if (!this.events[event]) this.events[event] = [];

this.events[event].push(listener);

return this;

}

emit(event, …args) {

if (!this.events[event]) return false;

this.events[event].forEach(listener => listener(…args));

return true;

}

}

const eventEmitter = new EventEmitter();

// Listen for decision service completion event
eventEmitter.on(‘dsDone’, (result) => {

console.log(“Event: Decision Service Completed”);

// Further UI updates or workflows can be triggered here

});

Ce modèle découple votre interface utilisateur ou votre logique commerciale à partir de l’invocation du service de décision asynchrone, de la promotion de la séparation propre et de l’entretien plus facile.

Choisir l’approche qui fonctionne pour vous

Voici un tableau résumant les avantages et les inconvénients des modèles tels que présentés dans le Échantillon sur la page Github Corticon Public:

Passez à l’étape suivante et Inscrivez-vous à une formation gratuiteou En savoir plus sur Corticon.js.