Utilisation de HATS (Host Access Transformation Services)

Vous pouvez utiliser IBM® Rational Host Access Transformation Services (HATS), pour créer des applications Web, incluant des portlets, et des applications client enrichi qui proposent une interface graphique conviviale pour les applications 3270 exécutées sur les plateformes IBM System z et pour les applications 5250 exécutées sur les plateformes IBM i. Les applications HATS peuvent accéder aux applications 5250 sans capacité OLTP (Online Transaction Processing). Dans ce guide, les applications 3270 et 5250 basées sur des caractères sont appelées applications hôte. Vous pouvez également créer des ressources SOA (architecture orientée services) à l'aide de services Web qui fournissent des interfaces de programmation standard aux transactions et à la logique applicative incluses dans les applications hôte. Les données des écrans d'émulation de terminal virtuel (VT) sont également accessibles de cette manière.

Les applications HATS peuvent bénéficier d'une présentation moderne. Les applications Web HATS, notamment les portlets, peuvent être développées à l'aide d'une interface correspondant au portail ou aux pages Web de votre société et les utilisateurs peuvent y accéder à partir de leurs navigateurs Web. Les applications Web HATS peuvent également être développées pour permettre l'accès à vos applications hôte à partir d'unités mobiles telles que des téléphones portables, des terminaux de collecte de données et des assistants électroniques de poche (PDA).

Les applications HATS client enrichi peuvent être développées de manière à être exécutées dans une implémentation de plateforme client enrichi Eclipse (RCP), dans Lotus Notes ou dans Lotus Expeditor Client afin de fournir des applications client natives ciblées pour le bureau d'un utilisateur. Pour plus d'informations sur l'environnement de plateforme enrichi Eclipse, voir http://www.eclipse.org/home/categories/rcp.php. Pour plus d'informations sur Lotus Notes, voir le centre de documentation Lotus Notes à l'adressehttp://publib.boulder.ibm.com/infocenter/domhelp/v8r0/index.jsp. Pour plus d'informations sur Lotus Expeditor Client, voir le centre de documentation Lotus Expeditor à l'adresse http://publib.boulder.ibm.com/infocenter/ledoc/v6r2/index.jsp.

Pour plus d'informations sur les nouveautés de HATS V7.5.1, voir Guide d’initiation HATS.

Remarque :
Dans ce document, les paramètres de configuration qui s'appliquent uniquement aux applications Web HATS, et notamment les portlets et les applications EJB, sont accompagnés de la mention  Web uniquement , sauf indication contraire. Les paramètres de configuration qui ne s'appliquent qu'aux applications de plateforme client enrichi HATS sont marqués  plateforme client enrichi uniquement .

HATS comprend deux composants :

Pour plus d'informations, voir Développement et déploiement d'applications Web HATS et Développement et déploiement d'applications client enrichi HATS.

Présentation des concepts et objets de base HATS

Cette section présente les concepts et objets de base de HATS. D'autres informations sont fournies dans la section Traitement des applications par HATS. De nombreux objets de base de HATS sont créés via un assistant, mais sont visualisés ou modifiés via un éditeur après leur création.

