Você está na página 1de 141

Treinamento Integration Bus 10

Página 1
Introdução ao Integration Bus

Página 2
Introdução ao Integration Bus

Objetivos

 Explicar o papel do “IBM Integration Bus” na arquitetura de


referência IBM WebSphere;
 Listar as principais funções de um “Enterprise Service Bus”;
 Descrever as funcionalidades do “IBM Integration Bus”;
 Descrever a arquitetura e componentes do “IBM Integration Bus”;

Página 3
Introdução ao Integration Bus
Arquitetura de Referência “IBM WebSphere”
Business Services
WebSphere Business Monitor

Information Services
Interaction Services Process Services
WebSphere
WebSphere Portal IBM Business
Information
Server Process Manager
Integrator
Development
Services
WebSphere
Business ESB
Management
Integration IBM Integration Bus
Services
Modeler e Service Registry
WebSphere
Integration
Developer Business Application
Partner Services Access Services
Services
WebSphere Partner WBI e WebSphere
WebSphere
Gateway Adapters, HATS
Application Server

Infraestructure Services

Página 4
Introdução ao Integration Bus
“Enterprise Service Bus” (ESB)
 Infraestrutura de conectividade flexível para aplicações e serviços;
 Reduz o número, tamanho e complexidade das interfaces;
 Atua entre o requisitante e o serviço:
o Roteando mensagens entre serviços;
o Convertendo o protocolo de transporte;
o Transformando o conteúdo da mensagem;
o Lidando com eventos de negócio de diferentes
fontes;

Shape = Protocol
Color = Data type

Página 5
Introdução ao Integration Bus
Introduzindo o “IBM Integration Bus”
 Um produto único para Windows .NET, Java e cenários de
integração totalmente heterogêneos;

 Evolução natural de aplicações “WebSphere Message Broker”;


o Inovações e evoluções da base tecnológica do “WebSphere Message
Broker”;
o Novas funcionalidades para balanceamento de carga baseada em
política, integração com IBM BPM, “business rules”, e .NET;
 Incorpora os casos de uso do “WebSphere Enterprise Service
Bus”;
Página 6
Introdução ao Integration Bus
Arquitetura do “IBM Integration Bus”
IBM Integration Bus

WebSphere
Application Server IBM Integration IBM Integration
administrative web user Toolkit
console interface

Controle
de Versão

Integration node (broker)

Application

Message Flows

Libraries
Sistema
Externo

Página 7
Introdução ao Integration Bus
“IBM Integration Bus” como um “Message Broker”
Queue manager

Integration node (broker)


Compute Output

Input Filter
Compute Output

 Recebe e roteia mensagens;


 Transforma mensagens para uma representação alternativa;
 Filtra mensagens com base no seu conteúdo;
 Interage com banco de dados externo para enriquecer uma
mensagem ou para persistir a mensagem ou parte dela;
 Responde a eventos e erros;
Página 8
Introdução ao Integration Bus
Funcionalidades do “IBM Integration Bus”
 Conectividade universal:
o Converte projetos do WebSphere ESB;
o Ferramentas de análise e descoberta de banco de dados;
o Modelagem de dados no padrão “Data Format Description Language”
(DFDL);
o Mapeamento de serviços;
 Transforma e roteia mensagem de qualquer lugar para qualquer
outro:
o Suporta uma gama enorme de protocolos e formatos de dados;
o Inclui diversas operações para rotear, filtrar, transformar, enriquecer,
monitorar, correlacionar e detectar;
 Gestão da Operação e da Performance:
o Ferramentas web para estatísticas de performance em tempo real;
o Funcionalidades para administração e gestão de sistemas para as
soluções desenvolvidas;
Página 9
Introdução ao Integration Bus
Ambientes de Software e Hardware suportados
 Ampla gama de sistemas operacionais e hardware:
o AIX, Windows, z/OS, HP-UX, Linux, Solaris e Ubuntu;
o Suporte otimizado para 64 bits em todos os ambientes;
o Opção de 32 bits para ambientes de desenvolvimento;
 Imagens virtuais para uso eficiente e provisão de forma simples:
o Ambientes virtualizados como “Wmware ” e “AIX Hypervisor”;
o “IBM Workload Deployer” para Linux (System X) e AIX;
o Suporte para Pure em hardware Power;
 Acesso a gama completa de bancos de dados e sistemas ERP:
o DB2, Oracle, Sybase, SQL Server, Informix e SolidDB;
o JDBC tipo 4 para banco de dados suportados;
o SAP, Siebel, PeopleSoft e JDEdwards;

Página 10
Introdução ao Integration Bus

Pré-requisitos
 WebSphere MQ V7.5 (V7.1 no z/OS);
 Java 7 em todos os ambientes;
 Outros pré-requisitos são definidos por sistema operacional e
hardware. Detalhes podem ser encontrados em:
- www.ibm.com/integration-bus;

Página 11
Introdução ao Integration Bus
Componentes do “IBM Integration Bus”
“IBM Integration Toolkit”;
“Integration Node”;
 “IBM Integration web user interface”;
 “Integration API”;
 Utilitários de linha de comando;

Página 12
Introdução ao Integration Bus
“IBM Integration Toolkit”
 Ambiente de desenvolvimento integrado e interface de usuário
baseado no Eclipse;
 Uma única perspectiva para compilação, testes, implantação e
correção de “Message flows”;
 Conecta para um ou mais “Integration nodes” para os quais os
“Message flows” são implantados;
 Relevante galeria de exemplos e padrões para iniciar o
aprendizado rapidamente;
 Executa em Windows e Linux em x86;

Página 13
Introdução ao Integration Bus

“IBM Integration Bus web user interface”


 Visualiza e gerencia recursos do “IBM Integration Bus” sem
qualquer software de gerenciamento adicional;
 Acessa funcionalidades operacionais como registro de dados
nativo e ferramenta de reprocessamento;
 Configura o gerenciamento de carga de trabalho baseada em
políticas;

Página 14
Introdução ao Integration Bus
Utilitários de linha de comando
 Comandos de “runtime” do “IBM Integration Toolkit”;
 Tem dependências com o “WebSphere MQ”:
o Necessita de um ambiente de comando especial;
o Pode requerer uma configuração de segurança extra;
 Disponível nos mesmos sistemas operacionais que o “IBM
Integration Bus” suporta;

Página 15
Introdução ao Integration Bus

“Integration API”
 Interface de programação de aplicações (API) para administração
do “IBM Integration Bus”;
 Aplicações podem usar a API para controlar “Integration nodes” e
seus recursos através de uma interface remota
 Necessita de “Websphere MQ Classes for Java”;

http://www-01.ibm.com/support/knowledgecenter/SSMKHH_10.0.0/com.ibm.etools.mft.cmp.doc/index.html?lang=pt-br

Página 16
Introdução ao Integration Bus

Conectividade com adaptadores, “bridges” e clientes


Conexões nativas: HTTP, FTP, web services, JMS, email,
“WebSphere MQ”;
 Conexões para EIS como SAP, Siebel, JD Edwards ou PeopleSoft
necessitam de adaptadores;
 Conectividade com z/OS usando IMS bridge ou CICS;
 WBI adapters: WBI adapter for JDBC, WBI adapter for Jtext;
 JCA adapters: SAP, JDBC, Siebel, Oracle Apps;

Página 17
Introdução ao Integration Bus
“Integration Services” no “IBM Integration Bus”
Contêineres bem definidos de lógica de integração que são criados
para o barramento;
 Definidos através de recursos padronizados:
o WSDL (“port type”) define a interface do serviço;
o Interface do serviço define uma ou mais operações;
o Descritor do serviço (XML) amarra a interface do serviço com a
implementação;
 Simplifica o ciclo de vida de criação de serviços e gerenciamento:
