Tutorial esb (aulas praticas)

de1 31 DAS - UFSC Profº Ricardo Rabelo
Universidade Federal de Santa Catarina"
Departamento de Automação e Sistemas"
"
"
"
"
"
"
"
"
"
"
"
Integração de Sistemas Corporativos"
"
"
"
"
"
"
"
Tutorial de integração de aplicações
utilizando Mule ESB – Plataforma de
Integração Open Source.!
"
"
"
"
"
"
"
"
"
"
"
"
"
"
"
"
"
"
"
"
João Santanna - Fevereiro de 2014"
"
"

"
ÍNDICE!
"
Tutorial de integração de aplicações utilizando Mule ESB – Plataforma de
Integração Open Source." 1"
Capitulo 1 - Introdução teórica." 3"
1.1 Introdução" 3"
1.2. Características de um ESB" 3"
1.2.1 Difusão" 3"
1.2.3 Integração Baseada em Padrões" 3"
1.2.4 Integração Altamente Distribuída e Seletivamente Implantada" 4"
1.2.5 Transformação de Dados" 4"
1.3. Arquitetura do Mule ESB" 4"
1.3.1 Serviços" 5"
1.3.2 Transportes" 6"
1.3.2.1 Conectores" 7"
1.3.2.2 Endpoints" 7"
1.3.2.3 Transformers" 8"
1.3.2.3 Roteadores" 8"
Capitulo 2 - Tutoriais introdutórios do Mule ESB." 10"
2.1. Introdução" 10"
2.2 Ferramentas" 10"
2.3 Projeto 1: echo na tela." 12"
2.4 Projeto 2: Alo mundo." 13"
2.5 Projeto 3 : Capturando objetos vindos do servidor web e tratando-os no Mule"14"
2.6 Projeto 4: Capturando dados vindos de um formulário web no tomcat." 17"
2.7 Projeto 5: Criando Java beans para utilizar no ﬂuxo do Mule" 17"
2.8 Projeto 6: Utilizando uma classe DAO para gravar dados" 17"
Capitulo 3 - Projeto de integração da disciplina " 19"
3.1. Cenário do projeto" 19"
3.2 Instalando as duas aplicações web." 20"
3.3 Integrando os dois aplicativos web (via mule)" 28"
3.4 Integrando o projeto legado ao mule" 29"
3.5 Utilizando o mule para enviar um email de notiﬁcação da compra" 30"
3.6 Enunciado do Projeto de disciplina" 31

"
Capitulo 1 - Introdução teórica.!
!
1.1 Introdução!
"
" O Mule é um enterprise service bus (ESB) e um framework de integração.Ele pode lidar
com serviços e aplicações usando protocolos de transporte díspares e tecnologias de
mensagens. A plataforma é Java based, mas pode intermediar as interações entre outras
plataformas, como .NET usando web services ou soquetes. Segundo o site oﬁcial, Mulesoft.com,
existem mais de 3000 empresas que utilizam o Mule ESB; 35% das empresas da Fortune 500, 5
dos 10 maiores bancos do mundo; a comunidade em torno do multe ainda conta com cerca de
150 mil desenvolvedores no mundo todo."
" Antes de começar nosso estudo a respeito do ESB Mule, vamos falar um pouco sobre as
características e funcionalidades de um ESB de maneira geral. Um ESB é uma plataforma de
integração baseada em padrões que combina troca de mensagens, Web Services,
transformações de dados e roteamento inteligente para conectar e coordenar a interação de
aplicações diversas através de uma organização e seus parceiros de negócios. Um ESB provê um
framework para implementar SOA, com um ambiente dirigido por eventos (event-driven), de baixo
acoplamento e um barramento de mensagens multiprotocolo."
"
1.2. Características de um ESB!
1.2.1 Difusão
"
" Um ESB tem a capacidade de abranger toda a corporação formando um grid de difusão de
aplicações e serviços com alcance global entre departamentos da organização, unidades de
negócios e parceiros comerciais. Aplicações se conectam ao barramento quando necessário,
possibilitando visibilidade e troca de dados entre as aplicações e serviços conectados ao
barramento."
"
1.2.3 Integração Baseada em Padrões
" "
" Para conectividade, ESB pode utilizar uma grande variedade de tecnologias padronizadas
como Java Message Service (JMS) e J2EE Conecctor Architecture (JCA e J2CA). Pode ser
utilizado para integrar aplicações desenvolvidas em várias tecnologias e plataformas como .NET,
COM, C# e C/C++. Adicionalmente ESB pode integrar facilmente aplicações que suportam SOAP

