Remarque
L’accès à cette page requiert une autorisation. Vous pouvez essayer de vous connecter ou de modifier des répertoires.
L’accès à cette page requiert une autorisation. Vous pouvez essayer de modifier des répertoires.
L’objectif de cet exemple est de créer une application de processeur de messages composée qui traite des éléments de ligne individuels à partir de messages agrégés.
Plus précisément, nous allons créer une planification d’orchestration qui :
Reçoit un message d’échange par lot composé de plusieurs commandes d’achat.
Démonte le message d’échange en documents de bon de commande individuels.
Traite chaque document : convertit chaque bon de commande en message de facture.
Assemble tous les messages de facture dans un échange par lots.
L’étape 3 est simplifiée à des fins d’exemple. Par exemple, dans des applications plus complexes, une orchestration peut envoyer des bons de commande désassemblé à différents systèmes d’inventaire back-end, puis après avoir collecté toutes les réponses, les agréger en un seul message de facture par lot.
Pour plus d’informations sur le modèle de processeur de messages composé, reportez-vous à [1].
Ce que fait cet exemple
Il existe deux projets dans l’exemple de solution, qui sont décrits en détail dans les sections suivantes.
Pipelines et schémas
Le projet Pipelines et schémas contient :
Schémas de fichiers plats pour l’échange de bon de commande d’entrée et pour l’échange de factures de sortie.
Mappage afin de transformer le document de bon de commande en document de facture.
Recevoir et envoyer des pipelines.
Schémas de fichiers plats pour les échanges d’entrée et de sortie
Notre exemple d’application fonctionne avec les échanges au format de fichier plat. Voici les exemples de l’échange de bon de commande et de l’échange de factures :
Échange de commande d'achat (CMPInput.txt) :
Northwind Shipping
Batch type:Purchase Orders
PO1999-10-20
US Alice Smith 123 Maple Street Mill Valley CA 90952
US Robert Smith 8 Oak Avenue Old Town PA 95819
Hurry, my lawn is going wild!
ITEMS,ITEM872-AA|Lawnmower|1|148.95|Confirm this is electric,ITEM926-AA|Baby Monitor|1|39.98|Confirm this is electric|1999-10-21
PO1999-10-21
US John Dow 123 Elm Street Mill Valley CA 90952
US July Dow 8 Pine Avenue Old Town PA 95819
Please ship it urgent!
ITEMS,ITEM398-BB|Tire|4|324.99|Wrap them up nicely,ITEM201-BB|Engine Oil|1|12.99|SAE10W30|1999-05-22
PO1999-10-23
US John Connor 123 Cedar Street Mill Valley CA 90952
US Sarah Connor 8 Grass Avenue Old Town PA 95819
Use cheapest shipping method.
ITEMS,ITEM101-TT|Plastic flowers|10|4.99|Fragile handle with care,ITEM202-RR|Fertilizer|1|10.99|Lawn fertilizer,ITEM453-XS|Weed killer|1|5.99|Lawn weed killer|1999-05-25
L’échange ou le document de bon de commande possède un en-tête qui identifie le type des documents qu’il contient :
Northwind Shipping
Batch type:Purchase Orders
Cet échange se compose de trois documents de bon de commande. Une instance se compose des informations indiquées ci-dessous. Comme vous pouvez le voir, il contient des informations telles que l’adresse pour la facturation et l’expédition, ainsi que la liste des articles commandés.
PO1999-10-20
US Alice Smith 123 Maple Street Mill Valley CA 90952
US Robert Smith 8 Oak Avenue Old Town PA 95819
Hurry, my lawn is going wild!
ITEMS,ITEM872-AA|Lawnmower|1|148.95|Confirm this is electric,ITEM926-AA|Baby Monitor|1|39.98|Confirm this is electric|1999-10-21
L’échange de factures que nous voulons générer doit ressembler à ceci :
Northwest Shipping
DocumentTypes:Invoices
INVOICE1999-10-20
BILLTO,US,Alice Smith,123 Maple Street,Mill Valley,CA,90952
872-AA Lawnmower 1 148.95 Confirm this is electric
926-AA Baby Monitor 1 39.98 Confirm this is electric
INVOICE1999-10-21
BILLTO,US,John Dow,123 Elm Street,Mill Valley,CA,90952
398-BB Tire 4 324.99 Wrap them up nicely
201-BB Engine Oil 1 12.99 SAE10W30
INVOICE1999-10-20
BILLTO,US,John Connor,123 Cedar Street,Mill Valley,CA,90952
101-TT Plastic flowers 10 4.99 Fragile handle with care
202-RR Fertilizer 1 10.99 Lawn fertilizer
453-XS Weed killer 1 5.99 Lawn weed killer
Cet échange contient un sous-ensemble d’informations qui étaient dans l’échange de bon de commande, ainsi que le format de l’échange ainsi que le format de l’en-tête sont différents.
L’en-tête est le suivant :
Northwest Shipping
DocumentTypes:Invoices
Et l’instance de document comprend les éléments suivants :
INVOICE1999-10-20
BILLTO,US,Alice Smith,123 Maple Street,Mill Valley,CA,90952
872-AA Lawnmower 1 148.95 Confirm this is electric
926-AA Baby Monitor 1 39.98 Confirm this is electric
Tout d’abord, nous devons créer des schémas de fichiers plats pour :
Document de bon de commande (PO.xsd)
Document de facture (Invoice.xsd)
En-tête de bon de commande (POHeader.xsd)
En-tête de facture (InvoiceHeader.xsd)
Pour cet exemple, nous ne allons pas expliquer le processus de création de schémas de fichiers plats. Pour savoir comment créer des schémas de fichiers plats à partir d’instances de document, reportez-vous à la section de documentation « Création de schémas de fichiers plats à partir d’une instance de document ».
Mapper pour transformer le document de bon de commande en document de facture
La carte (PO2Invoice.btm) transforme une instance du bon de commande en document de facture.
Les pipelines de réception et d'envoi
Le pipeline de réception (FFReceivePipeline.btp) contient un composant désassembleur de fichier plat utilisé pour traiter un échange de bon de commande. En particulier, pour l’échange dans le fichier CMPInput.txt, il supprime l’en-tête de l’échange et produit trois documents XML correspondant à trois bons de commande.
Le désassembleur de fichier plat dans le pipeline de réception est configuré comme indiqué :
Schéma de document : PipelinesAndSchemas.PO
Schéma d’en-tête : PipelinesAndSchemas.POHeader
Conservez l’en-tête : Faux
Échange récupérable : Faux
Schéma de bande-annonce : (Aucun)
Valider la structure du document : Faux
Le pipeline d’envoi (FFSendPipeline.btp) contient un composant assembleur de fichiers plats utilisé pour créer un échange de factures agrégé.
L’assembleur de fichiers plats dans le pipeline d’envoi est configuré comme indiqué :
Schéma de document : PipelinesandSchemas.Invoice
Schéma d’en-tête : PipelinesAndSchemas.InvoiceHeader
Conservez la marque d’ordre d’octet : Faux
Charset cible : (Aucun)
Schéma de bande-annonce : (Aucun)
Planification de l’orchestration
Le calendrier d'orchestration (CMP.odx) est l'endroit où se déroule tout le traitement principal. Plus précisément, les actions suivantes sont effectuées :
Le pipeline de réception est exécuté pour désassembler l’échange de bon de commande
Chaque message de sortie du pipeline de réception est transformé
Le pipeline d’envoi est exécuté pour assembler un échange de factures
Création d’une planification d’orchestration et définition de variables globales
Notre orchestration recevra un échange de fichiers plats en tant qu’entrée et enverra un échange de fichiers plats en tant que sortie. En raison de cela, nous devons définir les messages d’entrée et de sortie (appelés InputInterchange et OutputInterchange respectivement) en tant que type indépendant (c’est-à-dire avoir le type System.Xml.XmlDocument).
En outre, nous devons définir une étendue atomique dans laquelle nous traiterons les messages. Cela est nécessaire, car le pipeline de réception peut être exécuté dans un contexte atomique.
Exécution d’un pipeline de réception
À l’étape suivante, nous allons ajouter une logique permettant d'exécuter un pipeline de réception pour le message reçu de l’orchestration. Pour ce faire, nous déclarons d’abord une variable (appelée RcvPipeOutput) de type Microsoft.XLANGs.Pipeline.ReceivePipelineOutputMessages dans l’étendue. Cette variable est un énumérateur qui nous permet de parcourir les messages de sortie du pipeline de réception. Notez que pour accéder à ce type, ainsi qu'à tous les autres types nécessaires à l'exécution des pipelines depuis l'orchestration, vous devez ajouter des références aux assemblies suivants :
Microsoft.XLANGs.Pipeline.dll
Microsoft.BizTalk.Pipeline.dll
Il n’existe aucune garantie que le pipeline de réception s’exécute toujours correctement. Parfois, les messages peuvent être mal formés, ce qui entraînerait l’échec du traitement du pipeline. Lorsqu’un pipeline échoue dans l’orchestration, une exception est levée, qui peut être interceptée, et on peut exécuter la logique de gestion des erreurs. Pour intercepter l’exception levée par le pipeline, nous devons exécuter le pipeline dans une étendue non atomique avec une gestion des exceptions. Le code réel pour exécuter le pipeline est appelé à partir d’une forme d’expression dans cette étendue.
Dans la forme d’expression ExecuteRcvPipe, écrivez la ligne de code suivante pour exécuter le pipeline de réception :
RcvPipeOutput = Microsoft.XLANGs.Pipeline.XLANGPipelineManager.ExecuteReceivePipeline(typeof(PipelinesAndSchemas.FFReceivePipeline), InputInterchange);
Analysons plus en détail cette ligne de code. Comme vous pouvez le voir, nous appelons une méthode statique ExecuteReceivePipeline qui prend comme paramètre un type de pipeline de réception à exécuter et un message d’entrée. Par conséquent, il produit un objet d’énumérateur avec l’ensemble de messages de sortie. Le résultat est affecté à une variable de type ReceivePipelineOutputMessages qui a été définie dans cette étendue avant.
Nous avons également inclus un bloc de gestion des exceptions pour l’étendue d’exécution du pipeline. Ce bloc intercepte l’exception de type XLANGPipelineManagerException, puis pour des raisons de simplicité, il suffit de mettre fin à une instance d’orchestration avec un message d’erreur personnalisé.
Dans des scénarios plus complexes, une gestion des erreurs supplémentaire peut être effectuée ici, comme la génération ou le message de notification d’erreur et son envoi à un utilisateur professionnel ou à un administrateur à l’aide de l’e-mail.
Transformation des messages de sortie de pipeline
Une fois le pipeline exécuté et l’ensemble de messages désassemblés générés, nous devons transformer chaque message de sortie dans un format différent.
Pour utiliser la transformation dans l’orchestration, nous devons définir deux messages : l’entrée et la sortie de transformation. Nous allons définir ces messages dans l’étendue atomique. Le message d’entrée de transformation appelé TmpMessageIn sera de type PipelinesAndSchemas.PO. Le message de sortie de transformation appelé TmpMessageOut sera de type PipeliensAndSchemas.Invoice. Nous allons appliquer la carte PO2Invoice.btm définie dans le projet PipelinesAndSchemas.
Comme nous voulons mapper chaque message de sortie de pipeline, nous devons effectuer la transformation dans la boucle. Nous allons utiliser une forme de boucle avec la condition de sortie comme ci-dessous :
RcvPipeOutput.MoveNext()
La méthode MoveNext() est une méthode standard d’interface .NET IEnumerator qui permet de se déplacer dans la collection de messages de sortie de pipeline. Lorsqu’elle atteint la fin de la collection, elle retourne false.
La première forme de construction est utilisée pour construire un message d’orchestration TmpMessageIn hors du message de sortie du pipeline.
Le code dans la structure de construction :
TmpMessageIn = null;
RcvPipeOutput.GetCurrent(TmpMessageIn);
Dans ce code, nous initialisons d’abord le message d’orchestration sur Null, puis nous l’avons défini sur le message actuel de la collection de messages de sortie du pipeline.
Dans la deuxième forme de construction, la transformation réelle de TmpMessageIn est effectuée et le TmpMessageOut de type PipelinesAndSchemas.Invoice est construit.
Exécution d’un pipeline d’envoi
La dernière étape de traitement de l’orchestration consiste à exécuter un pipeline d’envoi de fichiers plats pour assembler tous les messages xml transformés en un échange de fichiers plats.
Pour exécuter un pipeline d’envoi, nous devons utiliser une variable de type Microsoft.XLANGs.Pipeline.SendPipelineInputMessages appelée SendPipeInput qui contiendra une collection de messages d’orchestration qui doivent être traités dans un pipeline d’envoi.
Dans la dernière expression de la boucle où nous avons effectué la transformation, nous allons écrire un code qui ajoute chaque message transformé à une collection de messages pour le pipeline d’envoi :
SendPipeInput.Add(TmpMessageOut);
Comme dans la partie où nous exécutons le pipeline de réception, le code d’exécution du pipeline d’envoi est placé dans une étendue non atomique avec un bloc de gestion des exceptions. Le code d’exécution du pipeline d’envoi se trouve dans la forme d’affectation de message du bloc de construction.
OutputInterchange = null;
Microsoft.XLANGs.Pipeline.XLANGPipelineManager.ExecuteSendPipeline(typeof(PipelinesAndSchemas.FFSendPipeline), SendPipeInput, OutputInterchange);
Le bloc de construction est utilisé pour construire les messages de sortie de pipeline OutputInterchange compatibles avec tous les types (par exemple, System.Xml.XmlDocument). Ensuite, dans la forme d’affectation de message, le message nouvellement construit est initialisé sur null. Après cela, la méthode statique ExecuteSendPipeline est appelée pour exécuter un pipeline d’envoi. Cette méthode prend comme paramètre un type du pipeline d’envoi à exécuter, le message d’entrée et la référence au message de sortie où la sortie du pipeline sera stockée.
Comme pour l’exécution du pipeline de réception, nous avons également un bloc de gestion des exceptions pour le périmètre d’exécution du pipeline. Ce bloc intercepte l’exception de type XLANGPipelineManagerException, puis pour des raisons de simplicité, il suffit de mettre fin à une instance d’orchestration avec un message d’erreur personnalisé.
Où trouver cet exemple
Le tableau suivant répertorie les fichiers de cet exemple.
| Fichier(s) | Description |
|---|---|
| Cleanup.bat | Utilisé pour annuler le déploiement d’assemblys et les supprimer du Global Assembly Cache (GAC). Supprime les ports d’envoi et de réception. Supprime les répertoires virtuels Microsoft Internet Information Services (IIS) selon les besoins. |
| ComposedMessageProcessor.sln | Fichier de solution Visual Studio pour l’exemple. |
| ComposedMessageProcessorBinding.xml | Fichier de liaison d’exemple. |
| Setup.bat | Utilisé pour générer et initialiser cet exemple. |
| Dans le dossier Orchestration : CMP.odx |
Orchestration qui exécute le pipeline de réception pour désassembler les messages, transforme chaque message désassemblé, puis exécute le pipeline d'envoi pour assembler les messages en un échange. |
| Dans le dossier Orchestration : Orchestration.btproj |
Projet BizTalk pour l’orchestration. |
| Dans le dossier Orchestration : SuspendMessage.odx |
Orchestration utilisée pour suspendre les messages qui échouent au traitement du pipeline. |
| Dans le dossier PipelinesAndSchemas : CMPInput.xml, CMPOutput.xml |
Instances de document d’entrée et de sortie pour l’exemple. |
| Dans le dossier PipelinesAndSchemas : FFReceivePipeline.btp, FFSendPipeline.btp |
Recevoir et envoyer des pipelines contenant des composants de fichier plat. Ces pipelines sont exécutés au sein d'un système d'orchestration. |
| Dans le dossier PipelinesAndSchemas : Invoice.xsd, InvoiceHeader.xsd |
Schémas de fichier plat pour le document de sortie et l’en-tête. |
| Dans le dossier PipelinesAndSchemas : PO.xsd, POHeader.xsd |
Schémas de fichier plat pour le document d’entrée et l’en-tête. |
| Dans le dossier PipelinesAndSchemas : PropertySchema.xsd |
Schéma de propriété pour l’exemple. |
Génération et initialisation de l’exemple
Utilisez la procédure suivante pour générer et initialiser l’exemple Compose.
Pour construire et initialiser l’exemple Compose
Dans une fenêtre de commande, accédez au dossier suivant :
<Chemin des exemples>\Pipelines\ComposedMessageProcessor
Exécutez le fichier Setup.bat, qui effectue les actions suivantes :
Crée les dossiers d’entrée (In) et de sortie (Out) pour cet exemple dans le dossier :
<Chemin des exemples>\Pipelines\ComposedMessageProcessor
Compile les projets Visual Studio pour cet exemple.
Crée une nouvelle application appelée « Exemple CMP » et déploie les assemblages d'exemple dans cette dernière.
Crée et lie l’emplacement de réception de BizTalk Server, ainsi que les ports d’envoi et de réception.
Enregistre et lance l’orchestration, active l’emplacement de réception et débute le port d’envoi.
Si vous choisissez d’ouvrir et de générer les projets dans cet exemple sans exécuter le fichier Setup.bat, vous devez d’abord créer une paire de clés de nom fort à l’aide de l’utilitaire .NET Framework Strong Name (sn.exe). Utilisez cette paire de clés pour signer les assemblys résultants.
Avant de tenter d’exécuter cet exemple, vérifiez que BizTalk Server n’a pas fait état d’erreurs pendant le processus de génération et d’initialisation.
Pour annuler les modifications apportées par Setup.bat, vous devez effectuer les opérations suivantes :
Arrêtez et redémarrez l’instance hôte à partir de la console Administration de BizTalk Server.
Exécutez Cleanup.bat. Vous devez exécuter Cleanup.bat avant d’exécuter Setup.bat une deuxième fois.
Exécution de l’exemple
Utilisez la procédure suivante pour exécuter l’exemple ComposedMessageProcessor.
Pour exécuter l’exemple ComposedMessageProcessor
Copiez le fichier texte CMPInput.txt situé dans le dossier PipelinesAndSchemas. Collez le fichier dans le dossier In.
Observez le fichier texte créé dans le dossier Out. Ce fichier contient les mêmes enregistrements que le CMPInput.txt, mais le format des données dans le fichier est différent.
À mesure que le message passe par BizTalk Server, voici ce qui suit :
Le message est désassemblé et converti en messages XML. Chaque message est mappé à un format différent.
Tous les messages mappés sont assemblés et convertis au format de fichier plat.