Projet
Ensemble de ressources HATS (également appelées artefacts) créées à l'aide d'assistants de HATS Toolkit et personnalisées à l'aide des éditeurs de HATS Toolkit. Ces ressources sont exportées sous la forme d'une application HATS. Il existe cinq types de projet HATS : Web, portlet, EJB, client enrichi et dans le but d'administrer les applications Web HATS (notamment portlet et EJB), et les projets de console d'administration HATS. Pour plus d'informations, voir Développement et déploiement d'applications Web HATS.
Evénement
Ressource HATS qui effectue un ensemble d'actions en fonction d'un certain état atteint. Il existe deux types d'événement HATS, les événements d'application et les événements d'écran.
Evénement d'application
Evénement HATS déclenché par des modifications d'état dans le cycle de vie de l'application. L'accès par un utilisateur à une application HATS (événement de démarrage) ou la rencontre d'un écran non reconnu par une application (événement d'écran sans correspondance) sont des exemples d'événements liés à l'application. Pour plus d'informations, voir Evénements d'application.
Evénement d'écran
Evénement HATS déclenché lorsqu'un écran hôte est reconnu par les critères de reconnaissance d'écran spécifique correspondants. Il existe deux types d'événements d'écran : les personnalisations d'écran et les combinaisons d'écrans.
Personnalisation d'écran
événement d'écran HATS conçu pour exécuter une série d'actions lorsqu'un écran hôte est reconnu. La reconnaissance d'un écran et sa transformation en interface graphique pour l'utilisateur ou la lecture d'une macro permettant d'ignorer l'écran constituent des personnalisations d'écran. La définition de personnalisation d'écran comprend un ensemble de critères de reconnaissance d'écran et une liste d'actions à entreprendre en cas de correspondance d'un écran hôte aux critères de reconnaissance d'écran. Des règles globales au niveau écran et des paramètres de remplacement de texte sont également proposées. Pour plus d'informations, voir Utilisation des événements d'écran.
Combinaison d'écran
Evénement événement d'écran conçu pour regrouper les données en sortie de plusieurs écrans hôte consécutifs, similaires, les combiner et les afficher sous la forme d'une page de sortie unique. Une combinaison d'écran peut, par exemple, reconnaître un écran ne contenant que des données partielles et se déplacer dans les écrans suivants afin de collecter les données restantes et les afficher à l'intention de l'utilisateur. La définition de combinaison d'écran comprend un ensemble de critères de reconnaissance d'écran pour le premier et le dernier écrans à combiner, le mode de déplacement d'un écran à l'autre, ainsi que le composant et l'objet fenêtre à utiliser pour reconnaître et rendre les données collectées dans chaque écran. Par ailleurs, il comporte une liste d'actions à exécuter une ou plusieurs fois, des règles globales au niveau écran, ainsi que des paramètres de remplacement de texte. Pour plus d'informations, voir Utilisation des événements d'écran.
Critères de reconnaissance d'écran
Lorsque vous créez une événement d'écran, vous définissez les critères de reconnaissance d'écran qui sont utilisés par HATS pour un ou plusieurs écrans. La reconnaissance des écrans hôte peut s'effectuer via n'importe quelle combinaison de critères, notamment le nombre de zones ou de zones d'entrée de l'écran, les coordonnées du curseur et les chaînes de texte présentes dans un rectangle défini ou n'importe où dans l'écran. Vous pouvez également utiliser des variables globales et des couleurs, comparer une zone d'écran à une valeur et comparer une zone d'écran aux critères de zone d'écran comme critères de reconnaissance d'écran.

Lorsqu'un système hôte affiche un écran, HATS détermine si cet écran hôte répond à l'un des critères de reconnaissance définis dans chaque événement d'écran de votre projet. Si HATS trouve une correspondance, les actions définies pour la événement d'écran sont exécutées.

Pour plus d'informations sur la définition des critères de reconnaissance d'écran, voir Critères de reconnaissance d'écran ou Début d'écran.

Action
Opération qui doit être exécutée lorsqu'un événement se produit (par exemple, lorsqu'un écran hôte correspond aux critères de reconnaissance d'écran indiqués pour une événement d'écran). Chaque événement d'application et de événement d'écran comporte dans sa définition une liste d'actions.
Transformation
Fichier JSP (JavaServer Pages (pour les projets Web) ou composite SWT (Standard Widgets Toolkit) (pour les projets client enrichi) qui définit la manière dont les composants hôte doivent être extraits et affichés à l'aide d'objets fenêtre dans une interface graphique. L'application d'une transformation est l'une des actions possibles pour une événement d'écran. Vous pouvez éditer les transformations en mode tel écran - tel écrit, en faisant glisser les composants HATS à partir de la palette et en modifiant les paramètres dans la vue Propriétés de HATS. L'éditeur d'application client Java™ (VE), également appelé Visual Editor, doit être installé pour pouvoir modifier les transformations client enrichi en mode WYSIWYG.

Pour plus d'informations sur la création de transformations, voir Gestion des transformations.

Composants hôte
Les Composants hôte sont des objets HATS qui effectuent la reconnaissance des éléments de l'écran hôte (tels que les lignes de commande, les touches de fonction, etc.) que vous présentez à l'utilisateur final de l'application HATS. Vous pouvez utiliser le composants hôte fourni par HATS ou en créer un.

Pour plus d'informations sur la sélection des composants hôte à utiliser avec votre projet HATS, voir Insertion d'un composant hôte.

Pour plus d'informations sur l'utilisation de l'assistant pour la création de composants et d'objets fenêtre personnalisés, voir HATS Web Application Programmer's Guide ou HATS Rich Client Platform Programmer's Guide, selon l'environnement d'application utilisé.

Objets fenêtre
Les objets fenêtre sont des objets HATS qui créent les sorties interface graphique des composants hôte dans la présentation HATS. Par exemple, vous pouvez convertir les composants hôte de type touche de fonction en objets fenêtre de type bouton de fonction afin que l'utilisateur final voit les touches de fonction sous forme de boutons de fonction dans l'application HATS. Vous pouvez utiliser les objets fenêtre fournis avec HATS ou en créer de nouveaux en fonction e vos besoins.

Pour plus d'informations sur la sélection des objets fenêtre à utiliser avec votre projet HATS, voir Insertion d'un composant hôte.

Pour plus d'informations sur l'utilisation de l'assistant pour la création de composants et d'objets fenêtre personnalisés, voir HATS Web Application Programmer's Guide ou HATS Rich Client Platform Programmer's Guide, selon l'environnement d'application utilisé.

Connexion
Jeu de paramètres utilisé par HATS pour la connexion aux applications hôte. HATS comporte deux types de connexion : la connexion par défaut (ou la connexion de transformation) et la connexion d'arrière-plan. Chaque application HATS possède une connexion de transformation pour l'application hôte dont les écrans seront transformés par HATS. Les connexions d'arrière-plan désignent toute connexion définie dans une application HATS autre que la connexion par défaut. HATS ne transforme pas les écrans provenant des connexions d'arrière-plan. Il est possible, toutefois, de sélectionner de manière dynamique la connexion à utiliser comme connexion par défaut. Pour plus d'informations, voir Gestion des connexions.
Règles globales
Règles spécifiant le remplacement au niveau de l'écran ou au niveau du projet d'un certain type de zone d'entrée hôte par un objet fenêtre particulier en utilisant des fragments de transformation. Ces fragments de transformation contiennent les données que vous souhaitez utiliser pour remplacer toutes les occurrences d'un masque dans une transformation donnée.
Remarque :
Il est possible de désactiver les règles globales dans le cadre d'une utilisation spécifique d'une transformation en éditant l'action de transformation d'une événement d'écran.

Pour plus d'informations, voir Rendu.

Rendu par défaut
Méthode utilisée par HATS pour effectuer le rendu d'un écran hôte pour lequel il n'existe aucune événement d'écran spécifique. Le rendu par défaut peut également être utilisé dans une transformation spécifique à appliquer à une zone définie d'un écran hôte. Pour plus d'informations, voir Rendu.
Remplacement de texte
Le remplacement de texte est utilisé au niveau du projet ou de l'écran pour transformer le texte qui apparaît sur les écrans hôte en images,  Web uniquement  HTML ou en un autre texte dans la transformation d'interface graphique. Pour plus d'informations, voir Remplacement de texte.
Modèle
Fichier JSP (pour les projets Web) ou classe composite Java SWT (pour les projets de client enrichi) qui permet d'améliorer l'apparence de votre projet. Lors de la création d'un projet HATS, vous sélectionnez un modèle à utiliser par défaut pour le projet. Ce modèle peut contenir des logos et informations d'entreprise, ainsi que des liens vers d'autres pages Web. Vous pouvez sélectionner votre modèle par défaut parmi ceux fournis avec HATS ou créer des modèles personnalisés à l'aide des assistants et de l'éditeur deHATS Toolkit. Vous pouvez également créer un modèle pré-rempli à partir d'un fichier existant ou, pour les projets Web, d'une URL..

Dans l'interface graphique, le modèle entoure la zone dans laquelle la transformation apparaît. Vous pouvez appliquer un modèle autre que le modèle par défaut comme résultat d'une événement d'écran. Pour plus d'informations sur l'association d'un modèle à une transformation, voir Utilisation des modèles.

Logique applicative
Tout code Java appelé en tant qu'action dans un événement (personnalisation d'écran, par exemple). La logique applicative est propre à l'application.