e APIs Web Service. Para compartilhamento de dados, ESB pode usar padrões XML como: XSLT,
XPath e XQuery, provendo transformação de dados e roteamento inteligente. ESB pode também
utilizar WSDL para descrever interfaces abstratas de serviços e Business Process Execution
Language (BPEL4WS) para Web Services."
" "
1.2.4 Integração Altamente Distribuída e Seletivamente Implantada
" "
" ESB provê integração de serviços, transformação de dados e adaptadores para aplicações
como serviços individuais que podem trabalhar juntos de uma forma altamente distribuída e que
pode ser escalada de forma independente. Um conceito central de ESB é o conceito de container
de serviço, que permite implantação seletiva de serviços de integração."
"
1.2.5 Transformação de Dados
"
" Uma parte fundamental da integração é a transformação de dados entre formatos
utilizados pelas aplicações que fazem parte da solução integrada. Muitas aplicações não
compartilham o mesmo formato para descrever dados similares. Transformação de dados
é parte integral do próprio ESB."
"
1.3. Arquitetura do Mule ESB
"
" A arquitetura do Mule consiste de uma coleção de componentes que provêm as
funcionalidades que um ESB deve oferecer. Vamos analisar os principais elementos que
compõem a arquitetura do Mule: Serviços, Transportes, Roteadores."

"
1.3.1 Serviços
"
" Mule é um ambiente de execução que hospeda serviços. Serviços são conjuntos discretos
de funcionalidades que são completamente separados uns dos outros, mas que podem trabalhar
juntos sobre os mesmos objetos. Um serviço Mule, representado pela figura a seguir, é composto
por três elementos:"
• Um “inbound router”, que especifica quais mensagens o componente de serviço processará. "
• Um componente de serviço, que implementa a lógica de integração do serviço e pode ser
implementado utilizando várias tecnologias, como: POJO, REST service e BPM, entre outros."
• Um “outbound router”, que determina para onde a mensagem deverá ser enviada após ser
processada pelo componente."
"
"
" Quando uma mensagem é enviada por uma aplicação, Mule pega a mensagem, envia-a
para o serviço que a processa usando alguma lógica e encaminhe-a para a aplicação correta.
Mule possui muitas partes individuais que tratam o processamento e roteamento da mensagem. A
principal parte de um serviço é o componente do serviço, que executa lógica de negócio sobre as
mensagens. Uma característica importante do componente do serviço é que ele não tem que ter
nenhum código específico Mule; ele pode ser simplesmente um POJO, um Spring bean, um Java
bean ou um web service. Mule gerencia o componente de serviço, envolve-o com configurações e
o expõe como um serviço, assegurando que a informação correta é passada para ele e a partir
dele conforme sua configuração. Um componente de serviço não contém qualquer informação de
como receber e enviar mensagens. Para assegurar que um componente de serviço receba

corretamente mensagens e as encaminhe apropriadamente após o processamento, precisamos
especificar um “inbound router” e um “outbound router”."
" Um inbound router especifica quais mensagens o componente de serviço irá processar.
Ele pode filtrar, agregar e mudar a sequência de mensagens antes de encaminhá-la ao
componente de serviço. Após o componente de serviço ter processado a mensagem, o outbound
router especifica para onde encaminhar a mensagem. Podem ser definidos múltiplos inbound e
outbound routers e mesmo cadeias de routers."
"
1.3.2 Transportes
"
" Mule pode tratar mensagens que são enviadas em uma variedade de protocolos como,
HTTP, JMS, FTP, VM, SMTP, JDBC e outros. O componente de serviço não se preocupa com o
protocolo usado, na verdade um componente de serviço não sabe como ler mensagens e não
precisa se preocupar com os formatos das mensagens. Ao invés disso, um transporte se
encarrega de transportar as mensagens e os “transformers” se encarregam de mudar as
mensagens de acordo com o formato requerido pelo componente de serviço. Todo o transporte,
transformação e roteamento de mensagens são completamente transparentes para o componente
de serviço."
" "
" Um transporte Mule provê todos os elementos ESB requeridos para receber, enviar e
transformar mensagens para um protocolo particular. Um transporte se manifesta em uma
configuração pelos seguintes elementos: conectores, endpoints e transformers. A figura a
seguir apresenta os elementos de um transporte Mule."
"

1.3.2.1 Conectores
"
! Um conector permite a um componente enviar ou receber dados através de um protocolo
específico. O conector tem a responsabilidade de controlar o uso de um protocolo particular. Ele é
configurado com parâmetros específicos para um protocolo e mantém qualquer estado que pode
ser compartilhado com as entidades abaixo que fazem a comunicação real. Temos então conector
JMS, conector HTTP, etc."
• Message Receiver. É uma classe que sabe como receber dados usando um protocolo e
convertê-los em um formato que o Mule possa usá-los."
• Message Dispatcher. É uma classe que sabe como converter dados Mule para transmissão
usando um protocolo específico."
• Transport-specific transformer. Classes opcionais que permitem transformar os dados
quando estão sendo enviados ou recebidos."
"
1.3.2.2 Endpoints
"
" Um endpoint representa o uso específico de um protocolo, se ele é para listening/polling,
para leitura ou escrita. Endpoints controlam quais entidades serão usadas com um conector.
Endpoints são elementos-chave de configuração para ligar todos os serviços. Inbound e outbound
endpoints existem no contexto de um serviço e representam respectivamente a entrada esperada
e pontos de saída para mensagens."
" Dentro de Mule, um endpoint pode conectar componentes de serviços a recursos locais
(como arquivos) ou a recursos de rede (por exemplo, conexões HTTP ou aplicações de terceiros).
Eles servem também como locais onde configurar várias outras características do ESB Mule,
como filtros, transformers e transações.A figura a seguir mostra o uso de endpoints para ligação
entre serviços internos e externos ao ESB Mule."
Os endpoints podem ser configurados em vários elementos de Mule:"
• Na seção inbound de um componente de serviço. Neste caso o endpoint é um inbound
endpoint, dados são lidos dele."
• Em um router dentro de uma seção outbound de um componente de serviço. Neste caso o
endpoint é um outbound endpoint e dados são escritos nele."
• Em definições de estratégias de exceção, usadas para gerir exceções."
• Em definições de estratégias “catch-all”, usadas para gerir possibilidades de roteamento."
"

