Este artigo ajuda administradores de IMS, programadores de sistema e programadores de aplicativos que estão interessados em usar Java® dentro de regiões dependentes de IMS. Este artigo destaca e fornece exemplos das etapas necessárias para implementar Java em regiões dependentes de IMS, incluindo regiões com Java Batch Processing (JBP), Java Message Processing (JMP) e Message Processing Program (MPP). O exemplo de MPP mostra o recurso de interoperar entre COBOL e Java.
Introdução
Este artigo descreve uma abordagem para usar Java dentro de regiões dependentes de IMS. Exemplos mostram como configurar, executar e solucionar problemas do seguinte:
- Aplicativos IMS Java em regiões Java Batch Processing (JBP)
- Regiões Java Message Processing (JMP)
- Interoperação entre COBOL e Java dentro de Message Processing Programs (MPP)
O suporte para Java em regiões dependentes de IMS foi fornecido por requisitos entregues usando o fluxo de serviço IMS V10 e V11 e com APARs (PM02734) (PK86498) tipo 2 e JVM APARs. Além disso, o seguinte é necessário:
- LE APAR PK99010
- driver DB2® para JDBC
- PTF UK52962
- JDK Versão 6.0
As seções JBP, JMP e MPP deste artigo são autônomas. Algumas informações são repetidas em cada uma das áreas, mas isso é intencional para permitir que cada seção seja lida de maneira independente das outras. Funções específicas, incluindo programador e administrador de sistema, que estejam associadas às atividades serão indicadas com Função: para diferentes áreas do artigo, quando adequado.
Entendendo drivers IMS Universal e Java
O IMS oferece diversas soluções para desenvolver e estender aplicativos em ambientes de cliente usando Java. Como parte das versões 10 e 11 do IMS, o IMS fornece drivers IMS Universal que incluem suporte para driver Java para conectividade tipo 2 dentro de regiões dependentes de IMS. Esse suporte possibilita que os clientes desenvolvam novos aplicativos em Java usando o driver IMS Universal JDBC e o driver IMS Universal DL/I.
Os drivers IMS Universal são componentes de software que fornecem aos aplicativos Java conectividade e acesso a bancos de dados IMS a partir do z/OS® e ambientes distribuídos através de TCP/IP. Os aplicativos Java que usam drivers IMS Universal tipo 2 devem residir na mesma partição lógica (LPAR) que o subsistema IMS. Aplicativos Java que usam os drivers IMS Universal tipo 4 podem residir na mesma partição lógica (LPAR) ou em uma LPAR diferente dos subsistemas IMS.
O driver JDBC
IMS fornece um driver Java Database Connectivity (JDBC) para conectividade de banco de dados com base em SQL para acessar bancos de dados IMS sobre TCP/IP com o driver IMS Universal JDBC que está incluso nos drivers IMS Universal. O driver IMS Universal JDBC é baseado no padrão JDBC 3.0. O JDBC é uma interface de programação de aplicativos (API) que aplicativos Java usam para acessar bancos de dados relacionais ou origines de dados tabulares.
A API do JDBC é o padrão do setor para conectividade dependente de banco de dados entre a linguagem de programação Java e qualquer banco de dados implementado na interface JDBC. O cliente usa a interface para consultar e atualizar dados em um banco de dados. è responsabilidade do driver JDBC em si implementar o protocolo de acesso subjacente (específico) para o banco de dados específico para o qual o driver está implementado.
Os drivers são adaptadores do lado do cliente, assim, são instalados na máquina do cliente, não no servidor. Os drivers convertem solicitações de programas Java para um protocolo que o sistema de gerenciamento de banco de dados (DBMS) pode entender. O suporte IMS para JDBC permite que aplicativos Java emitam chamadas SQL dinâmicas para acessar dados do IMS e processar o conjunto de resultados que é retornado em um formato tabular.
O driver IMS Universal JDBC é projetado para suportar um subconjunto de sintaxe SQL com funcionalidade limitada ao que o sistema de gerenciamento de banco de dados IMS pode processar nativamente. Seu design centrado em DBMS possibilita que o driver IMS Universal JDBC aproveite totalmente os recursos de alto desempenho do IMS. O driver IMS Universal JDBC também fornece suporte de função agregada, suporte ORDER BY e suporte GROUP BY.
Conectividade de arquitetura tipo 2 do driver JDBC
Programas Java com conectividade JDBC tipo 2 podem executar no mesmo sistema z/OS ou partição local (LPAR) zSeries® que o subsistema IMS de destino. O driver IMS Universal JDBC com conectividade tipo 2 é usado para acessar o IMS a partir de regiões dependentes de Java (JDRs), incluindo regiões JMP e JBP. Ao programar, a propriedade driverType deve ser definida para indicar conectividade local (tipo 2) para IMS.
Conectividade de arquitetura tipo 4 do driver IMS Universal JDBC
O driver IMS Universal JDBC com conectividade tipo 4 é usado para acessar o subsistema IMS através de conexão de rede TCP/IP. Com conectividade tipo 4, os drivers IMS Universal fornecem suporte para a Secure Sockets Layer (SSL) através da Java Secure Socket Extension (JSSE).
Driver IMS Universal DL/I
O driver IMS Universal DL/I é usado quando há necessidade de escrever consultas granulares para acessar bancos de dados IMS diretamente a partir de um cliente Java em um ambiente não gerenciado. Em função das diferenças fundamentais entre bancos de dados hierárquicos e bancos de dados relacionais, às vezes o driver IMS Universal JDBC não fornece acesso ao conjunto completo de recursos de banco de dados IMS.
O driver IMS Universal DL/I está fortemente relacionado à interface de chamada tradicional IMS DL/I usada com outras linguagens de programação para escrever aplicativos em IMS. O driver fornece um acesso de nível inferior às funções do banco de dados IMS que a API JDBC. O driver IMS Universal DL/I fornece a habilidade de construir segment search arguments (SSAs) e usar os métodos do objeto program communication block (PCB) para ler, inserir, atualizar, excluir ou realizar operações em lote em segmentos. Controle total de navegação na hierarquia do segmento é obtido usando o driver IMS Universal DL/I.
Entendendo regiões dependentes de IMS e JAVA
O IMS fornece espaços de endereço para executar programas de aplicativos e sistema que usam serviços IMS. Esses espaços de endereço são chamados de regiões dependentes. . As regiões dependentes são iniciadas pelo envio do JCL para o sistema operacional. O JCL é enviado através de um comando emitido para a região de controle de IMS, através de automação, ou através de um envio de tarefa em lote regular. Depois de as regiões dependentes serem iniciadas, os programas de aplicativos são programados e enviados pela região de controle do IMS. Em todos os casos, o espaço de endereço z/OS executa um programa de região de controle IMS. O programa de aplicativo então é carregado e chamado pelo código IMS. Até 999 regiões dependentes podem ser conectadas a uma região de controle IMS.
Regiões dependentes podem ser regiões orientadas por mensagem (processamento de mensagens) ou regiões não orientadas por mensagens (lote). As message processing regions (MPRs) executam aplicativos que processam mensagens que vem para o IMS TM como entrada, como de terminais ou programas online. O IMS enviando o JCL como resultado de um comando IMS pode iniciar MPRs. O espaço de endereço não carrega automaticamente programas de aplicativos, mas espera até que a tarefa fique disponível. Configurações prioritárias determinam qual MPR executa o programa de aplicativo. Quando o IMS determina que um aplicativo deve executar em um MPR em particular, o programa de aplicativo é carregado nessa região e recebe controle. O aplicativo processa a mensagem e qualquer outra mensagem para a transação que esteja aguardando processamento. Então, dependendo das opções especificadas na definição da transação, o aplicativo espera mais entradas ou outro programa de aplicativo é carregado para processar uma transação diferente.
O IMS fornece os seguintes tipos de região dependente:
- Regiões de processamento de mensagens, que leem e processam mensagens da fila de mensagens do IMS, incluindo o seguinte:
- Message Processing Program (MPP)
- IMS Fast Path (IFP)
- Java Message Processing (JMP)
- Regiões não orientadas por mensagem, que são orientadas por lote e não processam mensagens IMS:
- Batch Message Processing (BMP)
- Java Batch Processing (JBP)
Regiões JMP e regiões JBP possibilitam que Java, COBOL orientado a objeto, PL/I orientado a objeto ou uma combinação dessas linguagens obtenha controle quando uma transação IMS é programada. Isso difere de regiões IFP e regiões BMP, que permitem que programas escritos em Assembler. PL/I, C, COBOL e PASCAL obtenham controle quando uma transação IMS é programada.
Regiões dependentes de IMS suportam Java Virtual Machines (JVM) persistentes para fornecer a habilidade de fazer chamadas de maneira eficiente que interoperam com Java e linguagens como COBOL e PL/I. Isso permite a capacidade de aproveitar aplicativos IMS existentes, bem como funcionalidade estendida usando Java. A interoperabilidade é suportada em regiões MPP, BMP, IFP, JMP e JBP.
Usar Java para desenvolver nova lógica de negócios permite aproveitar as habilidades que são comuns no ambiente do mundo distribuído, como JDBC. Além disso, é possível reduzir o custo de executar aplicativos Java aproveitando mecanismos System z Application Assist Processor (zAAP), que auxiliam na redução do uso de MIPs debitáveis ao processar Java.
Regiões JBP executam programas flexíveis que realizam processamento tipo lote online e podem acessar as filas de mensagem IMS para saída (similar a aplicativos BMP não orientados por mensagem). Aplicativos JBP são iniciados enviando uma tarefa com JCL ou para TSO. Aplicativos JBP são como aplicativos BMP, exceto que não podem ler mensagens de entrada da fila de mensagens IMS. Como aplicativos BMP, os aplicativos JBP podem usar ponto de verificação simbólico e reiniciar chamadas para reiniciar o aplicativo após um encerramento anormal. Aplicativos JBP podem acessar dados IMS ou DB2 em um ambiente DB/DC ou DBCTL e dados DB2 em um ambiente DCCTL.
Ambiente JBP: Configuração
Esta seção descreve o uso de Java em um ambiente de região de Java Batch Processing.
Função: Programador de sistema
Esta seção fornece uma visão geral para configurar uma região IMS Java Batch Processing (JBP) para executar aplicativos Java. A Listagem 1 fornece um exemplo de uma tarefa chamada JBPSAMPL para iniciar uma região JBP.
Listagem 1. Tarefa de amostra JBPSAMPL para iniciar uma região JBP
//JBPSAMPL JOB,0M // CLASS=A,MSGCLASS=H,MSGLEVEL=(1,1),NOTIFY=&SYSUID,REGION=32M // EXEC DFSJBP, // IMSID=IMSB,MBR=JBPSAMPL,PSB=S2U1LPSJ,JVMOPMAS=DFSJVMMS, // ENVIRON=DFSJVMEV //STEPLIB DD DSN=IMS.PGMLIB,DISP=SHR // DD DSN=IMS.SDFSJLIB,DISP=SHR // DD DSN=IMS.SDFSRESL,DISP=SHR // DD DSN=CEE.SCEERUN,DISP=SHR // DD DSN=SYS1.CSSLIB,DISP=SHR //PROCLIB DD DSN=IMS.PROCLIB,DISP=SHR //JAVAOUT DD PATH='/tmp/jvm.out', // PATHDISP=(KEEP,KEEP), // PATHOPTS=(OWRONLY,OCREAT,OTRUNC), // PATHMODE=(SIRWXU,SIRWXG,SIRWXO) //JAVAERR DD PATH='/tmp/jvm.err', // PATHDISP=(KEEP,KEEP), // PATHOPTS=(OWRONLY,OCREAT,OTRUNC), // PATHMODE=(SIRWXU,SIRWXG,SIRWXO)
A tarefa JBPSAMPL executa o procedimento DFSJBP fornecido no padrão IMS.PROCLIB. Os parâmetros incluem o seguinte:
- IMSID
- O ID do subsistema IMS sob o qual executar
- MBR
- Um nome de programa de aplicativo
- PSB
- O bloco de especificações do programa definido no IMS para permitir acesso adequado ao banco de dados e transações com base na definição do PSB. Na amostra de JBPSAMPL, S2U1LPSJ é o PSB fornecido. O PSB de amostra chamado S2U1LPSJ é mostrado na Listagem 2.
Listagem 2. Definição de PSB S2U1LPSJ
PCB TYPE=DB,DBDNAME=S2U1ADBD,PROCOPT=A,KEYLEN=20, X
PCBNAME=PCB01
SENSEG NAME=ADDINFO,PARENT=0
PSBGEN LANG=JAVA,PSBNAME=S2U1LPSJ
END
O S2U1LPSJ fornece acesso ao segmento ADDINFO no banco de dados S2U1ADBD definido no IMS. Além disso, a opção de processamento (PROCOPT) especifica A, que permite todas as operações com relação a um segmento, incluindo recuperar, atualizar, inserir e excluir.
Recomendação
Se estiver usando PCBs que definam múltiplos segmentos, o PROCOPT P é recomendado para permitir unir segmentos na mesma hierarquia. Isso é útil quando os aplicativos exigem dados de múltiplos segmentos em uma única consulta.
Importante: Se estiver usando o driver IMS Universal, um PCBNAME ou LABEL é necessário na instrução PCB, pois bibliotecas Java aproveitam as interfaces AIB, que exigem que o nome ou o rótulo esteja presente. JVMOPAS é o nome do membro IMS.PROCLIB que contém CLASSPATH e as opções JVM para o BVM mestre. A Listagem 3 mostra um exemplo de membro DFSJVMMS de JVMOPAS IMS.PROCLIB.
******************************************************************** * Specify the profile that has environment settings and JVM options. * The following two JVM options are required. ******************************************************************** -Djava.class.path=> /stjava/ims/IMS Universal driver .jar:> /stjava/ims/imsutm.jar:> /stjava/SolutionTestApps.jar:> ******************************************************************** * The following JVM options are a subset of the options allowed * Xmx64M - set the maximum Java heap size of your program * Xmso512k - set stack size for OS threads for 32 bit * Xss256k - set Java thread stack size * Xms1M - set initial Java heap size ******************************************************************* -Xmaxf0.8 -Xminf0.3 -Xmx64M -Xmso512k -Xss256k -Xms1M
CLASSPATH (java.class.path) na Listagem 3 especifica o local do driver IMS Universal .jar, imsutm.jar, e bibliotecas SolutionTestApps.jar. Os drivers IMS Universal .jar e imsutm.jar são as bibliotecas necessárias ao programar com as APIs do driver IMS Universal. Os drivers IMS Universal .jar e imsutm.jar podem ser instalados usando o IMS Installation Verification Program (IVP) para cenários Java.
Os drivers IMS Universal driver .jar e imsutm.jar são as bibliotecas necessárias aos programas com as APIs do driver IMS Universal. A instalação do SMP/E do IMS Java On Demand FMID adiciona as partes do adaptador de recurso IMS Universal DB nos diretórios adequados no sistema de arquivos. Antes de o IMS Java On Demand FMID poder ser instalado, um sistema de arquivos ZFS ou HFS deve ser criado e montado. Quando esse sistema de arquivos tiver sido montado, uma tarefa de amostra DFSJSMKD é executada para criar os diretórios no sistema de arquivos. DFSJSMKD chama DFSJMKDR para criar as estruturas de diretório e o link simbólico libT2DLI.so.
SolutionTestApps.jar contém os aplicativos de amostra para serem executados nessa amostra. A Listagem 4 mostra uma lista dos conteúdos do arquivo SolutionTestApps.jar.
Listagem 4. Conteúdos do arquivo SolutionTestApps.jar
JavaPayPolicy.class databaseviews/S2U1LPSJDatabaseView.class databaseviews/S2U1PSBDatabaseView.class com/ibm/ims/st/opendb/jmp/AdditionalCustomerIOMessage.class com/ibm/ims/st/opendb/jmp/AdditionalCustomerCRUD.class com/ibm/ims/st/opendb/jbp/AdditionalCustomerInfo.class
ENVIRON é o nome do membro IMS.PROCLIB que contém a definição do caminho da biblioteca (LIBPATH) para o ambiente Java. A Listagem 5 mostra o ENVIRON IMS.PROCLIB, membro DFSJVMEV.
Listagem 5. Membro de amostra DFSJVMEV
********************************************************************** * Specify the location of Java Virtual Machine (JVM) installation and * IMS Java native code (libT2DLI.so) ********************************************************************** LIBPATH=> /javaroot/java160/J6.0/bin:> /javaroot/java160/J6.0/bin/j9vm:> /usr/lpp/ims/lib
Os dois primeiros caminhos especificados no ponto DFSJVMEV para as bibliotecas de tempo de execução Java Versão 6.0 localizadas no z/OS UNIX® System Services (USS) Hierarchical File System (HFS). O último caminho especifica o local de libT2DLI.so, que aponta para o código nativo para conectividade Java tipo 2 IMS fornecida no IMS Versões 10 e 11. O arquivo libT2DLI.so é criado no sistema de arquivos USS ao executar o Programa de Verificação de Instalação IMS para cenários Java.
MBR é um nome de programa de aplicativo usado para chamar aplicativos Java.
Para indicar qual aplicativo Java chamar ao executar JBP, especifica um nome de 1-8 caracteres no parâmetro MBR. Quando o nome MBR é especificado, o JBP tenta carregar o membro DFSJVMAP IMS.PROCLIB. DFSJVMAP mapeia nomes MBR para nomes de classe Java totalmente qualificados.
A Listagem 6 mostra um exemplo de uma definição DFSJVMAP.
Listagem 6. Membro de amostra DFSJVMAP
********************************************************************** * The Java applications specified here are located in the * SolutionTestApps.jar file. ********************************************************************** JBPSAMPL=com/ibm/ims/st/opendb/jbp/AdditionalCustomerInfo **********************************************************************
Neste exemplo, JBPSAMPL é mapeado para uma classe Java chamada AdditionalCustomerInfo, de modo que quando o JBP é enviado, ele executará o método principal na classe Java AdditionalCustomerInfo Java. Se o parâmetro MBR não for fornecido, o JBP tenta carregar uma classe Java com o nome de PSB. Para o exemplo, o IMS tentará carregar S2U1LPSJ.class.
A tarefa JBPSAMPL na Listagem 1, também especifica os nomes DD JAVAOUT e JAVAERR. Esses arquivos são usados para aplicativos Java, e especificam onde os fluxos Java System.out e System.err são gravados. As instruções DD JAVAOUT e JAVAERR DD fornecidas criam esses arquivos se eles não existem, e se eles já existem, serão substituídos.
Ambiente JBP: Desenvolvimento de aplicativo
Esta seção descreve o desenvolvimento do aplicativo JBP.
Função: DBA ou programador de aplicativos, dependendo do seu ambiente
Quando você planeja acessar um banco de dados IMS a partir de Java, a primeira etapa no desenvolvimento de aplicativos que usam o driver IMS Universal é criar uma visualização do banco de dados. Essa visualização do banco de dados é uma classe Java contendo metadados que descrevem IMS PSBs, DBDs, segmentos, campos, relacionamentos, chaves/não chaves e informações de tipo de dado. Essa classe serve como o metadado para um PSB e seu conjunto de visualizações relacionadas (PCBs) e bancos de dados (DBDs). Isso é necessário para os drivers IMS Universal construírem e validarem consultas com relação a bancos de dados IMS, bem como layouts de campo em um segmento.
Para gerar essa classe de metadados, o IMS fornece um Plug-in do Utilitário IMS Enterprise Suite DLIModel para Eclipse, que pode ser transferido por download sem custos (consulte Recursos).
O plug-in é instalado sobre o Eclipse e fornece um assistente, que importa origem PSB e origem DBD para gerar a visualização do banco de dados com base em um PSB em particular. No JCL fornecido na Listagem 1, , o PSB usado é S2U1LPSJ, que faz referência a um DBD chamado S2U1ADBD. A origem para S2U1LPSJ e S2U1ADBD precisa ser transferida por download com um nome de arquivo que corresponde aos nomes do PSB e DBD.
Sugestão: É possível para um DBD fazer referência a outros DBDs, então se certifique de fazer o download de todos os DBDs referidos, incluindo DBDs indexados secundários, DBDs lógicos e DBDs referidos em instruções LCHILD. Entre em contato com o administrador de banco de dados (DBA) para se certificar de que isso está disponível para uso.
Quando obtiver todas as partes, procure as informações do plug-in do utilitário MS Enterprise Suite DLIModel no InfoCenter (consulte Recursos).
Para sua referência, a Listagem 7 mostra o S2U1LPSJDatabaseView.java gerado usando o utilitário DLIModel. Nunca será necessário olhar para esta classe, pois as bibliotecas Java a consomem internamente. Na classe S2U1LPSJDatabaseView, o segmento ADDINFO contém informações do cliente adicionais e possui vários campos definidos, incluindo CustomerNumber (Chave Única), E-mail, Fone, Fax, e assim por diante.
Listagem 7. S2U1LPSJDatabaseView.java
package databaseviews;
import com.ibm.ims.db.*;
import com.ibm.ims.base.*;
public class S2U1LPSJDatabaseView extends DLIDatabaseView {
// This class describes the data view of PSB: S2U1LPSJ
// PSB S2U1LPSJ has database PCBs with 8-char PCBNAME or label:
// PCB01
// The following describes Segment: ADDINFO ("ADDINFO") in PCB: PCB01 ("PCB01")
static DLITypeInfo[] PCB01ADDINFOArray= {
new DLITypeInfo("info_length", DLITypeInfo.SMALLINT, 1, 2),
new DLITypeInfo("CustomerNumber", DLITypeInfo.INTEGER, 3, 4,
"CUSTNO",DLITypeInfo.UNIQUE_KEY),
new DLITypeInfo("Email", DLITypeInfo.CHAR, 7, 30),
new DLITypeInfo("Phone", DLITypeInfo.CHAR, 37, 10),
new DLITypeInfo("Fax", DLITypeInfo.CHAR, 47, 10),
new DLITypeInfo("CompanyName", DLITypeInfo.CHAR, 57, 30),
new DLITypeInfo("DriversLicense", DLITypeInfo.CHAR, 87, 8),
new DLITypeInfo("DLState", DLITypeInfo.CHAR, 95, 2),
new DLITypeInfo("Notes", DLITypeInfo.CHAR, 97, 1468)
};
static DLISegment PCB01ADDINFOSegment= new DLISegment
("ADDINFO","ADDINFO",PCB01ADDINFOArray,1564);
// An array of DLISegmentInfo objects follows to describe the view
// for PCB: PCB01 ("PCB01")
static DLISegmentInfo[] PCB01array = {
new DLISegmentInfo(PCB01ADDINFOSegment,DLIDatabaseView.ROOT)
};
// Constructor
public S2U1LPSJDatabaseView() {
super("2.0.3","S2U1LPSJ", "PCB01", "PCB01", PCB01array, "A");
} // end S2U1LPSJDatabaseView constructor
} // end S2U1LPSJDatabaseView class definition
Acessando o banco de dados IMS em Java usando o driver IMS Universal JDBC ou o driver IMS Universal DL/I
Os drivers IMS Universal fornecem duas APIs: JDBC e DL/I para Java. O driver IMS Universal JDBC trata segmentos IMS DB como equivalentes às tabelas relacionais. As Listagens 8 e 9 apresentam amostras de aplicativo fornecidas para cada. As amostras serão executadas em uma região JBP e relatarão uma lista de todos os números de cliente, nomes de empresa e números telefônicos no segmento ADDINFO (tabela).
Listagem 8. Driver IMS Universal JDBC para a API Java
public static void main(String[] args) {
//Setting Type 2 Properties
IMSDataSource imsDS = new IMSDataSource();
imsDS.setDatastoreName("IMSB");
imsDS.setDriverType(IMSDataSource.DRIVER_TYPE_2);
imsDS.setMetadataURL("class://databaseviews.S2U1LPSJDatabaseView");
//Application is used to get a Transaction object
Application app = ApplicationFactory.createApplication();
//Transaction is primarily used for commit or rollback calls
Transaction tran = app.getTransaction();
try {
Connection conn = imsDS.getConnection();
Statement st = conn.createStatement();
ResultSet rs = st.executeQuery(
"SELECT CustomerNumber, CompanyName, Phone FROM PCB01.ADDINFO");
while(rs.next()){
System.out.println("CustomerNumber: " +
rs.getString("CustomerNumber") +
", CompanyName: " +
rs.getString("CompanyName") +
", Phone: " +
rs.getString("Phone"));
}
rs.close();
st.close();
tran.commit();
conn.close();
} catch (SQLException e) {
System.out.println("An SQLException occurred: " + e.getMessage());
e.printStackTrace();
} catch (DLIException e) {
System.out.println("A DLIException occurred: " + e.getMessage());
e.printStackTrace();
}
}
JDBC é uma API padrão para emitir instruções SQL em Java. O aplicativo usa IMSDataSource para definir o seguinte:
- Tipo do driver
- Nome do armazenamento de dados ou IMSID
- A URL de metadados aponta para o driver IMS Universal para a classe de visualização do banco de dados para o PSB sendo acessado
O aplicativo usa o modelo de programação JDBC padrão para obter uma conexão, criar uma instrução, executar a instrução e processar o conjunto de resultados. Para confirmar os dados em regiões dependentes de IMS, use a instância de transação (tran) para confirmar o trabalho feito.
A Listagem 9 apresenta um exemplo que usa o driver IMS Universal DL/I.
Listagem 9. Exemplo de driver IMS Universal DL/I
public static void main(String[] args) {
//Setting Type 2 Properties
IMSConnectionSpec connSpec = IMSConnectionSpecFactory.createIMSConnectionSpec();
connSpec.setDatastoreName("IMSB");
connSpec.setDriverType(IMSConnectionSpec.DRIVER_TYPE_2);
connSpec.setMetadataURL("class://databaseviews.S2U1LPSJDatabaseView");
//Application is used to get a Transaction object
Application app = ApplicationFactory.createApplication();
//Transaction is primarily used for commit or rollback calls
Transaction tran = app.getTransaction();
try {
PSB psb = PSBFactory.createPSB(connSpec);
PCB pcb = psb.getPCB("PCB01");
SSAList ssa = pcb.getSSAList("ADDINFO");
PathSet pathSet = pcb.batchRetrieve(ssa);
while(pathSet.hasNext()){
Path path = pathSet.next();
System.out.println("CustomerNumber: " +
path.getString("CustomerNumber") +
", CompanyName: " +
path.getString("CompanyName") +
", Phone: " +
path.getString("Phone"));
}
tran.commit();
psb.close();
} catch (DLIException e) {
System.out.println("An error occurred: " + e.getMessage());
e.printStackTrace();
}
O método principal na Listagem 9 mostra como obter uma conexão do tipo 2 para S2U1LPSJ criando IMSConnectionSpec que especifica o seguinte:
- Tipo do driver
- Nome do armazenamento de dados ou IMSID
- A URL de metadados aponta para o driver IMS Universal para a classe de visualização do banco de dados para o PSB sendo acessado
A seguir, o aplicativo usa os objetos PSB, PCB e SSAList para executar uma recuperação em lote do segmento ADDINFO. Isso retorna um pathSet, que é uma coleção de caminhos. Um objeto de caminho é a área de E/S para a chamada do banco de dados e contém os segmentos que a chamada retorna. Um loop while é usado para imprimir uma linha para cada caminho retornado listando os campos Número do cliente, Nome da empresa e Número do telefone.
Ambiente JBP: Implementando o aplicativo Java
Esta seção descreve como implementar o aplicativo Java no ambiente JBP.
Função: Desenvolvedor de aplicativos e Administrador do sistema
Para implementar o aplicativo, exporte o projeto Java como um arquivo jar e coloque o arquivo jar em FTP para seu sistema de arquivo USS no modo BINARY no LPAR em que deseja executar.
O arquivo jar deve ser referido no membro DFSJVMMS IMS.PROCLIB descrito na Listagem 3. Na listagem 3, stjava, é o diretório no qual o archive do aplicativo SolutionTestApps.jar foi colocado no FTP.
Executando o JBP e visualizando os resultados
Esta seção descreve como executar o JBP e visualizar os resultados.
Função: Desenvolvedor de aplicativos
Agora que todas as partes estão no lugar (JCL, membros IMS.PROCLIB e classes Java), execute JBPSAMPL JCL na Listagem 1. . Para verificar os resultados, use SDSF para localizar a tarefa JBP ativa ou concluída. Certifique-se de que não há erros no JOBLOG para a tarefa JBPSAMPL.
A seguir, verifique os locais de saída especificados por JAVAOUT e JAVAERR. Na amostra, é possível localizar JAVAOUT em /tmp/jvm.out, e localizar JAVAERR em /tmp/jvm.err no ambiente USS. Se nada tiver sido escrito para o fluxo de erro, jvm.err está vazio. Para o aplicativo de amostra, o arquivo jvm.out contém um relatório de números de cliente, nomes de empresa e números do telefone.
Na maioria dos sistemas z/OS, é possível acessar o ambiente USS inserindo OMVS a partir de TSO. Para procurar um arquivo no ambiente USS que tenha o nome jvm.out e que esteja localizado no caminho tmp, insira obrowse /tmp/jvm.out.
Ambiente JMP: Configuração
Esta seção descreve o uso do Java em um ambiente de região de processamento em lote de Java.
Função: Programador de sistema
Um programa de aplicativo JMP é similar a um programa de aplicativo MPP, exceto que aplicativos JMP são escritos em Java ou COBOL orientado a objetos. Como um aplicativo MPP, um aplicativo JMP é iniciado quando há uma mensagem na fila de mensagens para o aplicativo JMP. O IMS programa a mensagem para processamento.
Cada código de transação representa uma transação que o aplicativo JMP processa. Um único aplicativo também pode ser iniciado a partir de múltiplos códigos de transação. Aplicativos JMP são muito flexíveis em como processam transações e onde enviam a saída. Aplicativos JMP enviam quaisquer mensagens de saída para as filas de mensagem e processam a próxima mensagem com o mesmo código de transação. O programa continua a executar até que não haja mais mensagens com o mesmo código de transação.
Os aplicativos JMP podem acessar dados IMS ou DB2 z/OS em um ambiente DB/DC, e podem acessar dados DB2 z/OS em um ambiente DCCTL usando JDBC. Os aplicativos JMP executam em regiões JMP que possuem Java virtual machines (JVMs). Aplicativos JMP também podem fazer o seguinte:
- Recuperar mensagens de entrada da fila de mensagens do IMS
- Acessar IMS e DB2 para bancos de dados z/OS
- Confirmar ou retroceder transações
- Enviar mensagens de saída
Esta seção descreve a configuração específica para executar um JMP que use o driver tipo 2 do driver IMS Universal.
A Listagem 10 é um exemplo de uma função que inicia uma região JMP.
Listagem 10. JMP com driver tipo 2 do driver IMS Universal
//JMPADTL1 JOB , // CLASS=A,MSGCLASS=H,MSGLEVEL=(1,1),NOTIFY=&SYSUID,REGION=0M /*JOBPARM S=* // EXEC DFSJMP, // IMSID=IMSB,JVMOPMAS=DFSJVMMS,ENVIRON=DFSJVMEV, // CL1=002,CL2=000,CL3=000,CL4=000 //STEPLIB DD DSN=IMS.PGMLIB,DISP=SHR // DD DSN=IMS.SDFSJLIB,DISP=SHR // DD DSN=IMS.SDFSRESL,DISP=SHR // DD DSN=CEE.SCEERUN,DISP=SHR // DD DSN=SYS1.CSSLIB,DISP=SHR //PROCLIB DD DSN=IMS.PROCLIB,DISP=SHR //JAVAOUT DD PATH='/tmp/jvm.out', // PATHDISP=(KEEP,KEEP), // PATHOPTS=(OWRONLY,OCREAT,OTRUNC), // PATHMODE=(SIRWXU,SIRWXG,SIRWXO) //JAVAERR DD PATH='/tmp/jvm.err', // PATHDISP=(KEEP,KEEP), // PATHOPTS=(OWRONLY,OCREAT,OTRUNC), // PATHMODE=(SIRWXU,SIRWXG,SIRWXO
A tarefa JMPADTL1 executa o procedimento DFSJMP fornecido no IMS.PROCLIB padrão. Os parâmetros incluem o seguinte:
- IMSID
- O ID do subsistema IMS sob o qual executar
- JVMOPAS
- O nome do membro IMS.PROCLIB que contém as opções CLASSPATH e JVM para o JVM mestre. Nesta amostra, o membro DFSJVMMS é definido na Listagem 11.
Listagem 11. Membro de amostra DFSJVMMS
******************************************************************** * Specify the profile that has environment settings and JVM options. * The following two JVM options are required. ******************************************************************** -Djava.class.path=> /stjava/ims/IMS Universal driver .jar:> /stjava/ims/imsutm.jar:> /stjava/SolutionTestApps.jar:> ******************************************************************** * The following JVM options are a subset of the options allowed * * Xmx64M - set the maximum Java heap size of your program * Xmso512k - set stack size for OS threads for 32 bit * Xss256k - set Java thread stack size * Xms1M - set initial Java heap size ******************************************************************** -Xmaxf0.8 -Xminf0.3 -Xmx64M -Xmso512k -Xss256k -Xms1M |
O CLASSPATH (java.class.path) especifica o driver IMS Universal .jar, imsutm.jar e as bibliotecas SolutionTestApps.jar. Os drivers IMS Universal .jar e imsutm.jar são as bibliotecas necessárias ao programar com as APIs do driver IMS Universal. A instalação SMP/E do IMS Java On Demand FMID adiciona as partes necessárias aos diretórios apropriados no sistema de arquivos. Antes de instalar o IMS Java On Demand FMID, é necessário criar e montar um ZFS ou um sistema de arquivos HFS.Uma vez que esse sistema de arquivos estiver montado, é possível executar a tarefa de amostra DFSJSMKD para criar os diretórios no sistema de arquivo. DFSJSMKD chama DFSJMKDR para criar as estruturas do diretório e o link simbólico libT2DLI.so.
A SolutionTestApps.jar contém os aplicativos de amostra a serem executados neste artigo. A Listagem 12 mostra os conteúdos do arquivo SolutionTestApps.jar gerados usando o comando jar tf SolutionTestApps.jar .
Listagem 12. Arquivo SolutionTestApps.jar
JavaPayPolicy.class databaseviews/S2U1LPSJDatabaseView.class databaseviews/S2U1PSBDatabaseView.class com/ibm/ims/st/opendb/jmp/AdditionalCustomerIOMessage.class com/ibm/ims/st/opendb/jmp/AdditionalCustomerCRUD.class com/ibm/ims/st/opendb/jbp/AdditionalCustomerInfo.class
O parâmetro ENVIRON especifica o nome do membro IMS.PROCLIB que contém a definição do caminho da biblioteca (LIBPATH) para o ambiente Java. Na amostra, DFSJVMEV é definido como mostrado na Listagem 13.
Listagem 13. Membro de amostra DFSJVMEV
********************************************************************** * Specify the location of Java Virtual Machine (JVM) installation and * IMS Java native code (libT2DLI.so) ********************************************************************** LIBPATH=> /javaroot/java160/J6.0/bin:> /javaroot/java160/J6.0/bin/j9vm:> /usr/lpp/ims/lib
Os primeiros dois caminhos especificados em DFSJVMEV apontam para as bibliotecas de tempo de execução Java Versão 6.0 localizadas no sistema de arquivos z/OS UNIX System Services (USS). . O último caminho especifica o local do libT2DLI.so, que aponta para o código nativo Java para conectividade Java tipo 2 IMS fornecida no IMS Versões 10 e 11. O arquivo libT2DLI.so é criado no sistema de arquivos USS ao executar o programa de instalação IMS para os cenários Java.
Parâmetros CL1,CL2,CL3 e CL4 são parâmetros posicionais que especificam quatro números decimais de três dígitos indicando quais classes de mensagens devem ser processadas por essa região de mensagem. O valor máximo para uma classe é 999. A sequência de especificação das classes determina a prioridade de classe relativa dentro da região da mensagem.
O JMPADTL1 na Listagem 10 também especifica os nomes DD JAVAOUT e JAVAERR. Esses arquivos são usados para aplicativos Java e especificam onde os fluxos Java System.out e System.err são escritos. As instruções DD JAVAOUT e JAVAERR criarão esses arquivos se um deles não existir, e se existir, serão substituídos.
Para indicar qual aplicativo Java chamada quando uma transação for programada, o IMS usa o membro DFSJVMAP IMS.PROCLIB. Cada transação no IMS tem um nome de aplicativo associado. Para o propósito deste artigo, a transação que será usada é ADTLTRAN.
Há duas maneiras de definir transações no IMS: Etapa 1 definições ou dynamic resource definitions (DRD). Use o seguinte comando de consulta DRD na Listagem 14 para obter o nome PSB para a trans.
Listagem 14. Comando de consulta DRD
QRY TRAN NAME(ADTLTRAN) SHOW(PSB CLASS)
A Listagem 15 mostra a saída do comando DRD.
Listagem 15. Saída do comando DRD
Trancode MbrName CC PSBname LCls ADTLTRAN IMSB 0 S2U1LPSJ 2
A saída de comando DRD mostra o nome do PSB e a classe de mensagem para a transação ADTLTRAN. Se o sistema IMS não estiver usando a funcionalidade DRD, é possível encontrar essas definições nas definições da Etapa1 (MODBLKS). Neste caso, o número de classe indicado (2) corresponde ao parâmetro CL1=002 em JMPADTL1 da Listagem 10. O nome do PSB é S2U1LPSJ. O IMS procura o membro DFSJVMAP IMS.PROCLIB para esse nome para determinar a classe Java correta para chamar. A Listagem 16 mostra um exemplo de DFSJVMAP, que mapeia S2U1LPSJ para a classe Java AdditionalCustomerCRUD.
Listagem 16. Membro de amostra DFSJVMAP
********************************************************************** * The Java applications specified here are located in the * SolutionTestApps.jar file. ********************************************************************** S2U1LPSJ=com/ibm/ims/st/opendb/jmp/AdditionalCustomerCRUD **********************************************************************
Ambiente JMP: Desenvolvimento de aplicativo
Esta seção descreve o desenvolvimento do aplicativo JMP
Função: DBA ou programador de aplicativos, dependendo do seu ambiente
Para este exemplo de JMP, quando ADTLTRAN é chamado, o aplicativo Java executado é AdditionalCustomerCRUD. O aplicativo insere informações do cliente no segmento ADTLINFO do banco de dados S2U1ADBD IMS. O PSB sendo usado é definido na Listagem 16.
As etapas para criar o aplicativo JMP incluem as seguintes:
- Criar uma classe Java para representar os layouts de mensagens de entrada/saída
- Criar uma visualização do banco de dados Java para representar o layout do banco de dados
- Criar o aplicativo contendo a lógica de negócios para processar as mensagens de entrada/saída e interagir com o banco de dados
Criar classes de mensagem de entrada/saída Java
Para este exemplo, o aplicativo espera uma mensagem de entrada contendo todos os campos necessários para inserir no segmento ADTLINFO, incluindo os seguintes:
- Número de cliente exclusivo
- Endereço de e-mail
- Número do telefone
- Número do fax
- Nome da empresa
- Carteira de habilitação
- Estado
- Notas adicionais
Este exemplo também usa o mesmo formato de mensagem para a mensagem de saída. Também incluirá um campo de mensagem de erro para indicar sucesso ou falha.
As bibliotecas do driver IMS Universal fornecem uma classe abstrata chamada IMSFieldMessage para objetos Java que representam uma mensagem tanto chegando quanto saindo de uma fila de mensagens IMS. O código Java na Listagem 17 mostra a definição de mensagem de entrada/saída pra o aplicativo.
Listagem 17. Mensagem de entrada/saída Java
public class AdditionalCustomerIOMessage extends IMSFieldMessage {
private static final long serialVersionUID = 23432884;
static DLITypeInfo[] fieldInfo = {
new DLITypeInfo("CustomerNumber", DLITypeInfo.INTEGER, 1, 4, "CUSTNO"),
new DLITypeInfo("Email", DLITypeInfo.CHAR, 5, 30),
new DLITypeInfo("Phone", DLITypeInfo.CHAR, 35, 10),
new DLITypeInfo("Fax", DLITypeInfo.CHAR, 45, 10),
new DLITypeInfo("CompanyName", DLITypeInfo.CHAR, 55, 30),
new DLITypeInfo("DriversLicense", DLITypeInfo.CHAR, 85, 8),
new DLITypeInfo("DLState", DLITypeInfo.CHAR, 93, 2),
new DLITypeInfo("Notes", DLITypeInfo.CHAR, 95, 1468),
new DLITypeInfo("ErrorMessage", DLITypeInfo.CHAR, 1563, 500)
};
/**
* Instantiate a new OutMessage object.
**/
public AdditionalCustomerIOMessage() {
super(fieldInfo, 2070, false); //false indicates that this is not a SPA message
//2070 is the length of the message
}
}
Criando uma visualização de banco de dados Java
Ao acessar o banco de dados IMS de Java usando os drivers IMS Universal, é preciso gerar uma visualização de banco de dados. Essa visualização do banco de dados é uma classe Java com metadados descrevendo IMS PSBs, DBDs, segmentos, campos, relacionamentos, chaves/não chaves e informações de tipo de dados. Isso é necessário para os drivers IMS Universal construírem e validarem consultas com relação a bancos de dados IMS. A visualização do banco de dados gerada deve ser compilada no mesmo nível em que a JVM usado no IMS está ativa.
Para gerar essa classe de metadados, o IMS fornece um Plug-in do Utilitário IMS Enterprise Suite DLIModel para Eclipse, que pode ser transferido por download sem custos (consulte Recursos).
O plug-in é instalado sobre o Eclipse e fornece um assistente, que importa origem PSB e origem DBD para gerar a visualização do banco de dados com base em um PSB em particular. No JCL fornecido na Listagem 10, o PSB usado é S2U1LPSJ, que faz referência a DBD S2U1ADBD. A origem para S2U1LPSJ e S2U1ADBD precisa ser transferida por download com um nome de arquivo que corresponda ao nome de PSB e DBD.
Sugestão: É possível um DBD fazer referência a outros DBDs, assim, certifique-se de fazer o download de todos os DBDs referidos, incluindo DBDs indexados secundários, DBDs lógicos e DBDs referidos nas instruções LCHILD. Entre em contato com o administrador do banco de dados (DBA) para certificar-se de que estão disponíveis para uso.
Quando obtiver todas as partes, siga o tutorial do Capítulo 6.3 Utilitário IBM IMS Enterprise Suite DLIModel para o IMS Versão 11 Visão Geral Técnica (consulte Recursos ).
A Listagem 18 mostra uma visualização de S2U1LPSJDatabaseView.java.
Listagem 18. S2U1LPSJDatabaseView.java
package databaseviews;
import com.ibm.ims.db.*;
import com.ibm.ims.base.*;
public class S2U1LPSJDatabaseView extends DLIDatabaseView {
// This class describes the data view of PSB: S2U1LPSJ
// PSB S2U1LPSJ has database PCBs with 8-char PCBNAME or label:
// PCB01
// The following describes Segment: ADDINFO ("ADDINFO") in PCB: PCB01 ("PCB01")
static DLITypeInfo[] PCB01ADDINFOArray= {
new DLITypeInfo("info_length", DLITypeInfo.SMALLINT, 1, 2),
new DLITypeInfo("CustomerNumber", DLITypeInfo.INTEGER, 3, 4,
"CUSTNO",DLITypeInfo.UNIQUE_KEY),
new DLITypeInfo("Email", DLITypeInfo.CHAR, 7, 30),
new DLITypeInfo("Phone", DLITypeInfo.CHAR, 37, 10),
new DLITypeInfo("Fax", DLITypeInfo.CHAR, 47, 10),
new DLITypeInfo("CompanyName", DLITypeInfo.CHAR, 57, 30),
new DLITypeInfo("DriversLicense", DLITypeInfo.CHAR, 87, 8),
new DLITypeInfo("DLState", DLITypeInfo.CHAR, 95, 2),
new DLITypeInfo("Notes", DLITypeInfo.CHAR, 97, 1468)
};
static DLISegment PCB01ADDINFOSegment= new DLISegment
("ADDINFO","ADDINFO",PCB01ADDINFOArray,1564);
// An array of DLISegmentInfo objects follows to describe the view
// for PCB: PCB01 ("PCB01")
static DLISegmentInfo[] PCB01array = {
new DLISegmentInfo(PCB01ADDINFOSegment,DLIDatabaseView.ROOT)
};
// Constructor
public S2U1LPSJDatabaseView() {
super("2.0.3","S2U1LPSJ", "PCB01", "PCB01", PCB01array, "A");
} // end S2U1LPSJDatabaseView constructor
} // end S2U1LPSJDatabaseView class definition
O aplicativo Java de amostra
O aplicativo de amostra AdditionalCustomerCRUD usa o driver IMS Universal para obter acesso às filas de mensagem do IMS e o JDBC para acessar o banco de dados IMS. A Listagem 19 detalha as principais partes do aplicativo de amostra AdditionalCustomerCRUD.
Listagem 19. Aplicativo AdditionalCustomerCRUD
public static void main(String[] args) {
Application app = ApplicationFactory.createApplication();
Transaction tran = app.getTransaction();
MessageQueue msgQueue = app.getMessageQueue();
IOMessage ioMessage = null;
try {
ioMessage = app.getIOMessage
("class://com.ibm.ims.solutiontest.opendb.jmp.AdditionalCustomerIOMessage");
while (msgQueue.getUnique(ioMessage)) {
IMSDataSource ds = new IMSDataSource();
ds.setMetadataURL("class://databaseviews.S2U1LPSJDatabaseView");
ds.setDatastoreName("IMSB");
ds.setDriverType(IMSDataSource.DRIVER_TYPE_2);
Connection conn = ds.getConnection();
conn.setAutoCommit(false);
PreparedStatement addinfo = conn.prepareStatement("INSERT INTO "
+ "PCB01.ADDINFO (Info_length,CustomerNumber,Email,"
+ Phone, Fax, CompanyName,"
+ "DriversLicense, DLState, Notes) Values(?,?,?,?,?,?,?,?,?)");
addinfo.setInt(1, 1564);
addinfo.setInt(2, ioMessage.getInt("CustomerNumber"));
addinfo.setString(3, ioMessage.getString("email"));
addinfo.setString(4, ioMessage.getString("Phone"));
addinfo.setString(5, ioMessage.getString("Fax"));
addinfo.setString(6, ioMessage.getString("CompanyName"));
addinfo.setString(7, ioMessage.getString("DriversLicense"));
addinfo.setString(8, ioMessage.getString("DLState"));
addinfo.setString(9, ioMessage.getString("Notes"));
int rowsInserted = addinfo.executeUpdate();
if (rowsInserted == 1) {
ioMessage.setString("ErrorMessage", "");
} else {
ioMessage.setString("ErrorMessage", "Insert failed");
}
addinfo.close();
conn.close();
msgQueue.insert(ioMessage, MessageQueue.DEFAULT_DESTINATION);
tran.commit();
}
} catch (Exception e) {
e.printStackTrace();
try {
if(e.getMessage().length()>500){
ioMessage.setString("ErrorMessage", e.getMessage().substring(0, 500));
} else {
ioMessage.setString("ErrorMessage", e.getMessage());
}
msgQueue.insert(ioMessage, MessageQueue.DEFAULT_DESTINATION);
} catch (DLIException e1) {
e1.printStackTrace();
}
}
}
A primeira parte do aplicativo cria as seguintes instâncias para permitir interação com a fila de mensagens:
- Application
- Transaction
- MessageQueue
- IOMessage
As seguintes listagens de código mostram uma instância de aplicativo (app) sendo criada usando ApplicationFactory. O objeto app é usado para obter um controle sobre uma instância de transaction, messageQueue e ioMessage. Ao criar uma instância de ioMessage, um parâmetro de sequência é usado para especificar o nome totalmente qualificado da classe Java criada para representar a mensagem. A Listagem 20 é um extrato da Listagem 19.
Listagem 20. Mensagem de entrada/saída da classe Java
Application app = ApplicationFactory.createApplication();
Transaction tran = app.getTransaction();
MessageQueue msgQueue = app.getMessageQueue();
IOMessage ioMessage = app.getIOMessage
+ ("class://com.ibm.ims.solutiontest.opendb.jmp.AdditionalCustomerIOMessage");
A seguir, o aplicativo usa a instância MessageQueue (msgQueue) para recuperar mensagens da fila de mensagens IMS usando a chamada de método getUnique. O método getUnique toma um parâmetro, ioMessage, que define a estrutura da mensagem da mensagem de entrada esperada descrita na Listagem 17. . Se a chamada getUnique é bem-sucedida, ioMessage é preenchida com os dados da mensagem de entrada de transaction. A Listagem 21 mostra a chamada getUnique.
Listagem 21. Chamada getUnique
while (msgQueue.getUnique(ioMessage))
Quando a mensagem é recuperada, o aplicativo cria IMSDataSource para obter uma conexão de tipo 2 para S2U1LPSJ PSB. Para especificar o PSB para o aplicativo ao qual se conectar, forneça o nome de classe totalmente qualificado da visualização de banco de dados criada na Listagem 18. . Então use a instância IMSDataSource (ds) para obter uma conexão JDBC, como mostrado na Listagem 22.
Listagem 22. Obtendo uma conexão JDBC
IMSDataSource ds = new IMSDataSource();
ds.setMetadataURL("class://databaseviews.S2U1LPSJDatabaseView");
ds.setDatastoreName("IMSB");
ds.setDriverType(IMSDataSource.DRIVER_TYPE_2);
Connection conn = ds.getConnection();
Ao usar JDBC de dentro de uma transação do IMS, a conexão JDBC setAutoCommit deve ser definida para falso para evitar que conexões JDBC automaticamente confirmem trabalho. Confirmações são, em vez disso, emitidas explicitamente usando o objeto transaction ou implicitamente confirmadas quando o método getUnique retorna um código de status de QC do IMS indicando que não há mais mensagens na fila, como mostrado na Listagem 23.
Listagem 23. setAutoCommit
conn.setAutoCommit(false);
A seguir, o aplicativo cria PreparedStatement (addinfo) para definir a chamada de inserção SQL, como mostrado na Listagem 24. Essa chamada SQL será inserida no segmento ADDINFO definido em S2U1LPSJ PSB, e fornecerá os dados de entrada, incluindo o seguinte:
- Info_length
- CustomerNumber
- Fone
- Fax
- CompanyName
- Habilitação
- DLState
- Notas
Listagem 24. Fornecendo dados de entrada
PreparedStatement addinfo = conn.prepareStatement("INSERT INTO "
+ "PCB01.ADDINFO (Info_length,CustomerNumber,Email, Phone, Fax, CompanyName,"
+ "DriversLicense, DLState, Notes) Values(?,?,?,?,?,?,?,?,?)");
O aplicativo então usa ioMessage para obter os dados da mensagem de entrada. O aplicativo usa os dados para definir campos addinfo para inserir no segmento ADTLINFO, como mostrado na Listagem 21. Os valores 1-9 nos métodos addinfo.set listados na Listagem 25 correspondem a cada um dos nove pontos de interrogação (?) (?) especificados em PreparedStatement.
Listagem 25. Configurando dados
addinfo.setInt(1, 1564);
addinfo.setInt(2, ioMessage.getInt("CustomerNumber"));
addinfo.setString(3, ioMessage.getString("email"));
addinfo.setString(4, ioMessage.getString("Phone"));
addinfo.setString(5, ioMessage.getString("Fax"));
addinfo.setString(6, ioMessage.getString("CompanyName"));
addinfo.setString(7, ioMessage.getString("DriversLicense"));
addinfo.setString(8, ioMessage.getString("DLState"));
addinfo.setString(9, ioMessage.getString("Notes"));
Depois que os valores da instrução preparados estão definidos, o aplicativo executa a instrução usando o método executeUpdate(), que retorna um número inteiro indicando o número de linhas (segmentos) afetados pela chamada, como mostrado na Listagem 26.
Listagem 26. Número de linhas inseridas
int rowsInserted = addinfo.executeUpdate();
No caso desta inserção, o aplicativo verifica que uma linha foi inserida no banco de dados. Se a operação foi bem-sucedida, o aplicativo define o campo ErrorMessage da mensagem de saída como em branco. Caso contrário, define o campo ErrorMessage d mensagem de saída como Insert failed, como mostrado na Listagem 27.
Listagem 27. Falha na inserção
if (rowsInserted == 1) {
ioMessage.setString("ErrorMessage", "");
} else {
ioMessage.setString("ErrorMessage", "Insert failed");
}
O aplicativo então insere uma mensagem de saída para a fila de mensagens do IMS usando DEFAULT_DESTINATION, como mostrado na Listagem 28. O aplicativo também pode escolher inserir mensagens para destinos de mensagem alternativos. Depois da inserção, o aplicativo confirma a unidade de trabalho.
Listagem 28. Inserir mensagem
msgQueue.insert(ioMessage, MessageQueue.DEFAULT_DESTINATION); tran.commit();
Por fim, o aplicativo fecha as instâncias de conexão e a instrução preparada, como mostrado na Listagem 29.
Listagem 29. Fechar instrução preparada
addinfo.close(); conn.close();
Ambiente JMP: Implementando o aplicativo Java
Esta seção descreve como implementar o aplicativo Java.
Função: Desenvolvedor de aplicativos e Administrador do sistema
Depois de escrever o aplicativo, a próxima etapa é implementá-lo. Para implementar o aplicativo, exporte o projeto Java como um arquivo jar e coloque em FTP o arquivo jar para o seu sistema de arquivos USS no modo BINARY no LPAR no qual deseja executar. O arquivo jar deve ser referido no membro DFSJVMMS IMS.PROCLIB descrito na Listagem 11 para DFSJVMMS. No DFSJVMMS, stjava é o diretório para o qual o archive do aplicativo SolutionTestApps.jar foi colocado em FTP.
Ambiente JMP: Executando a transação JMP
Esta seção descreve como executar a transação JMP
Função: Desenvolvedor de aplicativos
Agora que todas as partes estão no lugar (JCL, membros IMS.PROCLIB e classes Java), execute JMPADTL1 JCL a partir da Listagem 10. Para verificar que a região JMP está executando, emita o comando /DISPLAY ACTIVE REGION do comando IMS e verifique se a saída é similar à da Listagem 30.
Listagem 30. /DISPLAY IACTIVE REGION
DFS000I REGID JOBNAME TYPE TRAN/STEP PROGRAM STATUS CLASS IMSB DFS000I 1 JMPADTL1 TPE WAITING 2 IMSB
Agora a transação ADTLTRAN do IMS está pronta para a execução. A próxima etapa é chamar o aplicativo. É possível chamar a transação do IMS a partir de qualquer um dos seguintes:
- Adaptador de recursos TM
- Interface do cliente OTMA
- Aplicativos MFS
- API de conexão do IMS para C
- API de conexão do IMS para Java
- Console do MVS
- Terminal do IMS
Depois de a transação ser chamada com sucesso, verifique os locais de saída especificados por JAVAOUT e JAVAERR. Com base na tarefa JMPADTL1, você encontrará JAVAOUT em /tmp/jvm.out, e é possível localizar JAVAERR em /tmp/jvm.err no ambiente USS. Caso nada tenha sido escrito para qualquer um dos fluxos, jvm.err e jvm.out estarão vazios.
Na maioria dos sistemas z/OS, é possível acessar o ambiente USS emitindo OMVS a partir de TSO. Para procurar um arquivo chamado jvm.out no USS localizado no caminho tmp , emita o comando obrowse /tmp/jvm.out especificado.
O aplicativo fornece uma resposta de mensagem de saída que é retornada para o cliente.
Solução MPP: Visão geral
Esta seção descreve como usar uma região MPP para uma solução COBOL para Java. Este cenário é uma transação de pagamento de seguro que acessa um banco de dados IMS para determinar o valor devido para uma apólice e também paga apólices atualizando o banco de dados com informações de pagamento. Esse cenário de interoperabilidade COBOL/Java inicia com um aplicativo IMS COBOL. Quando o aplicativo COBOL é chamado, ele chama um programa wrapper OO COBOL, que chama um método Java. O programa wrapper OO COBOL é essencialmente um programa que converte a interface COBOL em uma interface Java. A meta para esse cenário é estender um programa COBOL legado para chamar métodos Java modernizados que podem acessar tanto bancos de dados IMS quanto bancos de dados DB2.
No IMS 10 e IMS 11, o IMS fornece suporte para uma JVM persistente nas regiões MPP/BMP/IFP/JMP/JBP. Também suporta chamadas do DB2 de um aplicativo Java chamado por um MPP/BMP/IFP/JMP/JBP usando uma External Subsystem Attach Facility (ESAF). Atualmente, cada vez que um aplicativo Java é chamado, o COBOL cria e destrói a JVM. Esse novo suporte possibilita que o IMS agora gerencie a JVM apenas uma vez e a mantenha ao longo da vida da região.
Ambiente MPP: Configuração
Esta seção descreve a configuração do ambiente MPP.
Função: Programador de sistema
Para executar um aplicativo de interoperabilidade COBOL/Java, é necessária alguma configuração. Esta seção descreve todas as etapas necessárias para executar a solução COBOL para Java em uma região MPP.
A Listagem 31 mostra uma tarefa de amostra para iniciar a região MPP.
Listagem 31. Tarefa de amostra para iniciar a região MPP
//IMSMPP01 JOB , // CLASS=A,MSGCLASS=H,MSGLEVEL=(1,1),NOTIFY=&SYSUID,REGION=0M /*JOBPARM S=* //PROCS JCCLIB ORDER=IMS.PROCLIB //IMSMPP01 EXEC PROC=DFSMPR,TIME=(1440), // NBA=6, // OBA-5; // SOUT=’*’ // CL1=001, TRANSACTION CLASS 1 // CL2=000, TRANSACTION CLASS 2 // CL3=000, TRANSACTION CLASS 3 // CL4=000, TRANSACTION CLASS 4 // TLIM=10, MPR TERMINATION LIMIT // SOD=, SPIN-OFF DUMP CLASS // ENVIRON=DFSJVMEV, // JVMOPMAS=DFSJVMMS, // IMSID=IMSB, IMSID OF IMS CONTROL REGION // PREINIT=DC, PROCLIB DFSINTXX MEMBER // PWFI=N PSEUDO=WFI //PROCLIB DD DISP=SHR,DSN=IMS.PROCLIB //DFSCTL DD DISP=SHR,DSN=IMS.PROCLIB(DFSSBPRM) //SYSEXEC DD DSN=IMS.SDFSEXEC, // DISP=SHR //SYSTSIN DD * //SYSTSPRT DD SYSOUT=* //SYSOUT DD SYSOUT=*
A tarefa IMSMPP01 executa o procedimento DFSMPR fornecido no IMS.PROCLIB padrão. Os parâmetros incluem o seguinte:
- IMSID
- O ID do subsistema do IMS sob o qual executar
- ENVIRON
- O nome do membro IMS.PROCLIB que contém o caminho da biblioteca (LIBPATH) para o ambiente Java
- JVMOPMAS
- O nome do membro IMS.PROCLIB que contém as opções CLASSPATH e para a JVM mestre.
- CL1, CL2, CL3, CL4
- Um parâmetro posicional requerido que especifica números decimais de três dígitos indicando quais classes de mensagem devem ser processadas por esta região de mensagem. O valor máximo para uma classe é 999. A sequência de especificação das classes determina a prioridade de classe relativa dentro da região da mensagem.
A Listagem 32 define as configurações de ENVIRON
Listagem 32. Membro de amostra DFSJVMEV
********************************************************************** * Specify the location of Java Virtual Machine (JVM) installation and * IMS Java native code (libT2DLI.so) ********************************************************************** LIBPATH=> /javaroot/java160/J6.0/bin:> /javaroot/java160/J6.0/bin/j9vm:> /usr/lpp/ims/lib
Os primeiros dois caminhos especificados em DFSJVMEV apontam para as bibliotecas de tempo de execução Java Versão 6.0 localizadas no sistema de arquivos z/OS UNIX System Services (USS). O terceiro caminho especifica o local de libT2DLI.so, que aponta para o código nativo Java para conectividade Java tipo 2 do IMS fornecida no IMS Versões 10 e 11. O arquivo libT2DLI.so é criado no sistema de arquivos USS durante a execução do processo de instalação do IMS para cenários Java. A Listagem 33 define as opções da JVM JVMOPMAS.
Listagem 33. Membro de amostra DFSJVMMS
******************************************************************** * Specify the profile that has environment settings and JVM options. * The following two JVM options are required. ******************************************************************** -Djava.class.path=> /stjava/ims/IMS Universal driver .jar:> /stjava/ims/imsutm.jar:> /stjava/SolutionTestApps.jar:> ******************************************************************** * The following JVM options are a subset of the options allowed * * Xmx64M - set the maximum Java heap size of your program * Xmso512k - set stack size for OS threads for 32 bit * Xss256k - set Java thread stack size * Xms1M - set initial Java heap size ******************************************************************** -Xmaxf0.8 -Xminf0.3 -Xmx64M -Xmso512k -Xss256k -Xms1M
Esteja ciente dos seguintes detalhes:
- O CLASSPATH (java.class.path) especifica as bibliotecas do IMS Universal .jar e imsutm.jar.
- As .jar e imsutm.jar do driver IMS Universal são bibliotecas necessárias ao se programar com as APIs do driver IMS Universal.
- As .jar e imsutm.jar do driver IMS Universal podem ser instadas usando o installation verification program (IVP) do IMS para cenários Java.
- As .jar e imsutm.jar do driver IMS Universal são bibliotecas necessárias ao se programar com as APIs do driver IMS Universal.
- A instalação SMP/E do IMS Java On Demand FMID adiciona as partes necessárias aos diretórios apropriados no sistema de arquivos.
- Antes de o IMS Java On Demand FMID poder ser instalado, um sistema de arquivos ZFS ou HFS deve ser criado e montado.
- Quando esse sistema de arquivos tiver sido montado, a tarefa de amostra FSJSMKD é executada para criar os diretórios no sistema de arquivos.
- DFSJSMKD chama DFSJMKDR para criar as estruturas de diretório e o link simbólico libT2DLI.so.
Ambiente MPP: Desenvolvimento de aplicativo
Esta seção descreve o desenvolvimento do aplicativo MPP
Função: Desenvolvedor de aplicativos
Opções de compilação dll e encadeamento devem ser especificadas para o programa OO COBOL. O parágrafo Program-id do programa deve ser qualificado com a palavra-chave recursivo para o programa OO COBOL chamar métodos Java. O código de amostra na Listagem 34 implementa um programa OO COBOL (INQPAY.cbl) para o programa Java (JavaPayPolicy.java) passando um tipo de dado primitivo e retornando um tipo de dado primitivo de um banco de dados IMS.
Listagem 34. INQPAY.cbl
cbl dll,thread
Identification division.
Program-id. "INQPAY" recursive.
Environment division.
Configuration section.
Repository.
Class Base is "java.lang.Object"
Class JavaException is "java.lang.Exception"
Class jstring is "jstring"
Class JavaPayPolicy is "JavaPayPolicy".
DATA DIVISION.
WORKING-STORAGE SECTION.
01 jpp object reference JavaPayPolicy.
01 stringBuf pic X(500) usage display.
01 ccDate object reference jstring.
01 rc pic s9(9) comp-5
01 CA-PAYMENT-CCEXP PIC X(10).
01 CA-PAYMENT-ID PIC 9(10).
01 PAYMENTID PIC S9(9) COMP.
01 AMOUNTDUE pic S9(6) comp-5.
Linkage section.
COPY STCMAREA.
COPY JNI.
01 IOPCB.
02 LTERM-NAME PICTURE X(8).
02 FILLER PICTURE X(2).
02 TPSTATUS PICTURE XX.
02 FILLER PICTURE X(3620).
01 DBPCB.
02 DBNAME PICTURE X(8).
02 SEG-LEVEL-NO PICTURE X(2).
02 DBSTATUS PICTURE XX.
02 FILLER PICTURE X(20).
Procedure division USING IOPCB, COMM-AREA, DBPCB.
Set address of JNIenv to JNIEnvPtr
Set address of JNINativeInterface to JNIenv
Move CA-PAYMENT-ID to PAYMENTID
IF CA-REQUEST-ID EQUAL 'INQPAY '
THEN Invoke JavaPayPolicy "getAmountPaid" using by value
PAYMENTID returning
AMOUNTDUE
Goback.
End program
"INQPAY".
O código de amostra na Listagem 35 implementa um programa OO COBOL para programa Java passando um tipo de dado primitivo e retornando um tipo de dado de sequência de um banco de dados do IMS.
Listagem 35. Fragmento do código INQPAY.cbl
Invoke JavaPayPolicy "getCCDate" using by value
PAYMENTID returning
ccdate
Call 'GetStringPlatform'
using by value JNIEnvPtr
ccDate
address of stringbuf
500
0
returning rc
If rc not = zero then
Display "Error occurred creating CARDEXP object"
Stop run
End-if
MOVE stringBuf to CA-PAYMENT-CCEXP
Goback.
End program
"INQPAY".
|
A Listagem 36 mostra os métodos getAmountPaid e getCCDate que o programa OO COBOL chama que faz uma chamada IMS DB e retornar o resultado para o programa OO COBOL de chamada. Para mais informações sobre passar parâmetros entre programas OO COBOL e Java, tipos de dados devem ser interoperáveis como descrito no Enterprise COBOL para z/OS (consulte Recursos ).
Listagem 36. JavaPayPolicy.java
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.text.DecimalFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.annotation.Resource;
import javax.annotation.Resource.AuthenticationType;
import javax.sql.DataSource;
import com.ibm.ims.dli.tm.ApplicationFactory;
import com.ibm.ims.dli.tm.Transaction;
import com.ibm.ims.dli.tm.Application;
import com.ibm.ims.jdbc.IMSDataSource;
import java.sql.DriverManager;
import java.util.logging.*;
//import test.PaymentInfo;
import com.ibm.ims.jdbc.IMSDataSource;
public class JavaPayPolicy
{
static int amountDue=0;
static Application app = null;
private static Transaction tran = null;
final static Logger loggerDli = Logger.getLogger("com.ibm.ims.db.opendb.dli");
final static Logger loggerT2 = Logger.getLogger("com.ibm.ims.db.dli.t2");
public static String getCCDate(int paymentID) {
try{
IMSDataSource datasource = new IMSDataSource();
datasource.setDriverType(IMSDataSource.DRIVER_TYPE_2);
datasource.setDatastoreName("IMSB");
datasource.setMetadataURL(
"class://databaseviews.S2U1PSBDatabaseView");
Connection conn = datasource.getConnection();
conn.setAutoCommit(false);
// create a statement
PreparedStatement stmt = conn.prepareStatement(
"Select creditCardExp from PGINSUR.Payment where PAYMENTID ="
+ paymentID);
while (rs.next()) {
creditCardExp = rs.getString(1);
}
rs.close();
stmt.close();
conn.close();
app = ApplicationFactory.createApplication();
tran = app.getTransaction();
return creditCardExp;
}catch(SQLException e) {
e.printStackTrace();
return null;
}
}
public static int getAmountPaid(int paymentID) {
try{
IMSDataSource datasource = new IMSDataSource();
datasource.setDriverType(IMSDataSource.DRIVER_TYPE_2);
datasource.setDatastoreName("IMSB");
datasource.setMetadataURL(
"class://databaseviews.S2U1PSBDatabaseView");
Connection conn = datasource.getConnection();
conn.setAutoCommit(false);
// create a statement
PreparedStatement stmt = conn.prepareStatement(
"Select amount from PGINSUR.Payment where PAYMENTID ="
+ paymentID);
while (rs.next()) {
amountPaid = Integer.parseInt(rs.getString(1));
}
rs.close();
stmt.close();
conn.close();
app = ApplicationFactory.createApplication();
tran = app.getTransaction();
return amountPaid;
}catch(SQLException e) {
e.printStackTrace();
return -5;
}
}
}
|
A Listagem 37 mostra o código JCL de amostra usado para compilar um link com um programa OO COBOL. Os objetos do programa devem residir em um PDSE. O tamanho da região deve ser definido para 96M ou maior. O parâmetro PGMNAME(LONGMIXED) deve ser especificado para compilação.
Listagem 37. INQPAY.jcl
//C EXEC PGM=IGYCRCTL,REGION=512M, // PARM='TEST(ALL,SYM,SEP),SOURCE,LIB,MAP,LIST,XREF,NOTERM, // THREAD,RENT,PGMNAME(LONGMIXED)' //STEPLIB DD DISP=SHR,DSN=IGYV3R40.SIGYCOMP // DD DISP=SHR,DSN=CEE.SCEERUN //SYSDEBUG DD DISP=SHR,DSN=IMS.SYSDEBUG(INQPAY) //SYSLIN DD DSN=IMS.OBJ(INQPAY), // DISP=(OLD,KEEP),SPACE=(CYL,(1,1,1)),UNIT=VIO //SYSLIB DD DISP=SHR,DSN=IMS.COPY //SYSPRINT DD DISP=SHR,DSN=IMS.LISTCOB(INQPAY) //SYSUT1 DD UNIT=SYSDA,DISP=(,DELETE), // SPACE=(CYL,(1,1)) //SYSUT2 DD UNIT=SYSDA,DISP=(,DELETE), // SPACE=(CYL,(1,1)) //SYSUT3 DD UNIT=SYSDA,DISP=(,DELETE), // SPACE=(CYL,(1,1)) //SYSUT4 DD UNIT=SYSDA,DISP=(,DELETE), // SPACE=(CYL,(1,1)) //SYSUT5 DD UNIT=SYSDA,DISP=(,DELETE), // SPACE=(CYL,(1,1)) //SYSUT6 DD UNIT=SYSDA,DISP=(,DELETE), // SPACE=(CYL,(1,1)) //SYSUT7 DD UNIT=SYSDA,DISP=(,DELETE), // SPACE=(CYL,(1,1)) //SYSIN DD DISP=SHR, // DSN=IMS.COBOL(INQPAY) // SET VAR= '/ENVAR("_CEE_ENVFILE=/Java/ENVAR")' // SET VAR2= 'POSIX(ON),XPLINK(ON)' //L EXEC PGM=IEWL, // PARM='&VAR &VAR2 RENT,LIST,LET,DYNAM(DLL), // CASE(MIXED),MAP,XREF,RMODE(ANY)', // COND=(4,LT,C) //RESLIB DD DSN=IMSNST.I11APAR.DBDC.CM1.SDFSRESL,DISP=SHR //SYSLIB DD DSN=SYS1.V1R3M2.COB2LIB,DISP=SHR // DD DISP=SHR,DSN=NEELA.MNA.S2U1F6.COPY // DD DSN=SYS1.MACLIB,DISP=SHR // DD DSN=CEE.SCEERUN,DISP=SHR // DD DSN=CEE.SCEELKED,DISP=SHR // DD DSN=IMS.SDFSRESL,DISP=SHR // DD DSN=IMS.PGMLIB,DISP=SHR //SYSLMOD DD DSN=IMS.PGMLIB(INQPAY),DISP=SHR,UNIT=VIO, // SPACE=(CYL,(1,1,1)),DSNTYPE=LIBRARY //SYSPRINT DD SYSOUT=* //SYSTERM DD SYSOUT=* //SYSUT1 DD UNIT=SYSDA,SPACE=(CYL,(5,1)) //SYSDEFSD DD DUMMY //OBJMOD DD DSN=IMS.OBJ,DISP=(OLD,KEEP) //SYSLIN DD * INCLUDE OBJMOD(INQPAY) INCLUDE '/javaroot/java160/J6.0/bin/classic/libjvm.x' INCLUDE '/cob42/lib/igzcjava.x' //*
Resolução de problemas
O parâmetro JVMOPAS é necessário na região de inicialização do MPP. Se o parâmetro não for especificado corretamente, a região encerra com um U0101.
Se você receber a mensagem de erro ABEND=S000 U4088 REASON=000003EC, certifique-se de que o tamanho da região é de 96M ou mais.
Se você receber a mensagem de erro IEW2606S 4B39 MODULE INCORPORATES VERSION 3 PROGRAM OBJECT FEATURES AND CANNOT BE SAVED IN LOAD MODULE FORMAT, verifique se o objeto do programa reside em um PDSE.
Se você receber a mensagem de erro Cannot find the libjvm.so file, crie um módulo como mostrado na Listagem 37 e inclua o módulo criado na seção de ligação do JCL usado para compilar e fazer ligação do programa OO COBOL.
A ligação JCL é mostrada na Listagem 38.
Listagem 38. Ligação JCL
//HLASM EXEC PGM=ASMA90,PARM='LINECOUNT(0)'
//SYSPRINT DD SYSOUT=*
//SYSUT1 DD UNIT=SYSDA,SPACE=(CYL,(1,1))
//SYSUT2 DD UNIT=SYSDA,SPACE=(CYL,(1,1))
//SYSUT3 DD UNIT=SYSDA,SPACE=(CYL,(1,1))
//SYSLIN DD DSN=NEELA.MNA.S2U1F6.OBJ(SHAYCEE),DISP=SHR
//SYSLIB DD DSN=CEE.SCEEMAC,DISP=SHR
// DD DSN=SYS1.MACLIB,DISP=SHR
//SYSIN DD *
TITLE 'CEEUOPT'
CEEUOPT CSECT
CEEUOPT AMODE ANY
CEEUOPT RMODE ANY
CEEXOPT XPLINK=(ON),
POSIX=(ON),
STACK=(512K,512K,ANYWHERE,KEEP,512K,512K),
ENVAR=('_CEE_ENVFILE=/Java/ENVAR')
END
//*//*
Conclusão
Este artigo descreve como o IMS oferece várias soluções para desenvolver e estender aplicativos em ambientes do cliente usando Java. Como parte do IMS Versões 10 e 11, o IMS fornece ao driver Universal Driver Database (driver IMS Universal) Java suporte para conectividade tipo 2 dentro de regiões dependentes de IMS. Esse suporte possibilita aos clientes desenvolver novos aplicativos em Java usando o driver IMS Universal JDBC e no driver IMS Universal DL/I.
Recursos
Aprender
- Saiba mais no Biblioteca do IMS
- Acesse a seção Soluções IMS para Desenvolvimento em Java.
- Saiba mais sobre o Plug-in do Utilitário DLIModel.
- Explore o InfoCenter para mais informações sobre o plug-in do utilitário IMS Enterprise Suite DLIModel.
- Consulte Calling Java from COBOL para informações sobre Java e COBOL.
- Consulte os artigos das Soluções IMS Utilizing IMS synchronous callout function to invoke a CICS Web service through IMS SOAP Gateway .
- Saiba sobre Information Management na zona de Information Management do developerWorks. Encontre documentação técnica, artigos com instruções, educação, downloads, informações sobre produtos e mais.
- Fique por dentro dos eventos técnicos e webcasts do developerWorks .
- Siga DeveloperWorks no Twitter.
Obter produtos e tecnologias
- Crie seu próximo projeto de desenvolvimento com a versão de teste do software IBM, disponível para download diretamente no developerWorks.
Discutir
- Participar do fórum de discussão.
- Confira os Blogs do developerWorks e participe da comunidade do developerWorks.
Qual a sua opinião?