Ce chapitre présente les objets d'intégration qui sont des beans Java™ encapsulant les interactions avec une application hôte. Les objets d'intégration sont uniquement pris en charge par les applications Web HATS, y compris les portlets HATS.
Si vous avez déjà utilisé IBM® WebSphere Host Publisher, vous êtes déjà familiarisé avec la plupart des aspects des objets d'intégration, mais vous devez apprendre à les utiliser dans HATS. Il n'est absolument pas nécessaire d'être un développeur Host Publisher expérimenté pour pouvoir créer et utiliser des objets d'intégration dans HATS.
Si votre application HATS doit transformer une seule application hôte, sans connexion secondaire, vous n'avez pas besoin d'utiliser des objets d'intégration. Il est possible que vous deviez utiliser des objets d'intégration si vous êtes dans l'un des cas suivants :
Lorsque vous avez créé un objet d'intégration, vous pouvez l'utiliser de plusieurs façons :
Pour plus d'informations sur les autres tâches avancées pouvant être effectuées avec les objets d'intégration, voir HATS Web Application Programmer's Guide. Vous y trouverez des informations sur les tâches suivantes :
Un objet d'intégration est créé à partir d'une macro. Pour enregistrer une macro, suivez les étapes décrites dans Macros et terminal hôte.
Cliquez avec le bouton droit de la souris sur la macro dans la Vue des Projets HATS et sélectionnez Création d'un objet d'intégration. L'objet d'intégration portera le même nom que la macro. Vous pouvez également définir une préférence dans HATS pour générer automatiquement un objet d'intégration lorsqu'une macro est enregistrée. Cliquez sur Fenêtre > Préférences, développez HATS dans l'arborescence figurant à gauche de l'écran et cliquez sur Objet d'intégration. Cochez la case Génération automatique d'un objet d'intégration lors de la sauvegarde de macro, puis cliquez sur Validation.
Lorsque vous nommez une macro utilisée pour la création d'un objet d'intégration, veillez à respecter les consignes ci-après.
Il n'est pas possible de créer des objets d'intégration à partir de macros en chaîne. L'enchaînement des objets d'intégration est différent de l'enchaînement des macros, dans le sens où chaque objet d'intégration d'un enchaînement est exécuté jusqu'au bout avant la prise de contrôle de l'objet d'intégration suivant. L'enchaînement des macros, qui utilise l'action HATS Exécution d'une macro, termine la macro en cours (celle dans laquelle l'action Exécution d'une macro se produit) et commence à traiter l'écran de macro indiqué de la macro cible. Si vous importez une macro HOD contenant la marque <playmacro name="chainedMacroName"/>, vous pouvez l'utiliser uniquement avec les actions Exécution d'une macro et Exécution d'une transaction de macro de HATS. Pour plus d'informations sur l'enchaînement des macros, voir HATS Advanced Macro Guide.
Si une macro est modifiée via l'éditeur de macro, après la création d'un objet d'intégration à partir de cette macro particulière, vous devez régénérer l'objet d'intégration de telle sorte qu'il reflète la modification apportée. Si la préférence Générer automatiquement un objet d'intégration lors de la sauvegarde de macro est sélectionnée, l'objet d'intégration est mis à jour automatiquement.
Pour afficher la liste des objets d'intégration que vous avez créés, cliquez sur l'onglet Projets HATS de HATS Toolkit et développez le nom de votre projet, puis sélectionnez Source > Objet d'intégration et cliquez deux fois sur le dossier pour afficher son contenu.
L'enchaînement d'objets d'intégration vous permet de regrouper plusieurs objets d'intégration dans une seule tâche principale au sein de votre application Host Access Transformation Services. Chaque objet d'intégration exécute une sous-tâche et la tâche principale est exécutée par une chaîne d'objets d'intégration. Lorsque l'application est exécutée, les objets d'intégration s'exécutent l'un après l'autre en utilisant tous la même connexion.
Lorsque vous cliquez avec le bouton droit de la souris sur la macro pour créer l'objet d'intégration, sélectionnez l'option Création d'un objet d'intégration d'enchaînement. Précisez ensuite si l'objet d'intégration est le premier objet, un objet intermédiaire ou le dernier objet de la chaîne. Une chaîne peut comporter plusieurs objets d'intégration intermédiaires. Entrez les libellés qui identifient l'état de début et l'état de fin de l'objet d'intégration. Il n'y a pas de libellé d'état de début pour le premier objet d'intégration d'une chaîne et il n'y a pas de libellé d'état de fin pour le dernier objet d'une chaîne. Les libellés d'état sont requis pour garantir que les objets d'intégration d'une chaîne sont traités dans le bon ordre et que les données appropriées sont transmises à chaque fois.
Cette section décrit l'enchaînement d'objets d'intégration en détails et vous montre comment l'utiliser dans vos applications HATS.
Pour déterminer combien d'objets d'intégration sont nécessaires dans une chaîne, commencez par répertorier toutes les sous-tâches qui doivent être effectuées. Par exemple, imaginez une application hôte nommée vue-des-fichiers qui, lorsqu'elle est appelée, affiche une liste de fichiers. Dans cette liste, un utilisateur peut sélectionner n'importe quel fichier en tapant 1 en regard de son nom et en appuyant sur Entrée pour afficher son contenu. Il y a deux tâches à effectuer :
Deux macros sont nécessaires car l'utilisateur doit prendre une décision pour que la seconde macro puisse être exécutée. La seconde macro doit donc attendre une entrée de l'utilisateur. La définition de l'endroit où l'entrée utilisateur est requise constitue la première étape de la procédure de séparation des tâches en différents objets d'intégration.
Si l'utilisateur a plusieurs choix et que chaque choix entraîne des actions hôte différentes, chaque choix doit être un objet d'intégration distinct. Vous pouvez ensuite rassembler les objets d'intégration dynamiquement, en fonction des sélections de l'utilisateur. Par exemple, imaginez un menu de cinq options. Si l'utilisateur est autorisé à sélectionner n'importe laquelle des cinq options, chaque sélection doit être créée en tant qu'objet d'intégration indépendant.
Une fois que vous avez déterminé le nombre de tâches distinctes nécessaires dans votre application, vous pouvez décider comment l'enchaînement va affecter cette application. Si vous avez plus de deux tâches, l'enchaînement peut vous aider à améliorer les temps de réponse de votre application ou à réduire le nombre d'enregistrements de macro à effectuer, ce qui permet de diminuer la complexité générale de vos objets d'intégration.
Un objet d'intégration appartenant à une chaîne quitte la connexion dans un certain état (dans un écran particulier). Lorsque l'exécution de cet objet d'intégration est terminée, un autre objet d'intégration commençant à cet état (c'est-à-dire dans cet écran) peut s'exécuter.
Vous pouvez utiliser l'enchaînement pour diviser une application complexe en plusieurs tâches, chacune de ces tâches étant représentée par un objet d'intégration. Vous devez vous assurer que l'ordre des objets d'intégration est correct.
Par exemple, si vous avez trois objets d'intégration A, B et C dans une chaîne, vous devez utiliser l'objet A en premier, puis l'objet B, puis l'objet C. Si l'objet d'intégration C est appelé avant l'objet d'intégration B, lorsque l'objet C demande sa connexion, la connexion n'est pas disponible à l'état adéquat et l'objet d'intégration échoue.

La figure 64 décrit la durée de vie d'une connexion lors de l'exécution de trois objets d'intégration. L'objet d'intégration A est configuré comme premier objet, l'objet d'intégration B comme objet intermédiaire et l'objet d'intégration C comme dernier objet. Les données sur l'état de la connexion indiquent la connexion et le libellé d'état du dernier objet d'intégration exécuté.
Pour créer une application utilisant l'enchaînement d'objets d'intégration avec HATS, vous devez tout d'abord créer les objets d'intégration, puis créer vos pages Web à partir de ces objets d'intégration.
Pour créer votre application, vous devez effectuer les étapes suivantes :
Vous pouvez enregistrer des macros dans HATS Toolkit à l'aide du terminal hôte HATS. Sur l'écran du terminal hôte HATS, cliquez sur l'icône Enregistrer une macro. Pour plus d'informations sur l'enregistrement des macros, voir Icônes liées aux macros.
Répétez ces étapes pour chaque objet d'intégration que vous voulez créer.
Cliquez à l'aide du bouton droit de la souris sur chaque macro individuelle et sélectionnez Créer un objet d'intégration d'enchaînement. Vous avez le choix entre les options Premier, Intermédiaire et Dernier pour sélectionner la position de l'objet dans la chaîne. Si vous sélectionnez Premier, l'état sera l'état de fin au cours de la configuration de l'enchaînement d'objets d'intégration. Si vous sélectionnez Intermédiaire, l'état peut être l'état de début ou l'état de fin. Le dernier objet de la chaîne utilise l'état de début.
Vous devez effectuer ces opérations pour tous les objets d'intégration faisant partie de la chaîne.
Bien que l'enchaînement d'objets d'intégration soit un outil puissant permettant la modélisation de la plupart des applications hôte complexes, vous devez être très prudent lors de l'assemblage de vos applications. Il existe, en effet, un risque de créer une application Java EE avec des objets d'intégration qui sont appelés dans le désordre. Par conséquent, vous devez connaître les erreurs qui sont obtenues sur le serveur lorsque cela se produit.
Si vous n'enchaînez pas correctement les objets d'intégration, des incidents se produiront lors de l'exécution de votre objet d'intégration. Voici les messages d'erreur que vous pouvez voir s'afficher sur le serveur et les procédures de débogage correspondantes :
Lorsque cela se produit, déterminez pourquoi cet objet d'intégration n'est pas appelé dans le bon ordre.
Vous pouvez créer des pages JSP à partir de n'importe quel objet d'intégration. Les trois approches possibles pour créer ces pages sont appelées modèle 1, JSF et Struts. Les sections ci-après décrivent ces approches et expliquent comment elles permettent de créer des pages.
L'approche traditionnelle de HATS pour créer des pages JSP est appelée modèle 1.
Dans ce modèle, une seule page JSP contient :
Dans la vue Projets HATS, cliquez avec le bouton droit de la souris sur le nom d'un objet d'intégration et sélectionnez Créer des pages Web de modèle 1. Indiquez les noms des pages en entrée et en sortie ainsi que la destination, ou acceptez les noms par défaut créés à partir du nom de l'objet d'intégration. Vous pouvez également indiquer des Options de génération de page en sélectionnant Adjoindre à des fichiers existants ou Remplacer les fichiers existants. Une fois les sélections effectuées, cliquez sur Suivant.
Lorsque vous créez des pages Web de modèle 1, vous définissez deux pages : une page en entrée, qui regroupe les données requises par l'objet d'intégration, et une page en sortie, qui présente les résultats après l'exécution de l'objet d'intégration.
La page Définir les pages en entrée permet de définir un contrôle d'entrée pour chaque propriété d'entrée. Pour modifier un contrôle, sélectionnez une propriété d'entrée et cliquez sur Modifier. Vous pouvez ajouter un texte de début pour le contrôle et, si nécessaire, configurer le contrôle sélectionné. En outre, vous pouvez choisir de définir la propriété d'entrée sur la valeur d'une variable globale au lieu d'utiliser un contrôle d'entrée. Il est également possible de stocker la valeur de la propriété d'entrée en tant que variable globale (les variables globales utilisées par les objets d'intégration sont partagées). Lorsque la page en entrée est exécutée, elle ne passe pas le contrôle directement à la page en sortie. Elle le renvoie à l'application HATS afin que les variables globales puissent être définies et que les autres actions nécessaires soient effectuées.
La page Définir les pages en sortie permet de choisir les propriétés de sortie de l'objet d'intégration que vous souhaitez afficher. Pour modifier un contrôle, sélectionnez une propriété de sortie et cliquez sur Modifier. Vous pouvez indiquer un texte de début pour le contrôle. La page JSP en sortie contient le code nécessaire pour initialiser l'objet d'intégration, pour définir les propriétés de l'objet d'intégration à partir des variables globales, pour exécuter l'objet d'intégration et pour afficher le résultat de l'objet d'intégration.
Les pages que vous créez sont stockées dans le répertoire Web Content/Model 1 Pages, dans la vue Projets HATS. Pour modifier une page Web et appeler Page Designer, cliquez deux fois sur le nom de la page. Pour tester vos pages, cliquez avec le bouton droit sur la page en entrée (ou sur la page de sortie, à défaut de page d'entrée) et sélectionnez Déboguer sur le serveur ou Exécuter sur le serveur.
SignOn.setHPubStartPoolName("<new_project_name>/<default_connection>");Si vous avez installé la fonction outils Struts Tools de Rational SDP, HATS vous permet d'utiliser Struts pour créer des pages Web fondées sur des objets d'intégration.
Dans la vue Projets HATS, cliquez avec le bouton droit de la souris sur le nom d'un objet d'intégration et sélectionnez Créer des pages Web Struts. Indiquez les noms des pages en entrée et en sortie, ou acceptez les noms par défaut créés à partir du nom de l'objet d'intégration. Cliquez sur Fin.
Lorsque vous créez des pages Web STRUTS, HATS génère cinq nouveaux fichiers :
HATS ajoute également une fonction de mappage d'action au fichier struts-config.xml pour associer la classe Action à la classe ActionForm.
STRUTS a été développé dans le cadre du projet Jakarta de The Apache Software Foundation. Pour plus de détails sur STRUTS, consultez le site http://jakarta.apache.org/struts et le contenu de l'aide Rational SDP.
La structure JSF (JavaServer Faces) permet de développer des interfaces utilisateur pour les applications Web exécutées sur un serveur Java. L'assemblage de composants d'interface utilisateur dans une page permet de construire rapidement des applications Web. Une fois les pages Web JSF créées, vous pouvez faire appel à des outils tels que Page Designer et la palette pour procéder à des modifications et des éditions.
Dans la vue Projets HATS, cliquez avec le bouton droit de la souris sur le nom d'un objet d'intégration et sélectionnez Créer des pages Web JSF. Indiquez les noms des pages en entrée et en sortie ainsi que la destination, ou acceptez les noms par défaut créés à partir du nom de l'objet d'intégration. Vous pouvez également Remplacer les fichiers existants en cochant la case appropriée. Une fois les sélections effectuées, cliquez sur Suivant.
Lorsque vous créez des pages Web JSF, vous définissez deux pages : une page en entrée, qui regroupe les données requises par l'objet d'intégration, et une page en sortie, qui présente les résultats après l'exécution de l'objet d'intégration.
Pour la page d'entrée, vous pouvez définir un contrôle d'entrée pour chaque propriété d'entrée. Pour modifier un contrôle, sélectionnez une propriété d'entrée et cliquez sur Modifier. Vous pouvez ajouter un texte de début pour le contrôle et, si nécessaire, configurer le contrôle sélectionné. Cliquez sur Suivant.
Pour la page de sortie, vous pouvez choisir les propriétés de sortie de l'objet d'intégration que vous souhaitez afficher. Pour modifier un contrôle, sélectionnez une propriété de sortie et cliquez sur Modifier. Vous pouvez indiquer un texte de début pour le contrôle. Cliquez sur Fin.
Les pages que vous créez sont stockées dans le répertoire Web Content/JSF Pages, dans la vue Projets HATS. Pour modifier une page Web et appeler Page Designer, cliquez deux fois sur le nom de la page. Pour tester vos pages, cliquez avec le bouton droit sur la page en entrée (ou sur la page de sortie, à défaut de page d'entrée) et sélectionnez Déboguer sur le serveur ou Exécuter sur le serveur.
Le fichier BasicIOErrorPage est la page d'erreur par défaut utilisée par les fichiers JSP qui pilotent les objets d'intégration. Lorsqu'une erreur se produit, cette page renvoie au navigateur des informations de base sur la nature de l'erreur. La connexion centrale est automatiquement supprimée lors de ce traitement.
Le fichier AdvancedIOErrorPage.jsp permet à la connexion d'être transmise au servlet d'entrée HATS pour une transformation par défaut si la connexion a été créée à partir de la définition de connexion par défaut. Ce traitement vous permet d'interagir avec la connexion centrale et éventuellement de déterminer pourquoi l'erreur s'est produite. La transformation par défaut vous donne également la possibilité de déconnecter la connexion. En fait, le fichier AdvancedIOErrorPage.jsp vous donne davantage de contrôle sur le traitement lorsqu'un objet d'intégration rencontre une erreur.
Vous pouvez trouver ces pages d'erreur dans la vueNavigateur dans le dossier Contenu Web de votre projet.
Ces fonctions des outils HATS sont applicables à la gestion des objets d'intégration sur les pages JSP. Vous pouvez sélectionner les options ci-après dans le menu Outils HATS de la barre de menus HATS Toolkit.
Vous pouvez ajouter une entrée et une sortie d'objet d'intégration dans la page JSP d'une transformation.
Pour ajouter une entrée d'objet d'intégration dans une page JSP, sélectionnez Insérer des propriétés d'objet d'intégration > Entrée. Dans la page Sélectionnez une classe d'objets d'intégration, entrez le nom de classe de l'objet d'intégration que vous souhaitez utiliser ainsi que la page de destination qui doit s'afficher lorsque l'utilisateur soumet le formulaire d'entrée. Cliquez sur Suivant. Dans la page Définir les pages en entrée, pour modifier un contrôle, sélectionnez une propriété d'entrée et cliquez sur Modifier. Vous pouvez alors définir le texte de début, choisir un contrôle d'entrée approprié et le configurer si nécessaire, et enregistrer la valeur en tant que variable globale.
Pour ajouter une sortie d'objet d'intégration dans une page JSP, sélectionnez Insérer des propriétés d'objet d'intégration > Sortie. Dans la page Sélectionnez une classe d'objets d'intégration, entrez le nom de classe de l'objet d'intégration que vous souhaitez utiliser et cochez la case Insertion de méthodes de transaction d'objet d'intégration pour inclure les méthodes de transaction qui exécutent les objets d'intégration. Cliquez sur Suivant. Dans la page Définir les pages en sortie, pour modifier un contrôle, sélectionnez une propriété de sortie et cliquez sur Modifier. Vous pouvez définir un texte de début et sélectionner le contrôle de sortie approprié.
Une variable globale HATS contient une valeur qui peut être utilisée pour transmettre des informations d'un objet HATS à un autre. Pour transmettre les données de sortie d'un objet d'intégration à un autre objet HATS, vous devez ajouter du code dans la page JSP de sortie pour diriger l'objet d'intégration. Il convient d'ajouter ce code après avoir exécuté l'objet d'intégration avec succès, par exemple :
<% IOGV.setGlobalVariableString(session, "exampleGV", exampleIO.getOutputData()); %>
Dans cet exemple, la variable globale partagée nommée exampleGV prend la valeur de la propriété OutputData de l'objet d'intégration exampleIO.
Une variable globale utilisée dans un objet d'intégration doit être définie en tant que variable globale partagée. Le code de l'exemple crée la variable globale partagée si elle n'existe pas déjà.
Sélectionnez Insérer un réacheminement vers l'application HATS pour ajouter à votre transformation un bouton permettant de renvoyer les informations de contrôle de la page JSP à l'application HATS, soit une application Web ou un portlet standard, démarrée par l'utilisateur. Par exemple, vous voudrez peut-être retourner le contrôle à l'application HATS après le pilotage d'un objet d'intégration et l'exécution d'une tâche donnée par une page JSP. Vous pouvez modifier les attributs de ce bouton dans la vue Conception en mettant en évidence le bouton, en cliquant dessus avec le bouton droit de la souris et en sélectionnant Attributs.