1.3.2.3 Transformers
"
" Transformers são utilizados para possibilitar a comunicação entre componentes que
utilizam formatos de mensagens diferentes. Mule não impõe nenhum formato de mensagem,
portanto as aplicações podem utilizar os formatos mais convenientes."
" Podem-se usar 3 tipos diferentes de transformações:"
• Transformação de tipo de mensagem. Esta transformação não altera a mensagem
propriamente dita, apenas seu tipo. Por exemplo, podemos converter um byte stream para uma
string; uma mensagem JMS para um objeto Java. Este é o tipo de transformação específica de
transporte."
• Transformação de mensagem. Esta transformação envolve a conversão da mensagem
propriamente dita. É o tipo de transformação específica de aplicação."
• Transformações envolvendo propriedades de uma mensagem. Mensagens podem conter
propriedades, por exemplo, uma mensagem enviada para um servidor SMTP deveria ter as
propriedades “To”, “From” e “CC”."
Transformers são declarados nas configurações Mule antes de serem usadas. Eles são
referenciados por nome, normalmente dentro de endpoints. Transformers podem ser encadeados,
acumulando seus efeitos."
"
1.3.2.3 Roteadores
"
" Os roteadores desempenham um papel fundamental no controle da trajetória das
mensagens que transitam pelo ESB Mule. Eles ficam na entrada dos endpoint direcionando as
mensagens para que alcancem seus destinos corretos. Alguns roteadores são muito simples,
outros são mais complexos examinando inclusive algumas características das mensagens para
decidir quais rotas as mensagens devem seguir. Alguns roteadores chegam a um nível bastante
sofisticado podendo quebrar, classificar ou reagrupar mensagens baseando-se em certas
condições, normalmente executadas por entidades denominadas de filtros."
" Os filtros são complementos poderosos dos roteadores, provendo-os com a capacidade de
decisão do que fazer com as mensagens que estão em transito. Alguns filtros analisam o
conteúdo das mensagens, baseando-se em determinados valores para fazer o encaminhamento
das mensagens."
" O local do roteador no serviço determina sua natureza (inbound, outbound ou async-reply)
e os possíveis papéis nos quais ele poderia atuar (pass-through, aggregator, etc). Os inbound
routers são atravessados antes que a mensagem alcance o componente de serviço, enquanto os
outbound routers são alcançados após a mensagem ser processada pelo componente. Um

roteador async-reply cuida de enviar resposta assíncrona para o endpoint que a espera. Quando
nenhum roteamento é necessário, o roteador pode ser o mais simples possível. Neste caso o
roteador pode ser um pass-through, dando passagem a qualquer mensagem que decida transitar
por ele."
"
"

Capitulo 2 - Tutoriais introdutórios do Mule ESB."
"
2.1. Introdução!
"
Nessa seção vamos apresentar uma serie de tutoriais para introduzir a ferramenta multe e seu
ambiente de trabalho, o objetivo é familiarizar o aluno com a ferramenta antes de partir para o
projeto de integração. Os exemplos são descritos rapidamente e mostrado em detalhes em
vídeos postados na Internet."
2.2 Ferramentas"
"
Para a primeira parte do tutorial só precisamos do Mule ESB e do Java instalado na sua maquina.
Para a segunda parte do tutorial vamos precisar do Netbeans IDE instalado para dar suporte as
aplicações web que vamos integrar."
"
JAVA"
o JSDK pode ser baixado a partir do endereço : http://www.oracle.com/technetwork/pt/java/
javase/downloads/index.html . Baixe a versão mais atualizada para seu sistema operacional.
Nesse link inclusive você tem a opção de baixar o java JSDK já com o netbeans, recomendo
baixar o netbeans em separado na pagina de desenvolvimento da IDE. Na época de preparo
desse tutorial a versão JSDK era a 7.51, ver ﬁgura "
"
" " " Figura 4: JSDK java"
"
"
"
"