Pour plus d'informations sur la logique applicative, voir HATS Web Application Programmer's Guide ou HATS Rich Client Platform Programmer's Guide, selon l'environnement d'application utilisé.

Variable globale
Variable utilisée pour stocker une valeur pouvant être utilisée durant toute la durée de vie d'une instance d'application HATS. La valeur d'une variable globale peut être extraite à partir d'un écran hôte ou définie par le développeur. Les variables globales peuvent être utilisées dans les modèles, les transformations, les actions de événement d'écran ou les critères de reconnaissance. Elles peuvent également être partagées entre des applications Web dans un fichier d'archive d'entreprise (.ear) ou entre des applications client enrichi exécutées dans le même environnement client enrichi. Elles peuvent en outre être indexées et utilisées dans des macros, dans une logique applicative ou dans des objets d'intégration.

Pour plus d'informations sur les variables globales, voir Interaction avec les variables globales.

Macro
Script XML définissant un ensemble d'écrans et certaines actions devant être entreprises sur ces écrans. Une macro permet d'automatiser les interactions de l'utilisateur avec l'hôte. Vous pouvez enregistrer et exécuter des macros permettant de sauter des écrans, d'effectuer une boucle, d'inviter les utilisateurs à saisir des données (ou d'insérer des données vous-même ou à l'aide de variables globales) ou d'extraire des informations de l'écran hôte.

