Formatos de Mensagens de Entrada e Saída

Você deve considerar as plataformas em que o aplicativo de host de destino e o cliente Java™ são executados e também qualquer característica especial que a mensagem de entrada e saída possa ter ao desenvolver um aplicativo que use o IMS TM Resource Adapter.

O aplicativo Java criado está em execução em uma plataforma diferente (por exemplo, Windows, AIX e Solaris) daquela da plataforma do Enterprise Information System (EIS). O IMS Transaction Manager (IMS TM) é um programa de aplicativo do IMS no z/OS). Devido às diferenças de plataformas, você deve converter os dados de texto nas mensagens, de dados de texto em UNICODE no lado do cliente para dados de texto em EBCDIC usado pelo aplicativo do IMS.

Dependendo do valor Endian da plataforma na qual o aplicativo de host de destino é executado e da página de códigos usada pelo sistema host do IMS, pode ser necessária conversão de formatos. O padrão é Inglês dos Estados Unidos (037).

Recomendação: Deixe que o ambiente de desenvolvimento integrado (IDE) manipule a conversão de formatos para você. Por exemplo, o assistente do J2C em diversos ambientes de desenvolvimento do WebSphere ou do Rational cria as ligações de dados Java a partir de estruturas de dados importadas C, COBOL e PL/I. As ligações de dados realizam todas as conversões de formatos de suas mensagens em tempo de execução. Essas ligações de dados são criadas com base nas opções selecionadas no assistente Importador.

O IMS requer que todas as mensagens de transação sejam prefixadas por um campo LL de 2 bytes, um campo ZZ de 2 bytes e seguidas pelo código de transação. O campo LL especifica o comprimento da mensagem. O ZZ é um campo de zero binário. Ao construir mensagens de entrada para o IMS, você deve configurar o valor do LL no tamanho da mensagem de entrada e configurar zz como 0.

Saída de Comprimento Variável de Diversos Segmentos

Se o aplicativo IMS retornar uma saída com diversos segmentos ou uma saída com comprimentos variáveis, será possível usar a definição OUTPUT-MSG do COBOL para definir a saída da transação ou criar uma mensagem de saída para a saída da transação.