o Criação facilitada de novos serviços de integração;
o Implantação de forma similar das aplicações de integração padrão;

Página 18
Fundamentos de desenvolvimento;

Página 19
Fundamentos de Desenvolvimento

Objetivos
 Descrever como o IBM Integration Bus executa o processamento
de mensagens;
 Descrever os componentes do message flow e os nós de
processamento de mensagem;
 Importação e exportação de recursos de e para o Integration
Toolkit;
 Examinar as propriedades dos nós MQInput, MQOutput e
Compute;
 Usar o IBM Integration Toolkit Test Client para testar um message
flow;
 Usar o IBM Integration Toolkit para checar o status no integration
node, integration server e message flow

Página 20
Fundamentos de Desenvolvimento

Interação entre os componentes principais

Página 21
Fundamentos de Desenvolvimento

Integration node do IBM Integration Bus


 Roteia, transforma e enriquece mensagens conforme definido nos
message flows e modelos de mensagem
 Podem haver vários integration nodes, cada um executando em
um sistema diferente para:
o Prover proteção contra falha
o Separar o trabalho
 Não requer uma queue manager do WebSphere MQ dedicada
 Deve possuir direitos de administrador para ser criado

Página 22
Fundamentos de Desenvolvimento

Integration servers
 Agrupamento de message flows que são implantados em um
integration node
 Executa em espaços de endereços diferentes (diferentes processos
do SO) para fornecer isolação dos ambientes de execução para um
grupo de message flows implantados
 Dentro dos integration servers existem conjuntos de threads
configuráveis alocados para os message flows implantados
 Cada integration server de um integration node deve possuir um
nome único
o O limite de quantidade de caracteres para o nome é 30
 O integration server é o mesmo que DataFlowEngine (DFE)

Página 23
Fundamentos de Desenvolvimento

Message flows
 Um message flow é uma sequência de operações
o Composto de nodes de message flow que estão conectados um nos outros
o Devem incluir um nó de entrada que é a fonte das mensagens a serem processadas
o Em geral, incluem um ou mais nós de saída que entregam as mensagens para seus
destinos

Nó de Entrada Conexão Message Flow

Nó de
Grupo de Processam.
Terminais

Nó de Saída
Terminal de
Saída

Terminal
Input

Página 24
Fundamentos de Desenvolvimento

Modelo de mensagem e árvore


 O IBM Integration Bus roteia e manipula mensagens depois de convertê-
las em uma árvore lógica
o Mensagens de entrada são convertidas de uma cadeia de bits para uma árvore
estruturada através da operação de parser; o input node é responsável por esta tarefa
o A árvore da mensagem é passada de nó em nó
o Mensagem de saída é criada a partir da estrutura de árvore através de outra operação de
parser, por um ou mais nós de saída do flow
 Uma estrutura lógica de árvore contém a mensagem original acrescida de
outras informações acerca do ambiente de execução, propriedades do
transporte da mensagem e outras informações de controle

Página 25
Fundamentos de Desenvolvimento

Ambiente de execução do IBM Integration Bus

Integration node

Integration server 1
Integration server 2

Aplicação Aplicação
Cliente Cliente
Múltiplas instâncias concorrentes
Message Flow 2
Message Flow 2 (1)

Mensagens WebSphere MQ
Mensagens WebSphere MQ

Threads (TCBs)

Página 26
Fundamentos de Desenvolvimento

Ferramentas de administração do IBM Integration Bus

Página 27
Fundamentos de Desenvolvimento

Utilitários de linha de comando


 Comando do ambiente de execução do IBM Integration Bus e IBM
Integration Toolkit
 Comandos no console necessitam de autorização do grupo
mqbrkrs
 Suportado no Linux, UNIX, Windows e z/OS
o No Windows, componentes são serviços que podem ser iniciados
automaticamente

Página 28
Fundamentos de Desenvolvimento

Comandos básicos do IBM Integration Bus


 mqsilist
o Lista os componentes do IBM Integration Bus no sistema
 mqsistart
o Inicia os componentes
 mqsistop
o Para os componentes. Use a flag opcional –i para forçar uma parada
imediata quando o componente for um integration node

 Nota: Sempre checar o log do sistema após um start ou stop

Página 29
Fundamentos de Desenvolvimento

IBM Integration Toolkit


 Ambiente de desenvolvimento baseado no eclipse para projeto,
implantação e testes de message flows
o Uma perspectiva é uma coleção de visões, ícones de barra de
ferramentas e menus que são agrupados para realizar um tipo
específico de trabalho
o Uma view suporta editores e apresenta informações
o Editores são usados para criar e modificar message flows, modelos
de mensagem e mapas
 Necessita de um workspace
o Localização no file system onde estão os recursos usados para
desenvolver aplicações
o É preciso informar um workspace sempre que iniciar o IBM Integration
Toolkit
o Somente um usuário por vez pode usar um mesmo workspace
 Pode ser usado com sistemas de controle de versão de código-
fonte
Página 30
Fundamentos de Desenvolvimento

Desenvolvimento em equipe
 Cada desenvolvedor trabalha em seu próprio IBM Integration
Toolkit
o Periodicamente libera releases de mudanças para o controle de
versão da equipe
o Pode atualizar o workspace com o código atualizado a qualquer hora
 Repositório da equipe
o Qualquer repositório que o Eclipse suporta pode ser usado
o Repositórios suportados diretamente: CVS e Rational ClearCase LT
o As opções dos repositórios incluem controle de mudanças, histórico,
lock de arquivos e segurança.

Página 31
Fundamentos de Desenvolvimento

Tela de Boas Vindas IBM Integration Toolkit

Página 32
Fundamentos de Desenvolvimento

Perspectiva Integration Development

Página 33
Fundamentos de Desenvolvimento

Visão Integration Nodes


 Alojada na visão Integration Nodes
 Permite ao desenvolvedor de aplicação:
o Criar e remover integration nodes
o Conectar com integration nodes remotos
o Criar e remover integration servers
o Implantar message flows em um integration server
o Configurar a porta de debug e executar a depuração para um
integration server
o Remover artefatos implantados em um integration server
o Iniciar e Parar integration nodes, integration servers e message flows

Página 34
Fundamentos de Desenvolvimento

Projetos, Aplicações e Bibliotecas (1 de 2)


 Integration Project
o Um contêiner especializado no qual você cria e mantem todos os
recursos que estão associados com um ou mais message flows
o Contém um único message flow e seus recursos ou grupos de
message flows e recursos em um único projeto para organizar os
recursos de seu message flow
o Mostrado na pasta Independent Resources na visão Application
Development
o Adiciona recursos a um Integration Project e implanta recursos que
estão contidos no projeto

Página 35
Fundamentos de Desenvolvimento

Projetos, Aplicações e Bibliotecas (2 de 2)


 Aplicações e Bibliotecas
o Contêiners implantáveis de recursos
o Podem incluir message flows, message definition (arquivos XSD e
DFDL), arquivos JAR, XSLT e arquivo de adaptadores Websphere
 Application é um contêiner para todos os recursos que são
necessários para criar uma solução completa
 Library é um agrupamento lógico de recursos reutilizáveis
relacionados (modelos de mensagem, mapas e subflows)
 São listados sob o nome application ou library na visão Application
Development

Página 36
Fundamentos de Desenvolvimento

Tipos de Library

Página 37
Fundamentos de Desenvolvimento

Library
Shared Library : as bibliotecas compartilhadas permitem que
as mesmas sejam referenciadas por uma ou mais aplicações,
não tendo a necessidade de cada aplicação ter uma “cópia”.
 Static Library: as bibiliotecas estáticas quando referenciadas
por uma aplicação tem o seu escopo definido por aplicação

Página 38
Fundamentos de Desenvolvimento