Vous pouvez utiliser les macros de différentes façons dans une application HATS :

Pour plus d'informations sur l'incorporation de macros dans l'environnement HATS, voir Macros et terminal hôte.

Objets d'intégration
Objets Java créés à partir d'une macro pouvant être utilisés comme blocs de construction pour les applications WebSphere. Les objets d'intégration sont des beans Java qui encapsulent les interactions avec des sources de données hôte. Ces sources de données incluent les applications orientées terminal qui utilisent des données 3270, 5250 et de terminal virtuel.

Il est possible de regrouper les objets d'intégration partageant la même connexion pour achever une tâche majeure dans l'application HATS. Il s'agit alors d'un enchaînement d'objets d'intégration. Pour plus d'informations, voir Utilisation des objets d'intégration.

Terminal hôte
Connexion dans le HATS Toolkit à un hôte interactif. Le terminal hôte vous permet de capturer des écrans, de créer des événements d'écran et transformations et d'enregistrer et d'éditer des macros. Il permet également d'exécuter des macros préalablement enregistrées ou importées. Il vous permet enfin de prévisualiser un écran sous forme d'interface graphique.
Terminal d'affichage
Fenêtre de terminal affichant les écrans hôte que vous pouvez utiliser pour les opérations de test et de débogage afin d'observer les interactions entre une application HATS et une application hôte au moment de l'exécution. Vous pouvez également interagir avec l'application hôte en utilisant les écrans hôte dans la fenêtre de terminal. Pour plus d'informations sur le terminal d'affichage, voir Utilisation de l'affichage du terminal pour des opérations de test et de débogage.
Capture d'écran
Représentation XML d'un écran hôte, utilisée pour créer ou adapter une événement d'écran, une transformation ou une règle globale.
Exécuter sur le serveur  Web uniquement 
Fonction de Rational SDP qui permet de tester vos projets HATS Web et de portlet dans une instance WebSphere Application Server ou WebSphere Portal, selon la situation appropriée. Vous avez alors la possibilité de modifier et de tester les paramètres d'exécution, définis dans le fichier runtime.properties, qui sont déployés dans l'environnement d'exécution. Toutes les modifications apportées aux paramètres d'exécution au cours d'un test effectué via ce mode seront conservées et prendront effet lors du déploiement de l'application HATS dans un environnement d'exécution. Pour plus d'informations sur la modification des paramètres d'exécution, voir Gestion des éléments d'identification des incidents.
Déboguer sur le serveur  Web uniquement 
Fonctionne de la même façon que le mode Exécuter sur le serveur, mais permet en outre :
Profil sur le serveur  Web uniquement 
Fonctionne de la même façon que le mode Exécuter sur le serveur, mais vous permet en outre de localiser les opérations qui demandent le plus de temps et d'identifier les actions répétées afin d'éliminer la redondance. Vous pouvez utiliser cette fonction pour l'analyse des performances, afin de mieux appréhender le fonctionnement de votre application.
Exécuter  plateforme client enrichi uniquement 
Fonction de Rational SDP qui permet de tester vos projets de client enrichi HATS dans une instance Eclipse, Lotus Notes ou Lotus Expeditor Client. Vous avez alors la possibilité de modifier et de tester les paramètres d'exécution, définis dans le fichier runtime.properties, qui sont déployés dans l'environnement d'exécution. Toutes les modifications apportées aux paramètres d'exécution au cours d'un test effectué via ce mode seront conservées et prendront effet lors du déploiement de l'application HATS dans un environnement d'exécution. Pour plus d'informations sur la modification des paramètres d'exécution, voir Administration des applications client enrichi HATS.
Déboguer  plateforme client enrichi uniquement 
Fonctionne de la même façon que le mode Exécuter, mais permet en outre :
Profil de  plateforme client enrichi uniquement 
Fonctionne de la même façon que le mode Exécuter, mais vous permet en outre de localiser les opérations qui demandent le plus de temps et d'identifier les actions répétées afin d'éliminer la redondance. Vous pouvez utiliser cette fonction pour l'analyse des performances, afin de mieux appréhender le fonctionnement de votre application.
Support d'impression
Possibilité pour un développeur de spécifier une session d'impression devant être associée à une session hôte et de permettre à l'utilisateur de visualiser les travaux d'impression de l'application hôte, de les envoyer en impression ou de les enregistrer sur un disque. Le support d'impression est disponible uniquement pour la connexion par défaut.

