Formats des messages d'entrée et de sortie

Vous devez considérer les plateformes où votre application hôte cible et le client Java™ s'exécutent ainsi que les caractéristiques spéciales de vos messages d'entrée et de sortie lorsque vous développez une application utilisant IMS TM Resource Adapter.

L'application Java que vous créez s'exécute sur une plateforme différente (par exemple Windows, AIX ou Solaris) de celle du système d'information d'entreprise (EIS). Le gestionnaire de transactions IMS (IMS TM) est un programme d'application IMS sur z/OS). En raison des différences entre les plateformes, vous devez convertir les données texte au format UNICODE à la sortie du client en données texte au format EBCDIC, qui est utilisé par votre application IMS.

Selon la valeur Endian pour la plateforme où l'application hôte cible s'exécute et la page de codes qui est utilisée par votre système hôte IMS, une conversion de format peut être nécessaire. La valeur par défaut est anglais américain (037).

Recommandation : Laissez l'environnement de développement intégré faire la conversion de format pour vous. Par exemple, l'assistant J2C dans différents environnements de développement WebSphere ou Rational crée des liaisons de données Java à partir des structures de données C, COBOL et PL/I importées. Les liaisons de données effectuent toutes les conversions de données pour vos messages lors de l'exécution. Ces liaisons de données sont créées en fonction des options que vous avez sélectionnées dans l'assistant de l'importateur.

IMS requiert que tous les messages de transaction soient préfixés par une zone LL et une zone ZZ de 2 octets chacune, suivies du code de transaction. La zone LL spécifie la longueur du message. La zone ZZ contient zéro en binaire. Lorsque vous construisez des messages d'entrée pour IMS, vous devez définir la valeur LL à la taille du message d'entrée et la valeur ZZ à 0.

Sortie multi-segment et de longueur variable

Si l'application IMS renvoie une sortie multi-segment ou une sortie avec des longueurs variables, vous pouvez utiliser la définition COBOL OUTPUT-MSG pour définir la sortie de la transaction, ou créer un message de sortie pour elle.

Dans l'application COBOL qui suit, le message de sortie renvoyé par IMS est consitué de trois segments de longueur fixe. Il a une longueur totale fixe de 99 octets et est représenté par la structure COBOL 01 OUTPUT-MSG. OUTPUT-SEG1, OUTPUT-SEG2 et OUTPUT-SEG3 font respectivement 16, 31 et 52 octets de long.
LINKAGE SECTION.
		                                                   
	        01  INPUT-MSG.                                                     
	            02  IN-LL          PICTURE S9(3) COMP.                         
	            02  IN-ZZ          PICTURE S9(3) COMP.                         
	            02  IN-TRCD        PICTURE X(5).                               
	            02  IN-DATA1       PICTURE X(6).
	            02  IN-DATA2       PICTURE X(6).
							  
	        01  OUTPUT-MSG.                                                   
	            02  OUT-ALLSEGS  PICTURE X(99) VALUE SPACES.
	
	        01  OUTPUT-SEG1.
	            02  OUT-LL       PICTURE S9(3) COMP VALUE +0.                 
	            02  OUT-ZZ       PICTURE S9(3) COMP VALUE +0.                  
	            02  OUT-DATA1    PICTURE X(12) VALUE SPACES.
	
	        01  OUTPUT-SEG2.
	            02  OUT-LL       PICTURE S9(3) COMP VALUE +0.                 
	            02  OUT-ZZ       PICTURE S9(3) COMP VALUE +0.                  
	            02  OUT-DATA1    PICTURE X(13) VALUE SPACES.
	            02  OUT-DATA2    PICTURE X(14) VALUE SPACES.
	
	        01  OUTPUT-SEG3.
	            02  OUT-LL       PICTURE S9(3) COMP VALUE +0.                  
	            02  OUT-ZZ       PICTURE S9(3) COMP VALUE +0.                  
	            02  OUT-DATA1    PICTURE X(15) VALUE SPACES.
	            02  OUT-DATA2    PICTURE X(16) VALUE SPACES.
	            02  OUT-DATA3    PICTURE X(17) VALUE SPACES.   
Vous pouvez créer un bean J2C qui exécute la transaction IMS à l'aide de l'assistant J2C :
  • Créez une classe de tampon de message pour stocker le message de sortie renvoyé par l'application IMS.
  • Importez le fichier COBOL pour effectuer le mappage COBOL-Java pour les messages d'entrée et de sortie.
    • Créez l'opération de liaison d'entrée en sélectionnant la structure du message d'entrée (représentée par la structure COBOL 01 INPUT-MSG).
    • Créez les opérations de liaison de sortie pour les segments du message de sortie en utilisant l'assistant de mappage des données, accessible en sélectionnant Fichier > Nouveau > Autre > Liaison de données Java CICS/IMS. Pour chaque segment, avec l'assistant de mappage des données, sélectionnez le segment approprié comme structure de données et spécifiez les paramètres comme la page de codes, le nom endian, le nom quote et le nom trunc.
  • Invoquez la méthode de bean J2C qui exécute la transaction IMS et remplissez les segments de sortie à partir du tampon des données renvoyées par la transaction IMS.
package sample.ims;

import com.ibm.etools.marshall.util.MarshallIntegerUtils;
import sample.ims.data.*;