REST API
 Utilize APIs REST para expor integrações como um serviço
da web RESTful que pode ser chamado por clientes HTTP.
 Uma API REST contém um conjunto de recursos e um
conjunto de operações que podem ser chamadas para esses
recursos. As operações em uma API REST podem ser
chamadas a partir de qualquer cliente HTTP, incluindo o
código JavaScript do lado do cliente que está em execução
em um navegador da web
 Para criar um projeto REST API:
1. File-> New REST API
2. New…-> Start by creating REST API

Página 39
Fundamentos de Desenvolvimento

REST API
1) Defina o nome da REST API

2) Selecione o arquivo json de definição REST API padrão SWAGGER

Página 40
Fundamentos de Desenvolvimento

REST API
3) Revise os recursos e operações definidas na definição da API REST

2) Após a criação é exibido as operações da seguinte maneira:

Página 41
Fundamentos de Desenvolvimento

SWAGGER

Documento Swagger são as definições dos recursos e operações


que estão disponíveis dentro de uma API REST, uma especificação
aberta para definição de APIs REST
o Equivalente de um documento WSDL para um serviço da web baseado
em SOAP
o Especifica a lista de recursos que estão disponíveis na API REST e as
operações que podem ser chamadas nesses recursos.
o Especifica a lista de parâmetros para uma operação, incluindo o nome
e o tipo dos parâmetros, se os parâmetros são necessários ou
opcionais e informações sobre valores aceitáveis para esses
parâmetros.
o Inclui o esquema JSON que descreve a estrutura do corpo da
solicitação que é enviado para uma operação em uma API REST e o
esquema .json descreve a estrutura de quaisquer corpos de resposta
que são retornados a partir de uma operação.

Página 42
Fundamentos de Desenvolvimento

SWAGGER
Para obter maiores informações sobre o Swagger consulte os
links abaixo:
Swagger RESTful API Documentation Specification
https://github.com/swagger-api/swagger-
spec/blob/master/versions/2.0.md

Swagger Editor
http://swagger.io/swagger-editor/
Swagger UI
http://swagger.io/swagger-ui/

Página 43
Fundamentos de Desenvolvimento

Namespaces (broker schema)


 Subdiretório de um integration project
 Previne conflito de nomes no workspace ou no integration node
 Pode adicionar mais estrutura usando o ponto (.) no broker
schema
 Quando move-se ou copia-se flows em outro schema:
o Os arquivos associados (*.esql *.map) não são automaticamente
movidos ou copiados
o Referências devem ser ajustadas manualmente
 Broker schema é propagado para o integration node com a
implantação

Página 44
Fundamentos de Desenvolvimento

Exportando para criar um arquivo Project


Interchange
 Crie um arquivo Project Interchange para
exportar recursos do workspace
 File > Export copia recursos do
workspace para:
o O file system
o Um arquivo comprimido
o Qualquer outro contêiner de
arquivos que o Eclipse suporta
 Operação do Eclipse
o Nenhuma transformação
o Nenhum envolvimento do IBM
Integration Bus

Página 45
Fundamentos de Desenvolvimento

Importando um arquivo Project Interchange


 Operação do Eclipse
o Nenhuma transformação
o Nenhum envolvimento do IBM
Integration Bus
 Arquivos são copiados para o workspace
de:
o file system
o um arquivo comprimido
o qualquer outro contêiner que o Eclipse
suporte
 File > Import copia recursos para um
workspace existente

Página 46
Fundamentos de Desenvolvimento

Nós do Message flow


 Nós do message flow realizam uma ação no message flow
o Transforma ou enriquece uma mensagem de entrada
o Fornece controle de roteamento para a movimentação de mensagens através do message
flow (baseado no conteúdo ou outros fatores)
o Fornece outras funções especializadas como recuperação e envio de mensagens, acesso
a banco de dados e agregração de múltiplas mensagens

 A maioria dos nós de message flow operam sobre uma mensagem


de entrada e então passam a mensagem para a saída direcionada
para um outro nó do message flow.
 Mensagens entram e deixam um nó através de pontos de entrada
e saída chamados terminais Terminal
de Entrada

Terminais
de Saída

Nós do message flow

Página 47
Fundamentos de Desenvolvimento

Propriedade dos nós de message flow


 Controla como um nó de message flow opera
o Mandatório: você deve configurar estas propriedades durante o
desenvolvimento
o Opcional: você pode configurar estas propriedades durante o
desenvolvimento, caso contrário, valores padrão são utilizados
o Configurável: permite que você sobrescreva os valores quando for
implantar os messages flow para execução
o Promovido: eleva a propriedade para o nível do message flow ao invés
do nível do nó individual; o valor da propriedade poderá então ser
alterado em nível de message flow

Página 48
Fundamentos de Desenvolvimento

Nós de transporte de mensagem


 WebSpher MQ
o MQInput, MQOutput, MQReply, MQGet,
 Web Services
o SOAPInput, SOAPReply, SOAPRequest, SOAPAsyncRequest,
SOAPAsyncResponse, SOAPEnvelope, SOAPExtract,
RegistryLookup, EndpointLookup
 HTTP
o HTTPAsyncRequest, HTTPAsyncResponse, HTTPInput, HTTPReply,
HTTPRequest, HTTPHeader
 JMS
o JMSInput, JMSOutput, JMSReceive, JMSReply, JMSHeader,
JMSMQTransform, MQJMSTransform
 Windows .NET
o .NETInput

Página 49
Fundamentos de Desenvolvimento

Nós relacionados ao transporte de mensagem


 File
o FileInput, FileOutput, FTEInput, FTEOutput, FileRead, CDInput,
CDOutput
 TCP/IP
o TCPIPClientInput, TCPIPClientOutput, TCPIPClientReceive,
TCPIPServerInput, TCPIPServerOutput, TCPIPServerReceive
 SCA
o SCAInput, SCAReply, SCAAsyncRequest, SCAAsyncResponse,
SCARequest
 WebSphere Adapters
o SAPInput, SAPReply, SAPRequest, SiebelInput, SiebelRequest, etc..
 Outros sistemas externos
o IMSRequest, CICSRequest, CORBARequest

Página 50
Fundamentos de Desenvolvimento

Outros nós de processamento de mensagem (1 de 2)


 Roteamento
o Filter, Router, Label, RouteToLabel, AggregateControl,
AggregateReply, AggregateRequest, Collector, Resequence,
Sequence
 Transformação
o Compute, JavaCompute, PHPCompute, XSLTransform, Mapping,
.NET Compute
 Banco de Dados
o Database, DatabaseInput, DatabaseRetrieve, DatabaseRoute
 Construção
o Input, Output, Throw, Trace, TryCatch, FlowOrder, Passthrough,
ResetContentDescriptor

Página 51
Fundamentos de Desenvolvimento

Outros nós de processamento de mensagem (2 de 2)


 Email
o EmailInput, EmailOutput
 Validation
o Validate
 Security
o SecurityPEP
 Timer
o TimeoutControl, TimeoutNotification

Página 52
Fundamentos de Desenvolvimento

MQInput
 Varre uma fila MQ por mensagens que atendem aos critérios de
busca;
 Possui valores padrão para seleção de parser e tópicos
publish/subscribe;
 Estabelece o modo de transação para o message flow inteiro;
 Inicia um nova thread;
 Múltiplos nós MQInput em um message flow identifica fontes
alternativas de entrada;
 Uma mensagem é recebida por cada thread;
 3 terminais de saída: Failure, Out e Catch;
Página 53
Fundamentos de Desenvolvimento

MQOutput
 Põe uma mensagem para uma fila local ou remota sob uma
transação de uma message flow ou um explícito commit;
 Modo Destination:
o Queue name;
o Reply-to Queue ou nó MQReply põe a mensagem em
MQMD.ReplyToQueue;
o DestinationList para roteamento dinâmico; os nomes das filas são
definidos usando ESQL em outros nós;
 Não é necessariamente o ponto final de um message flow:
o Terminal out;
o Força uma sequencia de mensagens escritas;

Página 54
Fundamentos de Desenvolvimento

Nó Compute
 Qualquer manipulação da estrutura da mensagem:
o Cálculos
o Dados de uma base de dados externa
o Nova ordem de campos
 Nessita da escrita de código:
o Compute: ESQL
o JavaCompute: Java
o PHPCompute: PHP
o .NET Compute: C#, VisualBasic, F#, C++/CLI for .NET e aplicações
COM (disponível apenas para Windows)

Página 55
Fundamentos de Desenvolvimento

Testando message flows usando o Flow Exerciser


Iniciado a partir do editor do message flow nos nós WebSphere
MQ, SOAP, HTTP, JSM Input e SCA;
Contrói automaticamente arquivos (BAR);
Implanta automaticamente no integration server selecionado;
Auxilia na criação de dados de testes e os salva para subsequente
testes;
Envia uma mensagem de teste;
Os caminhos percorridos pela mensagem no fluxo são realçados;
Disponibilizado a visualização da estrutura e o conteúdo da árvore
de mensagem lógica em qualquer conexão em destaque no fluxo
de mensagens;
Não é possível utilizar o debugger com o flow exerciser;

Página 56
Fundamentos de Desenvolvimento

Flow Exerciser
Iniciando o flow exerciser para gravar, o caminho percorrida pela mensagem
no fluxo

Página 57
Fundamentos de Desenvolvimento

Flow Exerciser
Enviando a mensagem a ser processada no fluxo

Página 58
Fundamentos de Desenvolvimento

Flow Exerciser
Visualizando o caminho e a mensagem processada pelo fluxo

Página 59
Módulos

Desenvolvimento de Message Flows

Página 60
Message Flows

Métodos de Criação de um “Message Flow”

Página 61
Message Flows

Nós de Processamento de Arquivos


 Nó “FileInput” lê a partir do file system ou de um servidor FTP:

 Nó “FileOutput” escreve arquivos no file system ou em um servidor


FTP:

 Nome de arquivo pode conter caracteres coringa;


 O foco é mais no processamento da mensagem que na entrega
da mesma;

Página 62
Message Flows

Adicionando Nós

1 – Arraste os nós para o Editor de “Message Flow”.

2 – Digite as propriedades para cada nó.


na “Properties view”.

Página 63
Message Flows

Conectando Nós
 Mova o cursor sobre os terminais para identificar o nome do
mesmo:

 Mova o cursor sobre a conexão para identificar a origem e destino


da conexão;
 Para criar uma conexão, clique com o botão direto sobre o nó e
selecione “Create Connection”, ou clique sobre o terminal de
origem e então clique sobre o terminal de destino;
 Linhas direcionais indicam a direção que a mensagem trafega;

Página 64
Message Flows

Empacotando e Implantando (1 de 2)
 Depois que o “Message Flow” foi desenvolvido, ele e todos os
seus componentes relacionados devem ser movidos (implantados)
para um “Integration Server” de forma que possa ser executado;
 Crie um arquivo “Broker Archive“ (BAR) para armazenar os
componentes implantáveis usando:
o “IBM Integration Toolkit”;
o O comando “mqsicreatebar” no Windows e Linux;
o O comando “mqsipackagebar” para criar arquivos BAR sem o “IBM
Integration Toolkit”.
 Se estiver usando “mqsipackagebar”, você deve usar o comando
“mqsicreatebar” primeiro para compilar qualquer “Message Set” e
código Java.

Página 65
Message Flows

Empacotando e Implantando (1 de 2)
 Adicione um “Message Flow” como “.msgflow” ou um “Message
Flow” compilado (“.cmf”):
o Selecione “Compile and in-line Resources” para adicionar “Flows”
como “.cmf”.
 Configure filas e DSNs para um ambiente de “Integration Node”
(“deployment descriptor””);
 Mova o arquivo BAR para o “Integration Server” usando:
o “IBM Integration Toolkit”;
o A linha de comando “mqsideploy”;
o “Integration API”.
 Monitore o “Deployment Log” para ver o status atual;
 Use comandos para implantação por scripts.

Página 66
Message Flows

Conteúdo de um Arquivo BAR

Página 67
Message Flows

Criando um arquivo BAR no “IBM Integration Toolkit”


 A partir do “IBM Integration Toolkit”:
o Selecione “File > New > BAR File”;
o Especifique o nome do BAR;
o Adicione componentes ao arquivo BAR usando o editor, ou arraste
componentes a partir da “Application Development view”.
 Por padrão, o arquivo BAR é criado no projeto “BarFiles”:
o Para alterar este comportamento no “IBM Integration Toolkit”,
selecione “Windows > Preferences”, expanda “Integration
Development” e selecione “Build Broker Archive”.

Página 68
Message Flows

Empacotamento e Validação do “Message Flow”


 A validação de “Message Flow” gera erros e avisos na “Problems
view”;
 Não é possível implantar uma aplicação, biblioteca ou projeto que
contém erros, mas é possível se houver apenas avisos;
 Encontre recursos associados em projetos referenciados como
“Subflows”, ESQL e mapas;
 Calcula valores para propriedade promovidas; promovidas de nó
para “Subflow” e para “Flow” principal.

Página 69
Message Flows

Detalhes de Implantação
Quando a operação de implantação é requisitada:
 O “Integration Node” finaliza o processamento das mensagens de
aplicações e para todos os “Message Flows”;
 O BAR é implantado e as alterações requisitadas são feitas no
“Integration Server” e no ambiente do “Integration Node”;
 “Message Flows” são reiniciados;
 As “views” “Deployment Log” e “Integration Node” são atualizadas:
o Sempre checar o “Deployment Log” para confirmar se não houve
erro na implantação e o motivo;
o Se necessário, ajuste o “Timeout” para o “Integration Node”.

Página 70
Message Flows

“Deployment Log”
 Apresenta o resultado da implantação em um “Integration Node”:
o Nome do “Integration Node” de onde a mensagem de implantação foi
originada;
o Detalhe da mensagem de Implantação;
 “Clear Deployment Log” limpa todas as entradas de log da “view”
“Deployment Log”, mas não apaga as entradas no log
administrativo;
 Mensagens são automaticamente limpas depois de 72 horas;

Página 71
Módulos

Compute Nodes

Página 72
Compute Nodes

Objetivos
 Descrever as Mensagens Lógicas, a Construção de Mensagens e
explicar como elas são usadas para o desenvolvimento de
aplicações no “IBM Integration Bus”;
 Usar o Nó “Compute” e “ESQL” para transformar mensagens;
 Usar o Nó “JavaCompute” e “Java” para transformar mensagens.

Página 73
Compute Nodes
Montagem da mensagem no “IBM Integration Bus”

Página 74
Compute Nodes

Modelo de Mensagem Lógica


 Um modo consistente e conveniente de representar o conteúdo de
mensagens dentro do “IBM Integration Bus”;
 Remove e isola os detalhes físicos da mensagem;
 Organizado como uma Árvore de Mensagem;
 Valores de elementos são armazenados em “Unicode” para
facilitar as conversões de código;
 Elementos na árvore são localizados usando “Xpath” ou a notação
com nomes e pontos.

Página 75
Compute Nodes
Exemplos de Representação de Dados

Página 76
Compute Nodes
Exemplo de Modelo de Mensagem Lógica

Página 77
Compute Nodes
Visão Geral do Parse de uma Mensagem

Página 78
Compute Nodes

Domínios de Mensagem Auto-definidos


 “XMLNSC”:
o Para mensagens que estão conforme o padrão “W3C XML”;
o Opcionalmente podem usar um modelo (“XML Schema”) para validar
documentos XML.
 “JMSMAP” e “JMSSTREAM”:
o Para mensagens produzidas pela implementação “WebSphere MQ” do
padrão “JMS”;
o Usa um “Parser XML”.

Página 79
Compute Nodes

Domínios de Mensagem Pré-definidos


 “DFDL”:
o Para texto em geral e formatos de mensagens binárias, incluindo
padrões de indústria;
o Pode validar mensagem em tempo de execução contra o modelo de
mensagem que foi definido no Arquivo de “Schema DFDL”.
 “MRM”:
o Para modelar uma gama ampla de mensagens como “XML”, Binário de
formato fixo e texto formatado;
o Opcionalmente pode validar mensagens de entrada e saída contra um
dicionário implantado em tempo de execução.
 “SOAP”:
o Para “SOAP” com padrões “WS-*”;
o Inclue “MTOM” e “SwA (MIME)”.

Página 80
Compute Nodes

Outros Domínios de Mensagem


 “BLOB”:
o Todas as mensagens cujo conteúdo não pode ser interpretado ou
subdivido em seções menores de informação;
o Tratado como um única cadeia de bytes.
 “MIME”:
o Para mensagens “Multipart MIME”;
o Os cabeçalhos “MIME“ são parseados e o conteúdo “MIME” é
armazenado como “BLOB” sob um elemento data.

Página 81
Compute Nodes

Outros domínios de mensagem


 “JSON”:
o Interpreta uma Cadeia de Bits com a gramática “JSON” e gera a
representação correspondente Árvore de mensagem lógica no Domínio
“JSON”.
 “Custom”:
o Domínios criados pelo usuários ou de plugins de terceiros.

Página 82
Compute Nodes

Opções de Transformação no “IBM Integration Bus”


 ESQL (Nó “Compute”);
 Java (Nó “JavaCompute”);
 “XSLT” (Nó “XSLTransform”);
 “Mapping” (Nó “Mapping”);
 “PHP” (Nó “PHPCompute”);
 C#, F#, “Visual Basic”, C++/CLI
(Nó “.NETCompute”);
 “WebSphere Transformation Extender”;

Página 83
Compute Nodes

Opções de Transformação no “IBM Integration Bus”


 “Database Stored Procedures”;
 “WebSphere Adapters”;
 Uma combinação das Opções Anteriores;
 Dados, Modelo e Parser afetam na escolha da
tecnologia de transformação:
o ESQL e Java fornecem a maior cobertura dos
Modelos de Mensagem;
o Outras tecnologias trabalham em alguns, mas
não em todos os Modelos.

Página 84
Compute Nodes

Acessando a Árvore da Mensagem com Nomes de Correção


ESQL
 Ponteiro para a Árvore da Mensagem:
o “Root”, “InputRoot”, “OutputRoot”;
o “Body (=Root.*[<])”, “InputBody (=InputRoot.*[<])”;
o “LocalEnvironment”, “Environment”, “ExceptionList”;
o “Database”;
o Outros métodos.
 Usados em Código ESQL, “Patterns” em Nó de “Trace”,
Parâmetros de Localização de Dados em um Nó “MQGet” e
outros:
o Exemplo: “Root.XMLNSC.Complaint.Text”.

Página 85
Compute Nodes

Acessando a Árvore da Mensagem com “Xpath”


 “Xpath 1.0” é usado para referencia e Manipulação de Elementos
em uma Árvore de Mensagem como em Nós “JavaCompute”,
“XSLTransform”, “Mapping” e “Route”;
 Selecione um Elemento a partir de uma Árvore XML usando uma
expressão:
o Não há necessidade de navegação explícita: “/documento/name”.
 Pode selecionar múltiplos elementos;
 Expressões “Xpath” suportam a seleção de predicado para
Critérios de Busca:
o Exemplo: “book[author=‘Luiz Yanai’]”.
 Funções “Xpath” para Cálculos de Expressões Triviais:
o Exemplo: “count(/sum/library/books/book)”.

Página 86
Compute Nodes

Combinando o Melhor dos Dois Mundos: ESQL e Java


 “MbSQLStatement” executa ESQL com um Nó “JavaCompute”:
o Melhor para acesso a “Banco de Dados” via “ODBC”.
 Invocar Métodos “Java” Estáticos de um módulo ESQL:
o Desenvolver Código “Java” na “Perspectiva Java” do “IBM Integration
Toolkit”:
public class IB90 {
public static void sleep(Long millis){
try{ Thread.sleep(millis.longValue());
} catch(InterruptedException e) {}}
}

Página 87
Compute Nodes

Combinando o Melhor dos Dois Mundos: ESQL e Java


 Invocar Métodos “Java” Estáticos de um Módulo ESQL:
o Encapsular o Método “Java” como uma “Procedure ESQL”:
CREATE PROCEDURE PauseFlow (In millisecs INT)
LANGUAGE JAVA
EXTERNAL NAME “mypackage.IB90.sleep”;

o Usá-la como qualquer outra “Procedure” em ESQL:


CALL PauseFlow(10000)

Página 88
Compute Nodes

Variáveis
 Tipos de Dados Escalar e Fixos;
 Estrutura de Árvore (“ROW” e “REFERENCE”):
>-DECLARE-+----Name-----+--+----------+-DataType-+--+---------------+-->>
+--<<--,--<<--+ +-CONSTANT-+ |+-InitialValueExpr-+
+--NAMESPACE----------+
+--NAME---------------+

 DECLARE var I INTEGER 1;


 DECLARE addr NAMESPACE ‘http://www.ibm.com/address’;
 DECLARE course CONSTANT CHAR ‘BLA123’.

Página 89
Compute Nodes

Escopo de Variáveis, Tempo de Vida e Compartilhamento


 Escopo: onde a variável é usada:
o Exemplos: “Nó”, “Flow”, “Integration Server” e “Integration Node”.
 Tempo de vida: Duração da Variável:
o Exemplos: Bloco de Código, Módulo e “Thread”.
 Compartilhamento: Visibilidade da “Thread”:
o Quando o “Flow” ou “Integration Server” pára, o Tempo de Vida de
variável compartilhada acaba;
o Blocos “ATOMIC” podem serializar o acesso a variáveis “SHARED”.

Página 90
Compute Nodes

Nó Compute
 Dados são copiados da entrada para a Área de Saída:
o Mensagem Completa ou apenas os Cabeçalhos da Mensagem;
o Outras partes da Mensagem.
 Criar uma Mensagem ou Mensagens pela codificação no Arquivo
ESQL do “Message Flow”;
 Qualquer manipulação da estrutura de Mensagem de Saída
como Cálculos, Recuperação de Dados de um Banco de Dados
externo e Reorganização de Campos;

Página 91
Compute Nodes

Nó Compute
 A expressão “PROPAGATE” pode ser usada para:
o Gerar múltiplas Mensagens de Saída;
o Rotear Mensagens para diferentes Terminais de Saída “Out1”,
“Out2”, etc...

Página 92
Compute Nodes

ESQL
 Estende as Construções da Linguagem SQL para definir o
comportamento de Nós em um “Message Flow”:
o Testa, Calcula e Manipula Campos em uma Mensagem Lógica;
o Referencia Campos do Cabeçalho da Mensagem;
o Alterar Propriedades de Campos.
 Baseado no Padrão “SQL3”;
 Exemplos:
RETURN Body.Msg.Name = 'IBM';
SET OutputRoot.XMLNSC.Msg.Name = 'IBM';
SET OutputRoot.XMLNSC.Msg.Name=InputBody."First.Name";

Página 93
Compute Nodes

Editor ESQL
 Validação da Sintaxe de Expressões:
