Utilisation des objets d'intégration

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.

Remarque :
Les variables et modèles globaux ne sont pas pris en charge pour les objets d'intégration utilisant les portlets HATS standard.

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 :

Création d'un objet d'intégration

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.

Remarques :
  1. Les objets d'intégration générés automatiquement ne sont jamais de type enchaînement.
  2. Pour plus d'informations sur la création d'objets d'intégration en utilisant un support DBCS, voir Création d'un objet d'intégration.

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.

Remarque :
Le dossier IntegrationObject, situé Source, n'apparaît que lorsque vous avez créé votre premier objet d'intégration.

Enchaînement d'objets d'intégration

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.

Choix du moment approprié pour utiliser l'enchaînement d'objets d'intégration

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 :

  1. Obtention de la liste de fichiers à présenter à l'utilisateur
  2. Extraction des détails concernant le fichier sélectionné

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.

Utilisation de l'enchaînement d'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.

Figure 64. Durée de vie de la connexion avec un enchaînement
Durée de vie de la connexion avec un enchaînement

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é.

  1. Lorsque l'objet d'intégration A commence à s'exécuter, il récupère la connexion indiquée dans la macro. Si l'écran de restitution est activé et qu'une connexion est disponible, la connexion est déjà connectée et prête. Si l'écran de restitution est activé, mais qu'aucune connexion n'est disponible, la connexion est créée et la macro de connexion (si elle est précisée) est exécutée. Si l'écran de restitution est désactivé, une connexion est créée et la macro de connexion (si elle est précisée) est exécutée.
  2. L'objet d'intégration A exécute la macro qui lui est associée, puis sauvegarde la connexion et son état actuel en vue de l'appel suivant. (Vous aurez défini cet état comme libellé d'état de fin lors de la définition de l'enchaînement d'objets d'intégration.)
  3. Lorsque l'objet d'intégration B commence à s'exécuter, il récupère la connexion et son état dans les données d'état de la connexion car il s'agit de l'objet d'intégration intermédiaire. Vous devez avoir défini le libellé d'état de début de l'objet d'intégration B comme étant le libellé d'état de fin de l'objet d'intégration A, ce qui permet l'enchaînement de ces objets d'intégration.
  4. Lorsque l'exécution de l'objet d'intégration B est terminée, la connexion et son état sont sauvegardées dans les données d'état de la connexion.
  5. L'objet d'intégration C récupère également la connexion à partir des données d'état de la connexion. Lorsque l'objet d'intégration C commence à s'exécuter, il récupère la connexion et son état dans les données d'état de connexion car il s'agit du dernier objet d'intégration. Vous devez avoir défini le libellé d'état de début de l'objet d'intégration C comme étant le libellé d'état de fin de l'objet d'intégration B, ce qui permet l'enchaînement de ces objets d'intégration. Le dernier objet d'intégration d'une chaîne n'a pas de libellé de fin car la connexion est toujours retournée.
  6. Si l'écran de restitution est activé, la connexion retourne dans le pool ; sinon, la macro de déconnexion (le cas échéant) est exécutée et la connexion est interrompue.
Remarque :
Pour paramétrer l'écran de restitution, accédez à l'onglet Macro des paramètres de connexion. Vous devez activer le regroupement de connexions pour pouvoir accéder aux paramètres de l'écran de restitution. Pour plus d'informations, voir Editeur de connexion.

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 :

  1. Enregistrement de macros
  2. Création d'objets d'intégration d'enchaînement à partir de chaque macro
  3. Création de pages Web pour chaque objet d'intégration
Enregistrement de macro

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.

Création d'objets d'intégration à partir de chaque macro
Une fois que toutes vos macros sont créées, vous pouvez sélectionner l'onglet Vue des projets HATS de HATS Toolkit et développer le nom de votre projet, puis ouvrir le dossier Macros.

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.

Création de pages Web à partir de chaque objet d'intégration
Une fois que vous avez créé vos objets d'intégration, vous pouvez créer vos pages Web. Pour plus d'informations sur la création de pages Web à partir d'objets d'intégration, voir Création de pages Web à partir d'un objet d'intégration.

Débogage des applications qui utilisent l'enchaînement des objets d'intégration

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 :