MULE ESB"
"
O Mule ESB pode ser encontrado no endereço: http://www.mulesoft.com , no final da pagina de
apresentação você encontra um botão para fazer o download, o site vai pedir para preencher um
pequeno cadastro , a única coisa chata de preencher é o telefone que deve estar no padrão
internacional , exemplo : 0554xxxx-xxxx ( no lugar do x coloque seu telefone). Depois disso vc
chega a uma tela para escolher a versão do multe para baixar, baixe a versão Designtime, como
mostra a figura 5, abaixo."
Figura 5: versão do Mule utilizada."
"
NETBEANS"
Para instalar as aplicações web do cenário do projeto vamos utilizar o Netbeans IDE, para esse
tutorial foi utilizado a versão 7.4, mas a versão 8 atual é totalmente compatível. Baixe a versão
mais completa (TUDO) do Netbeans no site : https://netbeans.org/downloads/"
figura 6: Download netbeans."

2.3 Projeto 1: echo na tela."
"
Código fonte do Mule:"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/MuleProjects/eb1.zip"
"
Video tutorial"
https://vimeo.com/album/2767541/video/88573522"
"
AVISO!!:"
Assista os vídeos tutoriais, eles tem maiores explicações e detalhes, cortamos essas informações
para esse tutorial não ficar muito extenso.!
"
Inicie o mule studio e crie um novo projeto mule( File-> New -> Mule Project), nomeie o projeto e
deixe as opções padrões marcadas, clique em finish. Na tela que vai surgir temos o Canvas que
funciona com Drop and down , basta arrastar os componentes da paleta de componentes e
montar o fluxo que queremos, ver figura 7 abaixo."
Figura 7: mule studio."
"
Agora procure no grupo de endpoints o componente endpoint http, araste o componente para o
canvas. A seguir , procure o componente echo no grupo de componets e araste para o canvas e
solte o componente logo depois do componente http. Ao final vc
estará com o seguinte fluxo configurado."
Esse simples fluxo do mule pega o trafego da porta http,
configurada por default na porte 8081, e ecoa de volta para o
programa que gerou o trafego, por exemplo um navegador web."
Para testar o fluxo , vá no menu do mule Run -> Run As->Mule
Applicartion, veja figura 8, abaixo. "
CANVAS
Componentes

" " " " Figura 8 : rodando o primeiro projeto Mule."
"
O mule deve iniciar e capturar todo o trafego na porta 8081. Você acompanha a inicialização dos
componentes do Mule na tela de console logo abaixo do canvas, figura 9 , abaixo."
Figura 9: componentes do mule inicializando."
"
Espere o mule terminar de carregar e abra um navegador, no endereço do navegado coloque
http://localhost:8081/ , quando você teclar enter vai notar que uma “/ “ vai aparecer no navegador,
experimente colocar o seu nome depois na barra de endereços ."
exemplo http://localhost:8081/maria, o mule pega o que vc está enviando e redireciona para o
navegador."
"
"
"
"
"
"
"
"
Figura 10: testando o fluxo."
"
"
"
2.4 Projeto 2: Alo mundo."
"
Video do projeto no Vimeo:"
https://vimeo.com/album/2767541/video/88573523"
Código fonte do Mule:"
"
"
Nesse segundo projeto vamos ecoar uma mensagem na tela , para isso montamos o fluxo
segundo a figura 11. O fluxo captura o trafego http , transforma o objeto enviado do navegado em
uma string e tratamos essa string com um componente java."

Ao final temos o seguinte fluxo abaixo."
Figura 11: segundo projeto , alo mundo ."
"
Para esse projeto precisamos criar uma classe java que receba essa string , formate a mensagem
e envie de volta para o navegador, confira os detalhes e o código fonte nos links correspondentes."
"
"
2.5 Projeto 3 : Capturando objetos vindos do servidor web e
tratando-os no Mule"
"
Video do projeto no Vimeo: 1 Importando aplicativo para o netbeans"
https://vimeo.com/92970672"
Video do projeto no Vimeo: 2 projeto no mule + aplicativo web no glassfish"
"
Arquivos do projeto do Netbeans:"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/NetbeansProj/ESB3.zip"
Arquivos do projeto do Mule:"
"
"
Esse projeto está dividido em 2 partes na primeira criamos uma aplicação “casca" no netbeans,
essa aplicação não vai fazer nada somente é uma pagina web html rodando em um servidor
(Glassfish) , essa aplicação pega o nome e o sobrenome de uma pessoa e não faz nada com o
dado, essa informação é capturada pelo mule que vai tratar a mensagem."
"
Na primeira parte o objeto que vier do servidor Glassfish é capturado pelo multe, o fluxo
transforma o objeto em uma strign e ecoa o resultado na tela."
"
Primeiro baixe o código fonte do aplicativo casca feito no netbeans e que está disponível no
seguinte endereço."
"
Importe esse projeto para o netbeans e coloque ele para rodar no glassfish. Para ver como isso é
feito veja o video do seguinte endereço."
"
Importante: A aplicação “casca” deve estar rodando no glassfish antes de rodarmos o fluxo do
Mule, se você rolar primeiro o servidor mule e depois o glassfish , o servidor web vai retornar um
erro e não vai funcionar , ele vai informar que a porta já está ocupada (pelo mule)."
"

