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.
De 0 a 10, o quanto você recomendaria este artigo para um amigo?