HPS5075 Réception de STATE_PLAY_ERROR lors de l'exécution de la macro dans le fichier zzz.macro
Cette erreur se produit lorsque la macro échoue parce qu'elle ne trouve pas de correspondance avec l'écran actif. Cela peut se produire si un objet d'intégration d'une chaîne est appelé dans le bon ordre (une connexion d'une chaîne spécifique pouvant être utilisée a été détectée), mais que l'exécution de la macro proprement dite échoue. Cet incident peut se produire si vos libellés d'état de début et de fin sont tous identiques ou s'il sont identiques pour au moins deux objets d'intégration et que vous n'appelez pas les objets d'intégration dans l'ordre logique.
HPS5035 Il n'existe pas d'objet source de données {0} dans HttpSession. Cela peut être dû à l'utilisation de plusieurs navigateurs sur une seule machine dans une application chaînée. Pour plus d'informations, consultez la documentation.
Cette erreur se produit lorsqu'un objet d'intégration ayant un libellé d'état de début de dernier objet d'intégration ne peut pas récupérer la connexion et son état car son libellé d'état de début ne correspond pas au libellé d'état de fin de l'objet d'intégration précédent.

Lorsque cela se produit, déterminez pourquoi cet objet d'intégration n'est pas appelé dans le bon ordre.

Création de pages Web à partir d'un objet d'intégration

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.

Création de pages Web de modèle 1

L'approche traditionnelle de HATS pour créer des pages JSP est appelée modèle 1.

Remarque :
Cette approche est la seule prise en charge pour les portlets HATS standard.

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.

Remarque :
Si votre macro ne comporte pas d'invite, il n'y a pas de page en entrée.

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.

Remarque :
Lors de l'utilisation des pages Web de modèle 1 pour les objets d'intégration dans les projets de type portlet HATS standard, tenez compte des considérations suivantes :

Création de pages Web Struts

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.

Remarque :
Cette approche n'est pas prise en charge pour les portlets HATS standard.

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 :

Classe Action STRUTS
Cette classe est la classe principale. Elle crée une instance de l'objet d'intégration, définit les propriétés d'objet d'intégration à l'aide des valeurs de la classe ActionForm, définit le nom du pool de l'objet d'intégration et exécute l'objet d'intégration. Elle est ensuite transmise à la page JSP en sortie ou, en cas d'erreur, elle est renvoyée au contexte d'exécution HATS afin que celui-ci puisse traiter l'erreur. Le développeur ne peut pas modifier cette classe.
Classe ActionForm
Cette classe contient les méthodes setter et getter de chaque entrée de la page JSP en entrée. La page JSP en entrée est transmise au servlet STRUTS, qui crée une instance de la classe ActionForm et définit toutes ses propriétés en fonction du formulaire JSP en entrée transmis. Cette classe est utilisée par la classe Action pour définir toutes les propriétés de l'objet d'intégration. Si vous ajoutez ou supprimez des propriétés d'entrée de la page JSP en entrée, vous devez ajouter ou supprimer les méthodes setter et getter correspondantes de ce fichier.
Page JSP en entrée
La page JSP en entrée contient un formulaire HTML STRUTS qui va envoyer la demande au contrôleur STRUTS, qui crée une classe ActionForm et transmet la demande à la classe Action appropriée. Si l'objet d'intégration ne requiert aucune entrée, ou si les entrées viennent de sources différentes, telles que des variables globales, une page JSP en entrée vierge est créée, qui contient uniquement le formulaire HTML. La page en entrée est créée dans le dossier Pages STRUTS. Pour tester vos pages, ouvrez ce dossier et recherchez la page que vous avez créée. Cliquez sur la page avec le bouton droit de la souris et sélectionnez Exécuter sur le serveur.
Page JSP en sortie
La page JSP en sortie affiche les propriétés de sortie de l'objet d'intégration. Cette page est similaire à la page JSP en sortie de modèle 1.
WebDiagram
Ce fichier affiche le flux et la logique des pages Web basées sur STRUTS. Pour plus d'informations sur la modification du diagramme Web, reportez-vous à la documentation relative aux outils STRUTS dans Rational SDP.

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.

Création de pages Web JSF

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.

Remarque :
Cette approche n'est pas prise en charge pour les portlets HATS standard et les portlets HATS IBM.

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.

BasicIOErrorPage.jsp et AdvancedIOErrorPage.jsp

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.

Gestion des objets d'intégration sur les pages JSP

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.

Insérer des propriétés d'objet d'intégration

Vous pouvez ajouter une entrée et une sortie d'objet d'intégration dans la page JSP d'une transformation.

Entrée

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.

Sortie

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à.

Insérer un réacheminement vers l'application HATS

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.