Você pode também baixar o projeto mule dessa aula no endereço:"
A seguir vamos montar o fluxo no mule, crie um novo projeto e araste os componentes segundo a
figura abaixo."
Figura 12: primeira parte do terceiro projeto."
"
Agora vamos testar o fluxo, primeiramente se você ainda não o fez coloque o projeto ESB3 do
netbeans para rodar, ao final da carga o netbeans vai chamar o seu navegador web padrão e vai
aparecer a pagina da aplicação casca. Volte para o mule, de dois cliques no endpoint http, vai
aparecer uma aba de configuração do elemento, altere o valor da porta para 8080 ou 8081 (portas
padrão do glassfish), veja figura 13 abaixo, depois de fazer essa alteração coloque o fluxo para
funcionar."
Figura 13: aba de configuração do endpoint http."
"
Agora volte par a a aplicação web e digite nome e sobrenome, você vai ver que o mule vai ecoar
na tela do navegador algo como a imagem abaixo."
"
"
"
"
"
"
"
"
"
"
"

Isso significa que o mule capturou o objeto enviado para o glassfish, converteu em string e ecoou
na tela o resultado. Se quiser testar com valores diferentes vá ao navegador clique no botão voltar
e teste novos valores."
"
Agora vamos a segunda parte do projeto, vamos criar uma classe java que vai receber os valores
e trata-los antes de ecoar o resultado na tela. Para isso vá ao projeto aberto clique na pasta src/
main/java e crie um pacote para armazenar nossa classe , recomendo usar o nome de pacote
como das.ufsc.br , veja a figura 14 abaixo."
Figura 14: adicionando um pacote para receber a classe de tratamento."
"
A seguir clique no pacote e crie uma nova classe java, no projeto chamei essa classe de
Tratamento.java. O código da classe segue comentado no arquivo do projeto que vc pode baixar
da internet, basicamente ele separa os argumentos e retorna o nome e o sobre nome ao usuário
tirando os símbolo & do meio."
"
Agora devemos modificar o fluxo para poder usar a classe java criada, para isso você troca o
componente eco ( basta selecionar o componente e apertar no botão deletar do teclado) , pelo
componente java, o fluxo fica da seguinte maneira conforme a figura 15 abaixo."
Figura 15: fluxo alterado."
"
Agora de duplo clique no componente java para configura-lo , no campo class name clique no
botão e digite o nome da sua classe recém criada, agora quando a string chegar nesse
componente essa classe será utilizada para tratar o componente."
"
Salve as alterações coloque o fluxo para rodar e repita o teste no aplicativo web. O resultado fica
parecido com o da figura abaixo ( depende do nome digitado :-) ). Note o sinal de "+" depois no
nome, isso aconteceu por que o + substitui os espaços em branco, vamos tratar isso no próximo
projeto. Isso finaliza o projeto 3."

2.6 Projeto 4: Capturando dados vindos de um formulário web no
tomcat."
"
"
"
"
Nesse projeto vamos mostra como instalar o servidor Tomcat e criamos outra aplicação somente
com a apresentação ( casca) para utilizar junto com o Tomcat, depois disso vamos trabalhar na
classe java para melhorar o tratamento da string que agora é bem maior."
"
Como esse projeto é de muitos passos, vamos apresenta-lo somente em video: primeiramente
comece assistindo o video para instalar o servidor Tomcat no netbeans, depois baixe os arquivos
do mule e do netbeans, importe os projetos, e termine de ver o tutorial."
"
"
2.7 Projeto 5: Criando Java beans para utilizar no ﬂuxo do Mule"
"
"
"
"
Nesse projeto vamos mostra como criar e testar um java bean que pode ser reutilizado ao longo
do ﬂuxo nos projetos do Mule."
"
Como esse projeto é de muitos passos, vamos apresenta-lo somente em video. O projeto do
Netbeans é o mesmo da seção passada, se você já baixou o aplicativo não tem necessidade de
faze-lo novamente."
"
"
2.8 Projeto 6: Utilizando uma classe DAO para gravar dados"
"
Video do projeto no Vimeo:!
https://vimeo.com/92986284 "
Arquivos do projeto do Netbeans:!
"
Drivers do Banco de dados JavaDB:"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/DriversJavaDB/derby.jar"
"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/DriversJavaDB/derbyclient.jar"
"

Nesse projeto vamos mostra como utilizar uma classe DAO ( Data Access Object),é um padrão
para persistência de dados que permite separar regras de negócio das regras de acesso a banco
de dados. Numa aplicação que utilize a arquitetura MVC, todas as funcionalidades de bancos de
dados, tais como obter as conexões, mapear objetos Java para tipos de dados SQL ou executar
comandos SQL, devem ser feitas por classes de DAO."
"
Como esse projeto é de muitos passos, vamos apresenta-lo somente em video. O projeto do
Netbeans é o mesmo da seção passada, se você já baixou o aplicativo não tem necessidade de
faze-lo novamente."
"
"
"