public class TestMultiSeg
{
	public static void main(String[] args)
	{
		byte[] segBytes = null;
		int srcPos = 0;
		int dstPos = 0;
		int totalLen = 0;
		int remainLen = 0;
		byte[] buff;
		short LL = 0;
		short ZZ = 0;

		try
		{
			// ---------------------------------------------------			
			// Populate the IMS transaction input message with
			// data.  Use the input message format handler method 
			// getSize() to set the LL field of the input message.
			// ---------------------------------------------------					
			InputMsg input = new InputMsg();
			input.setIn__ll((short) input.getSize());
			input.setIn__zz((short) 0);
			//----------------------------------------------
			// find out the transaction code from your IMS 
			// administrator
			//-----------------------------------------------
			input.setIn__trcd("SKS6 ");
			input.setIn__data1("M2 SI1");
			input.setIn__data2("M3 SI1");

			// ---------------------------------------------------			
			// Run the IMS transaction.  The multi-segment output 
			// message is returned.
			// ---------------------------------------------------				
			MSOImpl proxy = new MSOImpl();
			
			sample.ims.CCIBuffer output = proxy.runMultiSegOutput(input);

			// ---------------------------------------------------	
			// Retrieve the multi-segment output message as a 
			// byte array using the output message format
			// handler method getBytes().
			// ---------------------------------------------------			 			
			System.out.println(
				"\nSize of output message is: " + output.getSize());
			segBytes = output.getBytes();

			srcPos = 0;
			dstPos = 0;
			totalLen = segBytes.length;
			remainLen = totalLen;

			// ---------------------------------------------------	
			// Populate first segment object from buffer. 
			// ---------------------------------------			             
			buff = null;
			// Get length of segment.
			LL =
				MarshallIntegerUtils.unmarshallTwoByteIntegerFromBuffer(
					segBytes,
					srcPos,
					true,
					MarshallIntegerUtils.SIGN_CODING_TWOS_COMPLEMENT);

			// Put segment in byte array.
			buff = new byte[LL];
			System.arraycopy(segBytes, srcPos, buff, dstPos, LL);
			remainLen -= LL;

			// Create and populate segment object from byte array.
			OutputSeg1 S1 = new OutputSeg1();
			S1.setBytes(buff);
			System.out.println(
				"\nOutSeg1 LL is:    "
					+ S1.getOut__ll()
					+ "\nOutSeg1 ZZ is:    "
					+ S1.getOut__zz()
					+ "\nOutSeg1_DATA1 is: "
					+ S1.getOut__data1());

			// ---------------------------------------------------	
			// Populate second segment object from buffer. 
			// ---------------------------------------------------	
			srcPos += LL;
			buff = null;
			// Get length of segment.
			LL =
				MarshallIntegerUtils.unmarshallTwoByteIntegerFromBuffer(
					segBytes,
					srcPos,
					true,
					MarshallIntegerUtils.SIGN_CODING_TWOS_COMPLEMENT);

			// Put segment in byte array.
			buff = new byte[LL];
			System.arraycopy(segBytes, srcPos, buff, dstPos, LL);
			remainLen -= LL;

			// Create and populate segment object from byte array.
			
			OutputSeg2 S2 = new OutputSeg2();
			S2.setBytes(buff);
			System.out.println(
				"\nOutSeg2 LL is:    "
					+ S2.getOut__ll()
					+ "\nOutSeg2 ZZ is:    "
					+ S2.getOut__zz()
					+ "\nOutSeg2_DATA1 is: "
					+ S2.getOut__data1()
					+ "\nOutSeg2_DATA2 is: "
					+ S2.getOut__data2());
			// ---------------------------------------------------				
			// Populate third segment object from buffer. 
			// ---------------------------------------------------	
			srcPos += LL;
			buff = null;
			// Get length of segment.
			LL =
				MarshallIntegerUtils.unmarshallTwoByteIntegerFromBuffer(
					segBytes,
					srcPos,
					true,
					MarshallIntegerUtils.SIGN_CODING_TWOS_COMPLEMENT);

			// Put segment in byte array.
			buff = new byte[LL];
			System.arraycopy(segBytes, srcPos, buff, dstPos, LL);
			remainLen -= LL;

			// Create and populate segment object from byte array.
			OutputSeg3 S3 = new OutputSeg3();
			S3.setBytes(buff);
			System.out.println(
				"\nOutSeg3 LL is:    "
					+ S3.getOut__ll()
					+ "\nOutSeg3 ZZ is:    "
					+ S3.getOut__zz()
					+ "\nOutSeg3_DATA1 is: "
					+ S3.getOut__data1()
					+ "\nOutSeg3_DATA2 is: "
					+ S3.getOut__data2()
					+ "\nOutSeg3_DATA3 is: "
					+ S3.getOut__data3());
		}
		catch (Exception e)
		{
			System.out.println("\nCaught exception is: " + e);
		}
	}
}
Pour les messages de longueur variable, les messages avec plusieurs segments et les messages contenant des tableaux, consultez les tutoriels IMS et les exemples de l'aide en ligne ou du centre de documentation dans l'environnement de développement WebSphere ou Rational.
  • Les tutoriels IMS sont disponibles dans Tutoriels > Do and Learn.
  • Les exemples IMS sont disponibles dans Exemples > Exemples de technologie > Exemples J2C.
Ces tutoriels et ces exemples donnent des informations d'aide et des exemples de code pour la gestion des formats de messages spéciaux.

Vos commentaires