Pour plus d'informations sur le support d'impression, voir Activation du support d'impression.

Support clavier
Possibilité pour un développeur de permettre à l'utilisateur d'utiliser un clavier physique pour dialoguer avec l'hôte lors de l'exécution de l'application dans une interface graphique. Le développeur décide également s'il doit inclure un bloc de touches hôte, un bloc de touches application ou les deux dans un projet. S'il inclut des blocs de touches, le développeur doit définir les touches qu'ils contiendront et la façon dont ces touches et ces blocs apparaîtront dans l'interface graphique.

Pour plus d'informations sur le support clavier, voir Activation du support clavier.

Support bloc de touches
Le bloc de touches hôte est un tableau de boutons ou de liens qui permet à l'utilisateur de dialoguer avec l'hôte comme s'il appuyait sur les touches d'un clavier réel. Cependant, l'utilisateur a toujours la possibilité d'utiliser les touches de son clavier réel à la place des boutons ou liens du bloc de touches hôte. Pour plus d'informations sur le bloc de touches hôte, voir Bloc de touches hôte

Le bloc de touches application est un tableau de boutons ou de liens qui permet à l'utilisateur d'exécuter des tâches liées à l'application, telles que la visualisation des travaux d'impression ou le rafraîchissement de l'écran. Pour plus d'informations sur le bloc de touches application, voir Bloc de touches application.

Traitement des applications par HATS