Capitulo 3 - Projeto de integração da disciplina "
"
"
3.1. Cenário do projeto"
"
O projeto da disciplina conta com 2 aplicações java web. Uma aplicação voltada para a compra de
um kit robótico (corpo apenas) , e a segunda aplicação voltada para a compra de reatores para os
robôs. Os produtos são hipoteticamente de duas empresas diferentes. "
"
Uma terceira aplicação (somente uma casca de apresentação ao usuário), realiza uma venda
integrada (os dois produtos juntos), essa aplicação vende os robôs juntamente com os reatores.
Para isso essa aplicação utiliza o Mule ESB para enviar os pedidos para o sistema das empresas
correspondentes. Vamos iniciar o tutorial instalando as suas aplicações web e testado elas no
ambiente de desenvolvimento Netbeans."
"
Além disso vamos integrar dois projetos do mule que serão apresentados a seguir:"
• Aplicativo legado (feita em Java) que recebe para que estado do Brasil o pedido se
destina e calcula o valor do frete."
• Projeto mule que recebe dados de um fluxo e envia email para o usuário."
Ao final nosso projeto de integração deve ficar similar ao ilustrado na figura abaixo."
Figura 16: cenário de integração."

As duas aplicações (1 e 2) vão estar rodando no servidor Glassﬁsh enquanto que a aplicação de
integração(3) vai estar rodando no Tomcat. A aplicação legada deve ser integrada ao Mule ESB,
como ela é uma aplicação desktop não precisa de servidor. O projeto de email é todo feito com
recursos do multe e também não precisa de servidor adicional. "
"
Na próxima seção vamos iniciar abordando como instalar as aplicações 1 e 2 no Netbeans."
"
3.2 Instalando as duas aplicações web.!
"
As duas aplicações são similares, a única diferença são os itens que elas comercializam. Nosso
ambiente de testes foi preparado tendo como base a IDE netbeans. Precisamos baixar os
arquivos do projeto, são dois arquivos ZIP: BrRobotics.zip e StarkSystem.zip. Esses são os
arquivos dos projetos exportados a partir do Netbeans, você pode baixa-los nos links abaixo: "
"
BrRobotics.zip: "
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/BrRobotics.zip"
StarkSystem.zip:!
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/StarkSystem.zip"
Depois de instalado os softwares e de posse dos dois arquivos dos projetos precisamos importar
os dois projetos para o Netbeans. Vamos fazer isso passo a passo para cada um dos projetos,
isso porque ambas as aplicações possuem banco de dados que devem ser criados depois de
importado o projeto."
# Importação do App BRrobotics!
Acompanhe o video abaixo que explica como importar as duas aplicações."
"
Video no vimeo:"
https://vimeo.com/88290936!
"
1º Passo: Importar o projeto.!
! Abra o netbeans, vá no menu arquivo -> importar Projeto -> De ZIP.!

! Escolha o arquivo zip correspondente, pode ser que durante a importação do projeto a IDE
aponte um erro na importação, caso o servidor web que vamos utilizar não esteja ainda ativado,
isso acontece quando é a primeira vez que você utiliza a IDE para um projeto javaweb."
" Para resolver essa pendência , clique no projeto importado com o botão direito e vá na
opção resolver problema da falta de servidor…"
Uma Janela deve abrir para informar que o destino não foi deﬁnido ou resolvido, clique no botão
Adicionar Servidor."

Escolha o Glass Fish server , clique no botão próximo e deixe a configuração como o netbeans
sugere, clique no botão próximo até surgir a opção do botão finalizar."
" Ao final ele retorna para a janela de escolha do servidor, basta clicar no botão ok."
" Feito isso as pendências do projeto vão sumir e o projeto vai tirar os avisos. A importação
foi feita com sucesso. Nesse momento tente rodar a aplicação, menu Executar -> Executar projeto
(BRRobotics), o netbeans vai fazer o deployment no servidor Glassfish e inicializar a aplicação, a
primeira vez que isso é feito demora vários segundos , aguarde até terminar…"
" Quando o servidor terminar de inicializar ele abre automaticamente seu browser padrão e
o endereço da aplicação."