o Falta de pontuação, uso incorreto de funções e palavras-chave;
o Projeto pode ser implantado com avisos, mas não com erros.
 Validação Semântica;
o Identificadores não resolvidos;
o Referências a mensagens ou banco de dados incorretas;
o Palavras-chave descontinuadas.
 Pode configurar Preferências de Validação;
 Assistência de preenchimento:
o Para usar, pressionar “Ctrl + Espaço” ou selecionar “File > Edit”;
o Clicar com o botão direito para acessar mais opções do Editor.

Página 94
Compute Nodes

Opções do “Editor ESQL”


 “Undo”: para desfazer mudanças feitas no Arquivo ESQL;
 “Revert File”: para desfazer todas as mudanças desde a última
vez que o arquivo foi salvo;
 “Comment”: para converter uma Linha de Código ESQL em
comentário;
 “Uncomment”: o inverso do “comment”;
 “Format to”: formata todas as Linhas de Código selecionadas;
 “Organize Schema Paths”: adiciona um “Broker Schema” que
contém “Procedures” e funções que o Arquivo ESQL invoca;
 “Add Schema Path”: adicionar um “Schema” para a expressão
“PATH” quando o código inclui uma chamada para uma
“Procedure” ou função que está em um “Schema” diferente.

Página 95
Compute Nodes

ESQL e Nó “Compute”
 Um Nó “Compute” é associado com apenas um Módulo ESQL;
 Cada Módulo contém uma Função que é chamada “Main()“ que é
o Ponto Entrada no qual o processamento do Nó inicia;
 A expressão “RETURN” controla a propagação da mensagem
para os Terminais de Saída:
o “RETURN” ou “RETURN TRUE”; Propagam para o terminal “OUT”
o “RETURN FALSE” ou “UNKNOWN”; A mensagem não é propagada

Página 96
Compute Nodes

Esqueleto de um Nó “Compute”
CREATE COMPUTE MODULE <flow_name>_Compute
CREATE FUNCTION Main() RETURNS BOOLEAN
BEGIN
-- CALL CopyMessageHeaders();
-- CALL CopyEntireMessage();
RETURN TRUE;
END;
CREATE PROCEDURE CopyMessageHeaders() BEGIN
DECLARE I INTEGER 1;
DECLARE J INTEGER CARDINALITY(InputRoot.*[]);
WHILE I < J DO
SET OutputRoot.*[I] = InputRoot.*[I];
SET I = I + 1;
END WHILE;
END;
CREATE PROCEDURE CopyEntireMessage() BEGIN
SET OutputRoot = InputRoot;
END;
END MODULE;
Página 97
Compute Nodes

Depuração de ESQL
 A partir do “Debugger”, vá para o Código Fonte:
o Inclua “Breakpoints” no ESQL;
o Mostra a Mensagem de Montagem.

Página 98
Compute Nodes

Um Pouco da Sintaxe do ESQL


 Palavras-chave do ESQL não são “case-sensitive”:
o SET, seT, SeT …
 “CorrelationNames” e Nomes de Campos são “case-sensitive”:
o OutputRoot, InputBody.Msg.field …
 Literais e Cadeias de Caracteres Constantes são envolvidos por
Apóstrofe;
 Referências de Campos são envolvidas por aspas se:
o Existem caracteres especiais no Nome, como branco;
o O Nome é uma palavra reservada do ESQL.

Página 99
Compute Nodes

Um Pouco da Sintaxe do ESQL


 O Delimitador de Expressões é o ponto e vírgula (;)
 Comentários:
o Uma linha: -- (dois traços)
o Bloco: /* …. Comentário …. */

Página 100
Compute Nodes

Inserindo, Atualizando e Removendo Campos


 “SET” Modifica um Campo ou uma Estrutura se ela existir;
 “SET” Adiciona um Campo ou uma Estrutura se ela não existir;
 “SET .. = NULL” remove um Campo ou uma Estrutura;
 A Ordem das Expressões ESQL determinam a Ordem dos
Campos;
 Exemplo:
CALL CopyMessageHeaders();
SET OutputRoot.XMLNSC.Msg.A.B.C = 1;
SET OutputRoot.XMLNSC.Msg.E = 2; SET OutputRoot.XMLNSC.Msg.D
= 3;
SET OutputRoot.XMLNSC.Msg.E.B.C = 4; SET
OutputRoot.XMLNSC.Msg.A.B.C = 5;
SET OutputRoot.XMLNSC.Msg.E.B = NULL;

Página 101
Compute Nodes

Tipos de Dados ESQL Especiais para Estruturas em Árvore


 “ROW”: uma Árvore nomeado com Tipos de Dados Dinâmicos
para Nós de Folha:
o Copia um subgrupo de outro “ROW”;
o Seleciona os Resultados;
o Construído através da função “ROW()”:
DECLARE rowCust ROW InputRoot.XMLNSC.OrderMsg.Customer;
SET rowCust.Address = ROW('Hursley' AS Town, 'UK' AS Country);

Página 102
Compute Nodes

Tipos de Dados ESQL Especiais para Estruturas em Árvore


 “REFERENCE”: Cursor de Árvore
o Aviso: Cursor para um Campo não existente aponta o ponteiro para o
“Root”, logo deve-se checar a declaração com “FIELDNAME” ou
“LASTMOVE”:
DECLARE refCust REFERENCE TO InputBody.OrderMsg.Customer;
IF LASTMOVE(refCust) THEN
IF FIELDNAME(refCust) <> 'Customer' THEN... .

Página 103
Compute Nodes

Movendo Variáveis de Referência


 Mover o Cursor:
o “PARENT”;
o “PREVIOUSSIBLING”, “NEXTSIBLING”;
o “FIRSTCHILD”, “LASTCHILD”:
DECLARE myRef REFERENCE TO InputBody.OrderMsg;
MOVE myRef FIRSTCHILD;
MOVE myRef NEXTSIBLING NAME 'OrderItem';
MOVE myRef LASTCHILD TYPE XMLNSC.Attribute;
MOVE myRef PREVIOUSSIBLING REPEAT TYPE;
o Checar o sucesso de “MOVE” ou “DECLARE ... REFERENCE”:
WHILE LASTMOVE(myRef) DO...

Página 104
Compute Nodes

Removendo e Reorganizando Campos


 Remover um Campo ou uma Estrutura:
o Remove e libera Memória; útil para Mensagens Grandes
DELETE FIELD OutputRoot.XMLNSC.OrderMsg.Customer;
DECLARE myRef REFERENCE TO
OutputRoot.XMLNSC.OrderMsg.OrderItem[1];
DELETE NEXTSIBLING OF myRef;
o Atribuir “NULL”:
SET OutputRoot.XMLNSC.OrderMsg.OrderItem[2]=NULL;
o “Detach” (Copiar e Colar):
DETACH myRef;

 “Reordenar”: Copia uma estrutura recortada em uma nova


posição da Árvore de Mensagem
ATTACH myRef TO OutputRoot.XMLNSC.OrderMsg
AS FIRSTCHILD;

Página 105
Compute Nodes

“CREATE”
 Cria Novos Campos (“tags”) ou Atributos:
o Em qualquer ponto na mensagem;
o Um Campo Escalar:
SET OutputRoot=InputRoot;
CREATE FIELD OutputRoot.XMLNSC.OrderMsg.Customer.AnAttr
TYPE XMLNSC.Attribute VALUE 'C';
DECLARE myRef REFERENCE TO OutputRoot.XMLNSC;
CREATE PREVIOUSSIBLING OF myREF DOMAIN 'MQRFH2';
o Ou uma Estrutura (por duplicação):
DECLARE myRef REFERENCE TO OutputRoot.XMLNSC.OrderMsg;
CREATE FIRSTCHILD OF myRef
FROM InputBody.OrderMsg.OrderItem[3];