Avant de créer un projet HATS, vous devez comprendre la façon dont HATS effectue le traitement des applications hôte. Au fur et à mesure que les utilisateurs accèdent aux écrans d'une application, HATS traite cette dernière comme indiqué ci-après. La figure 1 présente les diverses étapes de traitement. Pour les concepts de base, voir Présentation des concepts et objets de base HATS.

  1. Lorsque l'hôte affiche un écran, HATS le compare à l'ensemble de critères de reconnaissance d'écran définis dans chacune des personnalisations d'écran activées pour le projet, dans l'ordre défini par la priorité des événements, jusqu'à ce qu'il trouve une correspondance.
  2. Lorsque HATS trouve une correspondance, il exécute les actions définies dans la événement d'écran. Pour les événements de personnalisation d'écran ou de combinaison d'écran, il peut s'agir des actions répertoriées ci-dessous. En outre, dans le cas d'un événement de combinaison d'écran, HATS se déplace à travers les différents écrans afin de collecter dans chaque écran les données à afficher à l'intention de l'utilisateur. Pour plus d'informations, voir Actions.
    Remarques :
    1. Lorsqu'un écran correspondant est trouvé, une action au moins doit être exécutée, mais la transformation de l'écran n'est pas obligatoire pour l'affichage à l'intention de l'utilisateur. En d'autres termes, l'action d'application d'une transformation n'est pas obligatoire.
    2. Vous pouvez exécuter des actions sur les données de l'écran hôte avant ou après l'interaction de l'utilisateur. Vous pouvez ainsi extraire certaines données sous forme de variable globale et remplacer des informations par de nouvelles données, puis appliquer la transformation avant de la montrer à l'utilisateur. Ensuite, une fois que l'utilisateur a effectué une action qui renvoie les données de l'écran, vous pouvez, si vous le souhaitez, procéder à des extractions et des insertions supplémentaires avant que les données soient finalement renvoyées à l'hôte.
  3. Si l'écran hôte ne correspond à aucun critère de reconnaissance d'écran, HATS effectue le traitement correspondant à l'événement d'application absence de correspondance. L'action par défaut exécutée dans le cadre de cet événement est l'affichage de l'écran hôte en utilisant la transformation par défaut et en appliquant le modèle par défaut. La transformation par défaut utilise les paramètres de rendu définis dans les paramètres du projet.
  4. Au fur et à mesure que l'hôte présente chaque nouvel écran d'une application, HATS repart de l'étape 1 et exécute de nouveau toutes les étapes indiquées précédemment. La figure 1 illustre la façon dont HATS effectue le traitement des écrans.
    Remarque :
    Si une macro utilise le mode consistant à sauter des écrans, ces écrans ne font pas l'objet de la procédure décrite.

Figure 1. Traitement des écrans par HATS
Organigramme du traitement des écrans effectué par HATS

Les événements d'écran constituent un élément important du développement d'un projet HATS. Si vous ne définissez pas de critères de reconnaissance d'écran dans une événement d'écran, HATS ne sait pas quelles actions exécuter lors de la réception de l'écran.

Il est nécessaire de se familiariser avec les principes de base de la événements d'écran avant d'entamer le processus de développement d'un projet. Pour connaître les éléments de base de la définition des critères de reconnaissance d'écran, voir Utilisation des événements d'écran.

Traitement des applications par HATS