Você pode utilizar a aplicação, compre alguns itens e depois informe vá ao caixa, informe os
dados para a entrega e um numero de pedido (pode informar um numero inteiro qualquer), essa
aplicação não é completa é só um protótipo para o cenário do ESB , em uma aplicação real a
própria aplicação geraria o numero do pedido. "
Depois disso feche o pedido e note que nada acontece, aparece uma pagina em branco. Isso
aconteceu porque ainda não criamos o banco de dados para que a aplicação possa gravar cada
uma das compras, esse é o segundo passo."
"
2º Passo: Preparar o banco de dados.!
Acompanhe o video abaixo que explica como criar o banco de dados:"
"
Video no Vimeo:!
Vamos utilizar o banco de dados nativo do Netbeans o Derby também chamado de Java
DB.Primeiramente clique na aba serviços ao lado da aba projetos. Uma vez na aba serviços
expanda a opção Banco de dados , vai aparecer um ícone Java DB, clique com o botão direito
nesse ícone e escolha a opção Criar Banco de Dados."
Uma janela de criação de banco de dados vai aparecer em seguida , informe o nome do Banco de
dados, o nome do usuário e a senha. use os valores que estão na ﬁgura abaixo. A aplicação
BRrobotics foi programada para funcionar com esses valores, se você trocar qualquer desses
valores a aplicação não vai funcionar. A senha do banco é root. Depois de informar os valores
clique em ok. "

Uma nova entrada vai aparecer, indicando que o banco foi criado. Clique nessa nova entrada e
escolha a opção conectar"
O próximo passo é criar uma tabela dentro do banco de dados. Clique no banco de dados, na
base ROOT -> Tabelas -> Criar Tabela"
Uma janela para a criação de tabela aparece para você informar os campos. Primeiramente
coloque o nome da tabela como: pedidos."
"
Em seguida vamos informar cada coluna da tabela, crie as colunas segundo a tabela abaixo,
utilize a mesma ordem das tabelas, a ordem é importante nesse caso."
Tabela 1: colunas da tabela pedidos."
Nome da coluna" Tipo de dado Tamanho
codigo numeric 10
cliente varchar 40
endereco varchar 100
estado varchar 10
itens varchar 100
total real -

Importante!!!: 1) A primeira coluna (código) é a chave primaria, marque essa opção quando
estiver criando essa coluna. 2) Não utilize acentuação, pode escrever tudo em minúsculas. 3)
Para o tipo real não se informa o tamanho do campo."
Ao final sua tabela deve estar como a figura abaixo, clique em ok e a tabela será criada."
Antes de sair desse passo verifique a estrutura da tabela, clique na tabela recém criada, ela deve
estar com a estrutura igual a da figura abaixo."
"
Passo 3: Testando a aplicação"
Agora , vamos testar novamente a aplicação. Mas antes vamos reiniciar o servidor Glassfish e
recompilar o projeto. "
Primeiramente pare o servidor, vá nas abas inferiores, clique na aba Glass Fish server, depois
clique no botão para para o servidor."
Depois clique no ícone para limpar e construir a aplicação ( um ícone de martelo no menu do
netbeans), isso vai fazer o link com o banco recém criado, depois execute o projeto normalmente. "

Primeiramente escolha um produto."
" Depois vá ao caixa para fechar a compra."
" Informe os dados para a entrega, aqui tem um detalhe, como código é uma chave primaria
esse numero não pode ser repetido, logo quando estiverem utilizando o aplicativo tenham cuidado
para não repetir o capo de código de pedido, você vera logo mais como consultar os dados da
tabela para ver que números de pedidos já foram utilizados. "
" "

Ao ﬁnal a aplicação mostra uma pagina com o link para voltar para a pagina inicial, isso indica que
a compra foi gravada com sucesso no bando de dados."
Para ver a compra feita no banco de dados, vá a aba serviços -> clique no banco de dados do
BrRobotics, se ele não está conectado clique em conectar, entre na base ROOT, e clique com o
botão direito na tabela pedidos, escolha a opção exibir dados. Uma janela de consulta SQL vai ser
aberta e mostrar o resultado."
" Com isso encerramos a instalação do primeiro sistema da BRrobotics."
"
# Importação do App StarkSystem!
"
Repita o primeiro passo com o arquivo do app da StarkSystem. Como você já vai ter adicionado o
servidor Glass Fish não vai precisar tratar a pendência inicial."
"
Após a importação inicial precisamos criar o bando de dados para o app, o funcionamento é muito
similar ao 2º passo do BRrobotics , a diferença é o nome do banco."

Siga o passo 2 , crie o banco conforme os valores da figura acima (senha: root). Depois crie uma
tabela (pedidos) igual a criada para o BRrobotics, as mesmas colunas, os mesmos valores da
tabela1."
"
Depois de criado o banco, proceda como no passo 3 e teste a aplicação. Se você se perdeu leia
novamente essa seção com calma e veja o video, o video vem bem detalhado e com comentários
que talvez ajudem a resolver o problema que você encontrou."
"
3.3 Integrando os dois aplicativos web (via mule)!
"
Acompanhe o video abaixo que explica como montar o fluxo e como testar se a integração está
funcionando. Baixe o código do projeto do Mule para acompanhar o video."
"
"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/NetbeansProj/NewTec.zip"
"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/MuleProjects/ProjInteg.zip"
"
"
Drivers do Banco de dados JavaDB:"
"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/DriversJavaDB/derby.jar"
"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/DriversJavaDB/derbyclient.jar"
"
"
Ao final o seu projeto de integração deve estar conforme a figura abaixo. "
"
Note que nosso fluxo principal se divide, quando o fluxo chega ao transformador all , ele é enviado
para os dois fluxos resultantes, isso é necessário para poder tratar os dados da compra relativa ao
chassi do robô separadamente do reator, posteriormente cada um desses dados é inserido no
banco de dados correspondente."
"
"