No seguinte aplicativo COBOL, a mensagem de saída retornada pelo IMS consiste de três segmentos de comprimento fixo. A mensagem de saída total retornada por este aplicativo do IMS é um tamanho fixo de 99 e é representado por OUTPUT-MSG da estrutura do COBOL 01. OUTPUT-SEG1 tem 16 bytes de comprimento, OUTPUT-SEG2 tem 31 bytes e OUTPUT-SEG3 52 bytes.
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.   
É possível usar o assistente do J2C para criar um bean J2C que execute a transação do IMS ao:
  • Criar uma classe de buffer de mensagem para armazenar a mensagem de saída retornada pelo aplicativo IMS
  • Importar o arquivo COBOL para fazer o mapeamento de COBOL para Java para as mensagens de entrada e saída
    • Criar a operação de ligação de entrada ao selecionar a estrutura da mensagem de entrada (representada pelo INPUT-MSG da estrutura do COBOL 01)
    • Criar as operações de ligação de saída para os segmentos da mensagem de saída ao usar o assistente de mapeamento de dados, disponível ao selecionar Arquivo > Novo > Outro > Ligação de Dados CICS/IMS Java. Para cada segmento, use o assistente de ligação de dados para selecionar o segmento correto como a estrutura de dados e especifique os parâmetros como a página de códigos, o nome endian, o nome entre aspas e nome truncado.
  • Chamar o método bean J2C que executa a transação do IMS e preencher os segmentos de saída do buffer de dados retornados pela transação do 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;

		tente
		{
			// ---------------------------------------------------			
			// Preencha a mensagem de entrada da transação do IMS com
			// dados.  Use o método do manipulador de formato de mensagem de entrada 
			// getSize() para configurar o campo LL da mensagem de entrada.
			// ---------------------------------------------------					
			InputMsg input = new InputMsg();
			input.setIn__ll((short) input.getSize());
			input.setIn__zz((short) 0);
			//----------------------------------------------
			// descubra o código de transação do administrador do 			// IMS
			//-----------------------------------------------
			input.setIn__trcd("SKS6 ");
			input.setIn__data1("M2 SI1");
			input.setIn__data2("M3 SI1");

			// ---------------------------------------------------			
			// Execute a transação do IMS.  A mensagem de saída 	
		// multissegmentos é retornada.
			// ---------------------------------------------------				
			MSOImpl proxy = new MSOImpl();
			
			sample.ims.CCIBuffer output = proxy.runMultiSegOutput(input);

			// ---------------------------------------------------	
			// Recupere a mensagem de saída multissegmentos como uma 
			// matriz de bytes usando o método do manipulador de formato
  // de mensagem de saída getBytes().
			// ---------------------------------------------------			 			
			System.out.println(
				"\nSize of output message is: " + output.getSize());
			segBytes = output.getBytes();

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

			// ---------------------------------------------------	
			// Preencha o primeiro objeto de segmento a partir do buffer. 
			// ---------------------------------------			             
			buff = null;
			// Obtenha o comprimento do segmento.
			LL =
				MarshallIntegerUtils.unmarshallTwoByteIntegerFromBuffer(
					segBytes,
					srcPos,
					true,
					MarshallIntegerUtils.SIGN_CODING_TWOS_COMPLEMENT);

			// Coloque o segmento na matriz de bytes.
			buff = new byte[LL];
			System.arraycopy(segBytes, srcPos, buff, dstPos, LL);
			remainLen -= LL;

			// Crie e preencha o objeto de segmento a partir da matriz de bytes.
			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());

			// ---------------------------------------------------	
			// Preencha um segundo objeto de segmento a partir do buffer. 
			// ---------------------------------------------------	
			srcPos += LL;
			buff = null;
			// Obtenha o comprimento do segmento.
			LL =
				MarshallIntegerUtils.unmarshallTwoByteIntegerFromBuffer(
					segBytes,
					srcPos,
					true,
					MarshallIntegerUtils.SIGN_CODING_TWOS_COMPLEMENT);

			// Coloque o segmento na matriz de bytes.
			buff = new byte[LL];
			System.arraycopy(segBytes, srcPos, buff, dstPos, LL);
			remainLen -= LL;

			// Crie e preencha o objeto de segmento a partir da matriz de bytes.
			
			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());
			// ---------------------------------------------------				
			// Preencha o terceiro objeto de segmento a partir do buffer. 
			// ---------------------------------------------------	
			srcPos += LL;
			buff = null;
			// Obtenha o comprimento do segmento.
			LL =
				MarshallIntegerUtils.unmarshallTwoByteIntegerFromBuffer(
					segBytes,
					srcPos,
					true,
					MarshallIntegerUtils.SIGN_CODING_TWOS_COMPLEMENT);

			// Coloque o segmento na matriz de bytes.
			buff = new byte[LL];
			System.arraycopy(segBytes, srcPos, buff, dstPos, LL);
			remainLen -= LL;

			// Crie e preencha o objeto de segmento a partir da matriz de bytes.
			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);
		}
	}
}
Para mensagens de comprimento variável, mensagens com diversos segmentos e mensagens que contêm matrizes, consulte os tutoriais e amostras do IMS na ajuda online ou o centro de informações no ambiente de desenvolvimento do WebSphere ou do Rational.
  • Os tutoriais do IMS estão disponíveis em Tutoriais > Faça e Aprenda.
  • As amostras do IMS estão disponíveis em Amostras > Amostras de tecnologia > Amostras do J2C.
Esses tutoriais e amostras fornecem as informações de orientação e o código de amostra para manipular formatos de mensagens especiais.

Feedback