HATS vous permet de développer une application en utilisant une approche progressive. Vous pouvez démarrer avec une configuration simple et ajouter des améliorations au fur et à mesure que vous le souhaitez. Vous pouvez tester chaque modification apportée dans l'environnement de test de Rational SDP. Il est possible de visualiser la plupart des modifications en effectuant une simple régénération de la transformation HATS. Vous pouvez apporter les modifications nécessaires et enregistrer votre travail avant de passer à la suivante. Cette section présente certaines séquences d'étapes que vous pouvez utiliser pour la conception et le développement de votre application HATS. Vous pouvez aller aussi loin que vous le souhaitez dans ce processus et vous arrêter à tout moment.

  1. Commencez par créer une application HATS utilisant toutes les valeurs par défaut et observez immédiatement le résultat de vos écrans hôte dans une interface graphique. Le rendu par défaut vous permet d'afficher les écrans hôte dans un format qui préserve la présentation initiale de l'écran hôte et d'ajouter automatiquement des contrôles d'interface graphique, par exemple des liens, des boutons et des tables, qui permettront à l'utilisateur d'améliorer sa productivité.
  2. Créez un modèle correspondant aux pages Web de votre entreprise ou à d'autres applications de l'entreprise et observez le rendu de vos écrans hôte avec la présentation de votre société. Vous pouvez commencer avec l'un des modèles fournis avec HATS et le modifier ou, pour les applications Web HATS, vous pouvez importer le site Web de votre entreprise comme modèle. Voir Utilisation des modèles pour plus d'informations. Votre application HATS possède désormais l'aspect et les couleurs des pages Web de votre société ou d'autres applications de l'entreprise.
  3. Configurez des paramètres au niveau du projet (ensemble de l'application) et déterminez la portion de l'application hôte qui peut être gérée sans qu'il soit nécessaire de configurer des écrans spécifiques. Vous pouvez modifier les caractéristiques au niveau du projet grâce aux différents onglets disponibles dans les Paramètres de projet. Pour plus d'informations, voir Modification d'un projet HATS. Essayez d'effectuer quelques modifications telles que les suivantes :
  4. Créez des événements au niveau écran afin de reconnaître des écrans hôte spécifiques et de déclencher une série d'actions à exécuter.
  5. Créez des macros simples pour aider l'utilisateur à se déplacer dans l'application hôte. Des macros peuvent être utilisées pour exécuter des fonctions ignorant certains écrans, pour inviter l'utilisateur à entrer des données ou pour extraire des données d'un ou plusieurs écrans hôte. Pour plus d'informations, voir Macros et terminal hôte.
  6. Pour les applications Web, créez des objets d'intégration, élaborés à partir de macros, qui sont des beans Java encapsulant des interactions avec une application hôte. Servez-vous ensuite des objets d'intégration pour créer des pages Web Modèle 1, Struts ou JavaServer Faces (JSF) Web afin de contrôler les interactions avec votre application hôte. Vous pouvez également exécuter les objets d'intégration à partir de votre propre logique applicative Java ou les étendre afin de fournir des EJB (Enterprise JavaBeans™) ou des interfaces de services Web à votre application hôte. Pour plus d'informations, voir Utilisation des objets d'intégration.

Comment connaître la version de HATS ?

Vous pouvez déterminer la version de HATS Toolkit et de chacun de vos projets HATS.

Pour déterminer la version de HATS Toolkit que vous utilisez, vérifiez les packages installés IBM Installation Manager :

  1. Lancez IBM Installation Manager.
  2. Dans la barre de menus, sélectionnez Fichier > Afficher les packages installés.

Le panneau Packages installés affiche la version du Toolkit HATS installé.

Vous pouvez déterminer la version (y compris le niveau de maintenance) de chaque projet HATS. Ces informations sur la version sont conservées pour chaque projet dans un fichier nommé .serviceHistory.xml. Ce fichier peut être consulté à partir de la vue Navigator de la perspective HATS dans le dossier Web Content\WEB-INF\profiles (pour les projets Web et portlets), le dossier profiles (pour les projets client enrichi) et le dossier ejbModule (pour les projets EJB).

Les informations de version pour les projets HATS .ear et pour le projet d'extension d'exécution HATS RCP sont conservées dans le fichier product.xml. Ce fichier peut être consulté à partir de la vue Navigator dans le dossier principal du projet.

Regroupement des informations relatives à l'identification des incidents

Vous aurez peut-être parfois besoin d'avoir recours à une assistance pour identifier certains incidents liés à HATS. Afin de rassembler les informations générales nécessaires à l'attention du support de HATS, sélectionnez, dans la barre d'outils de HATS Toolkit HATS > Regrouper des informations relatives à l'identification des incidents pour lancer l'assistant.

Une fenêtre s'ouvre et indique la liste de tous vos projets. Sélectionnez le projet ou les projets que vous souhaitez inclure. Indiquez la destination du fichier zip que vous désirez utiliser pour capturer les informations demandées et cliquez sur Fin. Les informations contenues dans ce fichier zip aideront le support de HATS à identifier les incidents.

Pour savoir comment l'utilisateur peut collecter les informations de résolution d'incidents dans un environnement de production client enrichi, voir >Préférences d'identification des incidents.

Pour des instructions sur la collecte d'informations spécifiques pour certains scénarios d'incidents, voir la section Regroupement des informations relatives à l'identification des incidents dans le Guide d'identification des incidents de HATS.

Où trouver des informations concernant HATS ?

Les informations concernant HATS sont disponibles avant de procéder à son installation :

De plus, les informations suivantes sont disponibles sur le système après l'installation de HATS :