3.4 Integrando o projeto legado ao mule!
"
Nessa segunda parte do projeto da disciplina vamos mostrar como integrar uma aplicação legado
ao nosso sistema. A aplicação legado é um programa simples em java que recebe o valor do
estado do Brasil para onde se destina a encomenda e calcula o valor do frete."
Figura 18: aplicativo Calculafrete, calculando um frete para Santa Catarina -SC."
"
O aplicativo foi feito no netbeans em java . O Mule ESB é feito em java e dá suporte de integração
nativo a algumas linguagens suportadas pela java virtual machine do Java, no caso poderíamos
facilmente integrar aplicativos legados feitos em Python ou Ruby."
"
Nosso aplicativo legado é uma classe java que contem uma
serie de if else para testar o estado de destino da compra e
calcular o frete. A tabela de preços utilizada é a da figura ao
lado:"
"
"
Figura 19: Tabela de preços. "
O video abaixo explica como fazer a integração. Ao final seu fluxo no mule deve ficar como a
figura abaixo:"
Figura 20: fluxo do exemplo de integração."
"
"

https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/NetbeansProj/CalculaFrete.zip"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/MuleProjects/ProjLegado.zip"
"
3.5 Utilizando o mule para enviar um email de notificação da
compra!
"
Chegamos a parte final do tutorial, nesse exemplo temos um fluxo que recebe os dados via
formulário web e ao final envia um email de confirmação da compra."
"
Os dados são recebidos, o payload da mensagem é alterado e ao final usamos um endpoint de
SMTP ( Simple Mail Transference Protocol ) para enviar um email utilizando uma conta do google
mail ( Gmail). Esse email chega confirmando a compra."
O video a seguir explica como fazer a integração. Ao final seu fluxo no mule deve ficar como o da
figura acima."
"
Detalhe: para fazer o fluxo funcionar use a sua conta de email e a sua senha , o projeto vai estar
com o campo senha vazio. Se você não tem uma conta de email no google basta criar, o restante
das configurações são as mesmas."
"
Arquivos do projeto do Netbeans - ( Já foi baixado previamente em outro video):"
https://dl.dropboxusercontent.com/u/2056692/Projeto%20ESB/MuleProjects/Email.zip"
"
"
"
"
"
"
"
"

3.6 Enunciado do Projeto de disciplina!
"
Utilizando os tutoriais da seção passada monte um só projeto de integração que comporte as duas
aplicações web , o código legado ( Calcula frete ) e o projeto de envio de email, siga as
seguintes especificações:!
" - A fonte de dados deve ser nosso aplicativo "casca" que vai receber os pedidos via um
formulário web."
- O estado de destino da compra deve ser passado para a aplicação legado que deve calcular
o valor de frete, o valor do frete deve ser incorporado no pedido de carcaça de robôs, ou seja
o valor do frete vai ser incorporado ao valor da carcaça e deve constar no banco de dados
correspondente. "
- Os pedidos devem ser inseridos nos respectivos bancos de dados. "
- Uma mensagem de conclusão da compra deve ser ecoada na tela do navegador , bem como
uma mensagem de confirmação da compra deve ser enviada por email."
- O aluno pode utilizar todos os códigos disponíveis em tutoriais prévios."
"
O trabalho deverá ser realizado em equipes de 3 alunos, cujas formações devem ser enviadas por
email (ricardo.rabelo@ufsc.br). Portanto,teremos 8 equipes."
"
Ao final do trabalho os alunos devem entregar apenas o código computacional gerado/utilizado/
funcionando. Ou seja, não será cobrado nenhum relatório escrito associado."
"
Os trabalhos serão defendidos presencialmente e com toda a equipe."
"
Os alunos deverão trazer as coisas funcionando em seus notebooks. Conforme o"
desempenho de cada membro da equipe na defesa, as notas da equipe não necessariamente
serão iguais."
"
Cada equipe deverá marcar a data/horário de defesa com o João Santanna
( joaosantanna@yahoo.com.br) , diretamente, até 7/7."
"
Critérios de Avaliação:!
"
1) Ter o sistema sem bug, funcionando; "
2) Corretude do sistema frente às especificações; "
3) Nível de resposta dos alunos durante a defesa; "
4) Um “bônus” será dado adicionalmente às equipes que implementarem coisas a mais, por
exemplo, uso de filtros mais sofisticados, integração com outros sistemas, etc.

Tutorial esb (aulas praticas)

Mais conteúdo relacionado

Mais procurados

Semelhante a Tutorial esb (aulas praticas)

Tutorial esb (aulas praticas)