Página 106
Compute Nodes

Valor “NULL”
 “Null” é um Estado Distinto:
o Não é 0 ou ‘’
o “SQL_NULL_DATA”;
o Todos os Tipos de Dados (exceto “REFERENCE”).
 Se o Valor é:
o Desconhecido;
o Indefinido;
o Não inicializado.

Página 107
Compute Nodes

Valor “NULL”
 Regra Geral: Se qualquer operando for “NULL”, então o valor
é “NULL”;
 Usar “NULL” para Remover um Campo ou Estrutura;
 Exemplo:
SET OutputRoot.XMLNSC.Msg.Field=NULL;
SET OutputRoot.XMLNSC.Msg.F2= InputBody.Msg.Unknown;

Página 108
Compute Nodes

“Procedure”
 Subrotinas com Parâmetros “IN”, “OUT” e “INOUT” e um Valor de
Retorno opcional:
o Pode ser usado recursivamente;
o Linguagem pode ser ESQL, “Java” ou “Banco de Dados” (“Stored
Procedure”):
CREATE PROCEDURE navigate (IN root REFERENCE, INOUT answer CHARACTER)
LANGUAGE ESQL
BEGIN
SET answer = answer||'Reached Field...Name:'||FIELDNAME(root);
DECLARE cursor REFERENCE TO root;
MOVE cursor FIRSTCHILD;
IF LASTMOVE(cursor) THEN
SET answer = answer || 'Field has children... drilling down ';
ELSE
SET answer = answer || 'Listing siblings... ';
END IF;
WHILE LASTMOVE(cursor) DO
CALL navigate(cursor, answer);
MOVE cursor NEXTSIBLING;
END WHILE;
SET answer = answer || 'Finished siblings... Popping up ';
END;

Página 109
Compute Nodes

Nó “JavaCompute” (1 de 3)
 É um Nó Programável de Propósito Geral;
 A Classe do Nó deve estender “MbJavaComputeNode”;
o Cada “Node” é uma Instância desta Classe.
 Deve implementar o método “Evaluate()” que o “Integration Node”
invoca ao processar cada mensagem;
 A Mensagem de Entrada é passada para o método “Evaluate”:
o “MbMessageAssembly” encapsula quatro objetos “MbMessage”.
 “MbElement” representa uma parte lógica da mensagem parseada.

Página 110
Compute Nodes

Nó “JavaCompute” (2 de 3)
 Estão contidas dentro de “MbMessageAssembly” quatro Árvores
Padrão:
o “Message” (somente leitura);
o “LocalEnvironment” (somente leitura);
o “GlobalEnvironment” ;
o “ExceptionList” (somente leitura).
 Árvores começam pelo Root:
o “MbElement” é um objeto que representa um elemento

Página 111
Compute Nodes

Nó “JavaCompute” (3 de 3)
 Equivalências com ESQL (“MbMessageAssembly”):
o getMessage().getRootElement() => InputRoot;
o getMessage().getRootElement().getLastChild => InputBody;
o getLocalEnvironment().getRootElement() => InputLocalEnvironment;
o getGlobalEnvironment().getRootElement() => Environment;
o getExceptionList().getRootElement() => InputExceptionList.

Página 112
Compute Nodes

Desenvolvendo com o Nó “JavaCompute”


 Abra o “Wizard Java”:
o Guia o Usuário e Cria um “Template” de Código;
o Pacote e “Classe Java” são identificados;
o Posiciona o usuário na “Perspectiva Java” do Eclipse.
 “Perspectiva Java”: Experiência completa para Desenvolvimento
“Java” no Eclipse:
o “Javadoc” para Auxílio no Conteúdo;
o Compilação Incremental.

Página 113
Compute Nodes

Desenvolvendo com o Nó “JavaCompute”


 Implantação do “Java”:
o Automática quando o Nó “JavaCompute” é adicionado no “Arquivo
BAR”;
o “Arquivos .JAR” Externos podem ser adicionados ao “Class Path” do
Projeto;
o Armazenado no “File System” do “Integration Node”.

Página 114
Compute Nodes
Usando o “Wizard Java” (1 de 3)

Página 115
Compute Nodes
Usando o “Wizard Java” (2 de 3)

Página 116
Compute Nodes
Usando o “Wizard Java” (3 de 3)

Página 117
Compute Nodes

“Templates JavaCompute”
 Apenas um “Template” por nó “JavaCompute”:
o Filtro: Somente Leitura;
o Modificação: Leitura e Escrita; Copia a Mensagem inteira;
o Criação: “outmessage” vazia e Método “CopyMessageHeaders”;
o Processando mensagens usando a “API Java Architecture for XML
Binding (JAXB)” para os objetos “Java”.

Página 118
Compute Nodes

Exemplo de “Template JavaCompute”


import com.ibm.broker.javacompute.MbJavaComputeNode;
import com.ibm.broker.plugin.*;

public class SampleModifyingNode extends MbJavaComputeNode {

public void evaluate(MbMessageAssembly inAssembly) throws MbException {


MbOutputTerminal out = getOutputTerminal("out");
MbOutputTerminal alt = getOutputTerminal("alternate");
MbMessage inMessage = inAssembly.getMessage();
// create new message
MbMessage outMessage = new MbMessage(inMessage);
MbMessageAssembly outAssembly = new MbMessageAssembly(inAssembly,
outMessage);
// ----------------------------------------------------------
// Add user code below
// End of user code
// ----------------------------------------------------------
// The following should only be changed
// if not propagating message to the 'out' terminal
out.propagate(outAssembly);
// clear the outMessage
outMessage.clearMessage(); }}

Página 119
Compute Nodes

Usando “Xpath” no Nó “JavaCompute”


 Usar o Método “MbMessage.evaluateXPath” em um “Element”
apropriado da Árvore;
 Quatro Tipos de Retornos:
o “java.lang.Boolean”, “Double” e “String” para valores “Xpath”
correspondentes;
o “java.util.List” para “nodesets” do “Xpath”:
String title = (String) message
.evaluateXPath("string(document/chapter/@title)");

List chapterList = (List)message.evaluateXPath("//chapter");


Iterator itr = chapterList.iterator();
while (itr.hasNext()) {
MbElement chapter = (MbElement)itr.next();

}

Página 120
Compute Nodes

Atualizando a Árvore
 Requer um Objeto sujeito a Escrita;
 Setar o Nome/Valor/Tipo do Elemento:
setName(), setValue(), setNamespace() e setSpecificType()
 Criar novos Elementos:
createElementAsFirstChild()
createElementAsLastChild()
createElementBefore()
createElementAfter()

Página 121
Compute Nodes

Atualizando a Árvore
 Copiando/Movendo Elementos (“detach()” e “copy()”):
o Adicione elementos recortados:
addAsFirstChild(element)
addAsLastChild(element)
addBefore(element)
addAfter(element)

Página 122
Compute Nodes

Nó “XSL Trasformation” (1 de 2)
 Usa um “XSLT Style Sheet” para Transformar Dados XML (Corpo da
Mensagem);

Página 123
Compute Nodes

Nó “XSL Trasformation” (2 de 2)
 O Nó busca o Nome do “Arquivo XSL” na seguinte ordem:
 Dinamicamente a partir da Mensagem de Entrada
o Exemplo:
<xml-stylesheet type="text/xsl" href="abc.xsl">

 Dinamicamente a partir de
“LocalEnviroment.ComIbmXslStylesheetname”:
 Permite seleção dinâmica do “Style Sheet” de um Nó “Compute”;
 Pode aplicar múltiplos “Style Sheets” para uma Mensagem.
 Estaticamente a partir de uma Propriedade de Nó do “Flow”.

Página 124
Compute Nodes

Nó “.NETCompute”

 Integra qualquer “CLR” (“Common Language Runtime”) em baixo


nível com o “IBM Integration Bus”;
 Permite integração do Código “.NET” diretamente com o “Message
Flow”;
 “Templates” de Código para auxiliar o Desenvolvimento:
o Filtra a Mensagem;
o Modifica a Mensagem – Cria Mensagem.
 Fornece Acesso Completo as Árvores do “IBM Integration Bus”;
 Bem integrado com o “Visual Studio”:
o O “IBM Integration Toolkit” pode iniciar o “Windows Visual Studio”;
o O plugin do “Windows Visual Studio” simplifica o Desenvolvimento.

Página 125
Módulos

Roteamento de Mensagens

Página 126
Roteamento de Mensagens

Objetivos
 Usar os nós “Filter” e “Route” para examinar o conteúdo de
mensagens e alterar o seu “Flow”;
 Usar os nós “RouteToLabel” e “Label” para mudar dinamicamente
o Roteamento de Mensagens;
 Usar os nós “TryCatch” e “Throw” para implementar Tratamento
de Erro do “Message Flow”;
 Criar “Subflows” Reutilizáveis;
 Descrever a estrutura do “ExceptionList” durante a montagem da
mensagem e do papel que ela desempenha no Tratamento de
Erros em Tempo de Execução;
 Descrever Opções de Implementação para “Message Flow”
Sensíveis ao Tempo.

Página 127
Roteamento de Mensagens

Nó “Filter”
 Avalia Expressões ESQL :
o SQL WHERE;

 Roteia a mensagem para Terminal de Saída apropriado:


o “TRUE”;
o “FALSE”;
o “UNKNOWN” (se o Campo de Teste não está presente);
o “FAILURE” (se ocorre erro em Tempo de Execução durante
Processamento Nó);
 Mensagem de Saída é igual a Mensagem de Entrada (não pode
alterar Mensagem);
 Mensagem se perde se o Terminal não estiver conectado ("True",
"False", e "Unknown");
 Pode acessar Base Dados Relacional.
Página 128
Roteamento de Mensagens

Nó “Route”

 Direciona Mensagem por Vários Caminhos, Decididos de Acordo


com Filtro usado;
 Usa Expressões de Filtro "XPath" para Controlar o Processamento;
 Mínimo de três Terminais de Saída; pode adicionar mais:
o Mensagem Roteada para Terminal "Match" quando Filtro avalia como
“TRUE”;
o Mensagem Roteada para Terminal "Default" caso nenhuma das
Expressões do Filtro verdadeiras;
o Mensagem Roteada para Terminal "Failure" quando ocorre erro em
Tempo Execução (se conectados);

Página 129
Roteamento de Mensagens

Nó “Route”
 Pode ser propagada para Múltiplos Terminais, dependendo do
modo de distribuição.

Página 130
Roteamento de Mensagens

Nó “RouteToLabel” e “Label”

 Transfere Controle dentro de Fluxo Mensagens, que se baseia no


conteúdo da Árvore “LocalEnvironment”;
 Nó "RouteToLabel" questiona a "LocalEnvironment.DestinationData"
sobre Mensagem para determinar Identificador do Nó "Label", para o
qual a Mensagem deve ser roteada:
o Use um dos Nós "Compute" para manipular a
"LocalEnvironment.DestinationData".
 Nó "Label" determina Alvo para a Decisão de Roteamento; e não
altera Mensagem que recebe;
 Nó "Label" pode também ser usado com um Nó "SOAPExtract" ou
como Alvo de um Argumento “PROPAGATE – (ESQL)”.

Página 131
Roteamento de Mensagens

Processamento Nó “TryCatch”

 Exceção de Tempo de Execução retorna Controle para Nó Entrada de


um "Message Flow";
 Use Nó "TryCatch" para Controlar Erros localmente;
o O nó “TryCatch” tem Terminal Entrada e dois Terminais Saída e não faz nenhum
Tratamento; atua apenas como um Ponto de Decisão;
o Mensagem é passada para Ramo "Try“ (tentativa) e segue para Conclusão, a menos
que uma Exceção ocorra.

 Se Exceção ocorrer no Ramo "Try":


o O “Integration Node” atualiza a "ExceptionList";
o A informação contida na "ExceptionList" é escrita num Log Local de Erro;
o "Root" and "LocalEnvironment" são reiniciadas para o estado do começo do Nó
"TryCatch";
o Alterações de Base Dados e MQPUTs no Ramo "Try" não são desfeitas;
o Entra no Ramo "Catch"; se não estiver conectado, retorna Controle para o Nó
Entrada.
Página 132
Roteamento de Mensagens

“ExceptionList”
 Contém Informações sobre Exceções que ocorrem quando
Mensagem processada encontra uma Exceção no Caminho Local
"Failure" ou Caminho "Catch" (de captura);
 Pode ser acessada, modificada e rastreada;
 Árvore "ExceptionList" é parte da Árvore de Mensagem Lógica;
 Consiste de um Conjunto Zeros ou mais Descrições de Exceção;
 Último Filho é a causa Original do Erro.

Página 133
Roteamento de Mensagens
Exemplo Nó “TryCatch”

Página 134
Roteamento de Mensagens
“Throwing” Controlado e Log Exceções

 O nó "Throw" é normalmente conectado no Final do Ramo "Catch";


 Função THROW no ESQL;
o Interrompe Processamento no Nó "Compute";
o Lida diretamente com Exceções da Base Dados;
o Base Dados retorna Códigos Capturados com Funções ESQL
se a propriedade avançada "Throw exception on database
error" não for selecionada:
THROW USER EXCEPTION
CATALOG 'BIPv610' MESSAGE 2950 VALUES(
'SQL State:', SQLSTATE,
SQLCODE, SQLNATIVEERROR, SQLERRORTEXT);

 O nó "JavaCompute" Classe MbService;


o Fornece Log Evento e Métodos syslog logError(), logWarning(), e
logInformation() ;
o Texto da Mensagem produzido através de Recursos Pacote Java.;
Página 135
Roteamento de Mensagens
Comportamento Erro de "Message Flow" com "TryCatch"

Página 136
Roteamento de Mensagens
Comportamento Erro de "Message Flow": BOTHRESH

Página 137
Roteamento de Mensagens

“Subflows”
 Um "Subflow" é um "Message Flow" com Nós de Entrada ou Saída
(ou ambos);
 Usado como um Nó de processamento normal (nó composto):
o Arraste para incorporar no "flow" principal;
o Conecte Terminais.
 Reuso do Código;
 Níveis Múltiplos de Encapsulamento;
 Comprimido no "flow" Principal durante Compilação;
 Propriedades do Nó podem ser promovidas e transferidas para um
Nível Superior do "Message Flow";
 Pode ser feita a Implantação num “Integration Node”, independente
do "Message Flow" que usa o "Subflow".

Página 138
Roteamento de Mensagens

Nós que são usados num “Subflow”

 Todo " Subflow " deve começar com pelo menos um Nó


Entrada

 Todo “Subflow” deve terminar com pelo menos um Nó Saída

 Quando um " Subflow " é incorporado a um "flow" Principal,


é Visualizado com um Único Nó do "Message Flow"

Página 139
Roteamento de Mensagens

Propriedades de um “Subflow” num arquivo BAR


 Configure o "deployment descriptor" para o "Subflow";
 Use Valores de Propriedade Comuns ou Modifique Valores pela
Instância do "Subflow";
 Pode ser configurado a qualquer hora que o "Subflow" for
implantado:
o Quando implantado no "Message Flow" Principal e Aplicações;
o Quando possível implantado no
"Subflow" apenas.
 Compatível com Ferramentas existentes:
o Editor Arquivo BAR;
o Comando mqsiapplybaroverride;
o APIs.

Página 140
OBRIGADO

Página 141