Java-Magazine 140 Zoovzveb

Assine agora e tenha acesso a
todo o conteúdo da DevMedia:

www.devmedia.com.br/mvp
Edição 140 • 2015 • ISSN 1676-8361
Atendimento ao leitor Fale com o Editor!

EXPEDIENTE A DevMedia possui uma Central de Atendimento on-line, onde você
pode tirar suas dúvidas sobre serviços, enviar críticas e sugestões e É muito importante para a equipe saber o que você está achando da revista:
falar com um de nossos atendentes. Através da nossa central também que tipo de artigo você gostaria de ler, que artigo você mais gostou e qual
artigo você menos gostou. Fique a vontade para entrar em contato com os
Editor é possível alterar dados cadastrais, consultar o status de assinaturas
editores e dar a sua sugestão!
e conferir a data de envio de suas revistas. Acesse www.devmedia. Se você estiver interessado em publicar um artigo na revista ou no site Java
Eduardo Spínola ([email protected])
com.br/central, ou se preferir entre em contato conosco através do Magazine, entre em contato com o editor, informando o título e mini-resumo
telefone 21 3382-5038. do tema que você gostaria de publicar:
Consultor Técnico Diogo Souza ([email protected])
Publicidade
[email protected] – 21 3382-5038
Produção
Jornalista Responsável Kaline Dolabella - JP24185 Anúncios – Anunciando nas publicações e nos sites do Grupo DevMedia, Eduardo Oliveira Spínola
você divulga sua marca ou produto para mais de 100 mil desenvolvedores eduspinola.wordpress.com
Capa Romulo Araujo
de todo o Brasil, em mais de 200 cidades. Solicite nossos Media Kits, com
Diagramação Janete Feitosa detalhes sobre preços e formatos de anúncios. @eduspinola / @Java_Magazine
Distribuição
FC Comercial e Distribuidora S.A Java, o logotipo da xícara de café Java e todas as marcas e logotipos
Rua Teodoro da Silva, 907, Grajaú - RJ baseados em/ ou referentes a Java são marcas comerciais ou
marcas registradas da Sun Microsystems, Inc. nos Estados Unidos e
CEP 20563-900, (21) 3879-7766 - (21) 2577-6362
em outros países.
Sumário
Artigo no estilo Curso
06 – Criando uma aplicação corporativa em Java – Parte 4

[ Bruno Rafael Sant’ Ana ]
16 – Dominando o Java Collections Framework e Generics

[ José Fernandes A. Júnior ]
Conteúdo sobre Boas Práticas, Artigo no estilo Mentoring
26 – Refatoração utilizando padrões de projeto e boas práticas

[ Alex Radavelli ]
Feedback
s eu
Dê
Conteúdo sobre Boas Práticas
sobre e
34 – Elaborando projetos com a Arquitetura Orientada a Eventos
[ Ualter Azambuja Junior ]
s
ta
edição
Conteúdo sobre Boas Práticas

Dê seu feedback sobre esta edição!
52 – Gerenciamento de dependências no Java
[ Brunno F. M. Attorre ] A Java Magazine tem que ser feita ao seu gosto.
Para isso, precisamos saber o que você, leitor, acha
da revista!
Conteúdo sobre Novidades, Artigo no estilo Solução Completa Dê seu voto sobre esta edição, artigo por artigo, atra-
vés do link:
62 – Big Data: MapReduce na prática www.devmedia.com.br/javamagazine/feedback
[ Cláudio Martins e Wesley Louzeiro Mota ]
Criando uma aplicação
corporativa em Java –
Parte 4
Conheça mais recursos do JSF e desenvolva as
regras de negócio da aplicação
Este artigo faz parte de um curso Fique por dentro

Este artigo é útil por apresentar informações importantes sobre o
JavaServer Faces e concluir o desenvolvimento da aplicação exemplo.
N
este quarto e último artigo da série desenvol- Como um dos destaques, citamos a análise sobre as fases do ciclo de
veremos as duas principais funcionalidades do vida do processamento de uma requisição a uma página JSF. Além
sistema gerenciador de bibliotecas: o emprésti- disso, vamos demonstrar como adotar a nova API de Data e Hora na
mo e a devolução de livros. Citamos tais funcionalidades prática, recurso lançado com a versão 8 do Java e que já começa a
como as mais importantes porque são elas que agregam ser amplamente adotado pelo mercado. A partir de todo o conteúdo
maior valor a um software destinado a bibliotecas. exposto nesta série, o leitor terá um ótimo material de referência para
A implementação desses dois itens será feita por meio iniciar o desenvolvimento de suas aplicações e se aprofundar ainda
de páginas JSF e managed beans. mais no assunto.
Ainda nesse artigo, serão explicadas as fases do ciclo
de vida do processamento de uma requisição feita a uma
página JSF. Para complementar esse tópico, também do suas informações no banco de dados. Para isso, é possível no
mostraremos um exemplo prático de como implementar formulário escolher o livro que será emprestado e para qual leitor
a interface PhaseListener, da API do JavaServer Faces, o é este empréstimo.
que é bastante útil quando precisamos executar algum Para apresentar todos os livros disponíveis para empréstimo,
código antes ou depois de alguma fase do ciclo de vida usamos os componentes h:selectOneMenu, que irá gerar um
da requisição. elemento HTML do tipo select, e f:selectItems, que irá gerar
Por fim, também é válido citar que passaremos rapi- elementos HTML do tipo option. Através do componente
damente pela nova API de data e hora do Java 8, a qual h:selectOneMenu conseguimos associar o valor do item sele-
será adotada para simplificar a manipulação de datas cionado com uma propriedade do managed bean (nesse caso, a
em todas as funcionalidades relacionadas da nossa propriedade idLivro). Com relação ao componente f:selectItems,
aplicação. para que o leitor entenda como ele foi utilizado no código da pá-
gina emprestimo.xhtml, veremos para que servem seus atributos,
Criando a funcionalidade para empréstimo de livros que são explicados a seguir:
Após toda a construção realizada até aqui, o nosso • value – colocamos nesse atributo a EL #{emprestimoBean
próximo passo é implementar a funcionalidade para em- .livrosDisponiveis}, para indicar que os livros que devem ser
préstimo de livros. Iniciaremos pela página emprestimo listados devem ser provindos da propriedade livrosDisponiveis
.xhtml, que tem seu código apresentado na Listagem 1. do managed bean. Em outras palavras, o método getLivros-
Tal página, apresentada na Figura 1, é composta por Disponiveis() – presente no bean – será invocado e irá retornar
um formulário que irá registrar o empréstimo, salvan- uma lista de livros, que serão exibidos na tela;
6 Java Magazine • Edição 140

• itemValue – define o que será setado na propriedade idLivro • itemLabel – define o que de fato será exibido para o usuário.
do bean. Como podemos notar na EL #{livro.id}, será setado o id Ao observarmos a EL #{livro.nome}, fica fácil presumir que serão
do livro selecionado; apresentados apenas os nomes dos livros na listagem.
Para que sejam listados todos os leitores, também usamos as

mesmas tags h:selectOneMenu e f:selectItems na página em-
prestimo.xhtml. Já do lado do managed bean, de forma análoga ao
que fizemos com o idLivro, também criamos uma propriedade
idLeitor para receber o id do leitor selecionado.
Logo abaixo do componente que lista os leitores serão exibidas a
data do empréstimo e a data prevista para devolução do livro. Para
isso, usamos o componente h:inputText, porém configuramos seu
atributo disabled para true para que o usuário do sistema não
possa alterar essas datas, que serão geradas automaticamente.
O último componente do formulário é um h:commandButton,
que irá acionar o método realizarEmprestimo() do managed
bean, quando clicado.
Listagem 2. Código do managed bean LeitorBean.
Figura 1. Conteúdo da página emprestimo.xhtml package br.com.javamagazine.mb;
import java.util.List;
Listagem 1. Código da página emprestimo.xhtml. import javax.enterprise.context.RequestScoped;
import javax.inject.Inject;
<?xml version=”1.0” encoding=”ISO-8859-1” ?> import javax.inject.Named;
<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” import br.com.javamagazine.dao.LeitorDao;
“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”> import br.com.javamagazine.entidades.Leitor;
<html xmlns=”http://www.w3.org/1999/xhtml” import br.com.javamagazine.interceptadores.Transacional;
xmlns:f=”http://java.sun.com/jsf/core”
xmlns:h=”http://java.sun.com/jsf/html” @Named
xmlns:ui=”http://java.sun.com/jsf/facelets”> @RequestScoped
<ui:composition template=”/WEB-INF/_template.xhtml”> public class LeitorBean {
<ui:define name=”corpo”>
<h:form> //restante da implementação omitida
<h2>
<h:outputText value=”Empréstimo” /> @Inject
</h2> private LeitorDao leitorDao;
<fieldset> private List<Leitor> leitores;
<legend>Dados do Empréstimo</legend>
@Transacional
<h:outputLabel value=”Escolher livro a emprestar:” for=”livro” /> public List<Leitor> getLeitores(){
<h:selectOneMenu id=”livro” value=”#{emprestimoBean.idLivro}”> if(leitores == null){
<f:selectItems value=”#{emprestimoBean.livrosDisponiveis}” leitores = leitorDao.listarLeitores();
var=”livro” itemValue=”#{livro.id}” itemLabel=”#{livro.nome}” /> }
</h:selectOneMenu>
<h:outputLabel value=”Leitor:” for=”leitor” /> return leitores;
<h:selectOneMenu id=”leitor” value=”#{emprestimoBean.idLeitor}”> }
<f:selectItems value=”#{leitorBean.leitores}”
var=”leitor” itemValue=”#{leitor.id}” itemLabel=”#{leitor.nome}” /> //restante da implementação omitida
</h:selectOneMenu> }
<h:outputLabel value=”Data do empréstimo:” for=”dataEmprestimo” />
<h:inputText id=”dataEmprestimo” value=”#{emprestimoBean
.dataEmprestimoFormatada}” disabled=”true” /> Como podemos verificar na Listagem 1, é utilizada a tag
<h:outputLabel value=”Data prevista para devolução:” for=”dataPrevista” /> f:selectItems para que sejam exibidos os nomes dos leitores e no
<h:inputText id=”dataPrevista” value=”#{emprestimoBean
.dataPrevistaFormatada}” disabled=”true” />
atributo value dessa tag é colocada a EL #{leitorBean.leitores}.
<h:commandButton value=”Realizar Empréstimo” action= Então, para que essa página funcione, o managed bean Leitor-
”#{emprestimoBean.realizarEmprestimo}” /> Bean precisa ser criado. O código desse bean pode ser visto na
</fieldset>
</h:form> Listagem 2. Note que deixamos essa classe com o mínimo de
</ui:define> código necessário, permanecendo apenas o método getLeitores(),
</ui:composition> que irá recuperar a lista com todos os leitores do banco de dados
</html>
através de uma classe DAO.
Edição 140 • Java Magazine 7

Criando uma aplicação corporativa em Java – Parte 4
Analisaremos agora o código do managed bean EmprestimoBean, Listagem 3. Código do managed bean EmprestimoBean.
presente na Listagem 3. No construtor dessa classe são invocados
package br.com.javamagazine.mb;
os métodos setters no objeto que representa o empréstimo para
que sejam definidas a data do empréstimo e a data prevista para import java.time.LocalDate;
devolução do livro. A data do empréstimo é a data atual e a data import java.time.format.DateTimeFormatter;
prevista para devolução é obtida a partir da adição de sete dias à import java.util.List;
import javax.enterprise.context.RequestScoped;
data atual. Com o intuito de simplificar o nosso trabalho, observe import javax.inject.Inject;
que estamos usando a nova API de data e hora do Java 8. Com import javax.inject.Named;
ela fica bem mais simples somar sete dias à data atual, pois a // restante dos imports omitidos
API provê uma interface fluente que possibilita o encadeamento @Named

de chamadas de métodos, o que geralmente torna o código mais @RequestScoped
fácil de ler. public class EmprestimoBean {

Para que essas duas datas sejam mostradas ao usuário no formato
@Inject
dd/MM/yyyy, usamos a classe DateTimeFormatter – também private EmprestimoDao emprestimoDao;
disponível a partir do Java 8 – para formatá-las. Ambas as datas private Emprestimo emprestimo = new Emprestimo();
serão formatadas como String e armazenadas nas variáveis da- @Inject
private LivroDao livroDao;
taEmprestimoFormatada e dataPrevistaFormatada. private Integer idLivro;
Para que essas datas sejam exibidas ao usuário, na página empres- private List<Livro> livrosDisponiveis;
timo.xhtml são utilizados dois componentes do tipo h:inputText @Inject
private LeitorDao leitorDao;
que têm como valor as seguintes ELs: #{emprestimoBean
private Integer idLeitor;
.dataEmprestimoFormatada} e #{emprestimoBean.dataPrevista- @Inject
Formatada}. private UsuarioLogadoBean usuarioLogadoBean;
String dataEmprestimoFormatada;
O principal método desse bean é o realizarEmprestimo(),
String dataPrevistaFormatada;
que contém a lógica referente ao empréstimo de livros. Ob-
serve que colocamos a anotação @Transacional para que ele EmprestimoBean(){
seja interceptado pelo nosso TransacionalInterceptor e seja emprestimo.setDataEmprestimo(LocalDate.now());
emprestimo.setDataPrevista(LocalDate.now().plusDays(7));
executado dentro de uma transação. Antes de persistirmos o DateTimeFormatter formatador = DateTimeFormatter.ofPattern(“dd/MM/yyyy”);
empréstimo, no entanto, precisamos relacioná-lo com o livro dataEmprestimoFormatada = emprestimo.getDataEmprestimo()
que está sendo emprestado, com o leitor que está tomando o .format(formatador);
dataPrevistaFormatada = emprestimo.getDataPrevista().format(formatador);
livro emprestado e com o funcionário da biblioteca que está
}
operando o sistema. Conforme explicado na listagem anterior,
a classe EmprestimoBean possui duas propriedades, idLivro e @Transacional
idLeitor, que armazenam os ids dos objetos, e usamos esses ids public void realizarEmprestimo(){
Livro livro = livroDao.pesquisarPorId(idLivro);
para recuperar tanto o livro quanto o leitor do banco de dados Leitor leitor = leitorDao.pesquisarPorId(idLeitor);
e assim associá-los ao empréstimo. FuncionarioBiblioteca funcionarioBiblioteca = usuarioLogadoBean
Como existe um relacionamento entre o usuário logado e o fun- .getUsuario().getFuncionarioBiblioteca();
emprestimo.setLivro(livro);
cionário ao qual o usuário pertence, recuperamos o funcionário livro.getEmprestimos().add(emprestimo);
da biblioteca através do usuário logado e também o associamos emprestimo.setLeitor(leitor);
ao empréstimo. Feitas as associações entre os objetos, persistimos emprestimo.setFuncionarioBiblioteca(funcionarioBiblioteca);
emprestimoDao.inserir(emprestimo);
o objeto que representa o empréstimo e, por fim, a lista de livros
livrosDisponiveis = livroDao.listarLivrosDisponiveisParaEmprestimo();
disponíveis é atualizada. Ao final, também é adicionada uma MensagemUtil.addMensagemInformativa(“Sucesso - “,
mensagem indicando que a operação foi realizada com sucesso, “Empréstimo realizado com sucesso!”);
a ser exibida na página. }
@Transacional
Criando a funcionalidade para devolução de livros public List<Livro> getLivrosDisponiveis() {
Uma das partes mais importantes do sistema, sem dúvidas, é a if(livrosDisponiveis == null){
livrosDisponiveis = livroDao.listarLivrosDisponiveisParaEmprestimo();
funcionalidade para devolução de livros. A página devolucao.xhtml }
(vide Listagem 4) juntamente com o managed bean Devolucao- return livrosDisponiveis;
Bean (vide Listagem 5) dão forma a esta funcionalidade. }
Explicaremos essa parte específica do sistema em duas etapas.
//demais métodos get e set omitidos...
Primeiro, iremos analisar os pontos mais importantes da página
devolucao.xhtml, e depois, passaremos à análise da classe Devo- }
lucaoBean.

Na página devolucao.xhtml (apresentada na Figura 2), por meio do leitor que pegou o livro emprestado, o nome do funcionário
dos componentes h:selectOneMenu e f:selectItems – explicados da biblioteca que realizou o empréstimo, a data do empréstimo
anteriormente –, é exibida uma lista de livros que se encontram e a data prevista para devolução e se existe multa a ser paga por
emprestados e são passíveis de devolução. Logo no início dessa atraso. Observe ainda que a edição dos valores dos campos é
lista, adicionamos uma opção em branco através do componente desabilitada através do atributo disabled=”true”.
f:selectItem. Pelo fato desta opção em branco já vir selecionada A partir desse ponto, passaremos a analisar o managed bean
ao carregar a página, o usuário é obrigado a selecionar na lista DevolucaoBean. Por se tratar de uma classe grande, quebramos
o livro que será devolvido, o que dispara a execução do método seu código em diferentes Listagens (da 5 a 12).
alteradoLivroSelecionado() presente no mana-
ged bean. Mas porque esse método é invocado
quando escolhemos algum livro? Veremos mais
detalhes adiante.
O mecanismo descrito no parágrafo anterior
– executar um determinado método a cada vez
que se escolhe um livro da lista – foi especifica-
do na tag f:ajax. Para isso, no atributo listener
dessa tag foi colocada a EL #{devolucaoBean
.alteradoLivroSelecionado}. Assim, toda vez
que escolhermos um item na lista de livros
emprestados, o método alteradoLivroSelecio-
nado() do nosso bean será invocado. Logo após,
o formulário da página será atualizado (rende-
rizado novamente), pois informamos seu id no
atributo render (render=“formDevolucao”) da
tag f:ajax.
Com esse mecanismo, ao selecionarmos qual-
quer livro na lista, os demais campos do for-
mulário serão preenchidos automaticamente e o
operador do sistema poderá visualizar os dados
relacionados àquele empréstimo, como o nome Figura 2. Conteúdo da página devolucao.xhtml
Listagem 4. Código da página devolucao.xhtml.
<?xml version=”1.0” encoding=”ISO-8859-1” ?> <h:inputText id=”emprestadoPara” value=”#{devolucaoBean.emprestimo

<!DOCTYPE html PUBLIC “-//W3C//DTD XHTML 1.0 Transitional//EN” .leitor.nome}” disabled=”true” />
“http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd”>
<html xmlns=”http://www.w3.org/1999/xhtml” <h:outputLabel value=”Emprestado por:” for=”emprestadoPor” />
xmlns:f=”http://java.sun.com/jsf/core” <h:inputText id=”emprestadoPor” value=”#{devolucaoBean.emprestimo
xmlns:h=”http://java.sun.com/jsf/html” .funcionarioBiblioteca.nome}” disabled=”true” />
xmlns:ui=”http://java.sun.com/jsf/facelets”>
<h:outputLabel value=”Data do empréstimo:” for=”dataEmprestimo” />
<ui:composition template=”/WEB-INF/_template.xhtml”> <h:inputText id=”dataEmprestimo” value=”#{devolucaoBean
<ui:define name=”corpo”> .dataEmprestimoFormatada}” disabled=”true” />
<h:form id=”formDevolucao”>
<h2> <h:outputLabel value=”Data prevista para devolução:” for=”dataPrevista” />
<h:outputText value=”Devolução” />
<h:inputText id=”dataPrevista” value=”#{devolucaoBean
</h2>
.dataPrevistaFormatada}” disabled=”true” />
<fieldset>

<legend>Dados da Devolução</legend>
<h:outputLabel value=”Multa por atraso:” for=”multa” />
<h:outputLabel value=”Escolher livro a devolver:” for=”livro” />
<h:inputText id=”multa” value=”#{devolucaoBean.multa}” disabled=”true” />
<h:selectOneMenu id=”livro” value=”#{devolucaoBean.idLivro}”>

<f:selectItem itemLabel=”” itemValue=”#{null}” />
<h:commandButton value=”Realizar Devolução”
<f:selectItems value=”#{devolucaoBean.livrosEmprestados}” var=”livro”
itemValue=”#{livro.id}” itemLabel=”#{livro.nome}” /> action=”#{devolucaoBean.realizarDevolucao}” />
<f:ajax listener=”#{devolucaoBean.alteradoLivroSelecionado}” </fieldset>
render=”formDevolucao” /> </h:form>
</h:selectOneMenu> </ui:define>
</ui:composition>
<h:outputLabel value=”Emprestado para:” for=”emprestadoPara” /> </html>

Listagem 5. Código do managed bean DevolucaoBean. Caso exista mais de um empréstimo vinculado ao livro, o que
vale é aquele que ainda não tem data de devolução, pois essa data
package br.com.javamagazine.mb;
só será atualizada quando a devolução for concretizada. Ainda
import java.math.BigDecimal; nesse método são recuperadas a data do empréstimo e a data
import java.time.LocalDate; prevista para devolução, formatadas e atribuídas às variáveis de
import java.time.format.DateTimeFormatter; instância dataEmprestimoFormatada e dataPrevistaFormatada,
import java.util.List;
import javax.enterprise.context.RequestScoped; para que possam ser exibidas na página. Em seguida é avaliado
import javax.inject.Inject; se a data atual é maior que a data prevista para o empréstimo,
import javax.inject.Named; e nesse caso é gerada uma multa de R$ 15,00. Para mantermos o
// restante dos imports omitidos
sistema simples, a multa não será persistida. Apenas será mostrada
@Named na tela para que seja cobrado algum valor pelo atraso.
@RequestScoped
public class DevolucaoBean {
@Inject Listagem 6. Código do método alteradoLivroSelecionado().
private LivroDao livroDao;
private Integer idLivro; public void alteradoLivroSelecionado(){
private List<Livro> livrosEmprestados; if(idLivro != null){
@Inject setarEmprestimo();
private EmprestimoDao emprestimoDao; DateTimeFormatter formatador = DateTimeFormatter.ofPattern(“dd/MM/yyyy”);
dataEmprestimoFormatada = emprestimo.getDataEmprestimo()
private Emprestimo emprestimo = new Emprestimo();
.format(formatador);
private String dataEmprestimoFormatada;
dataPrevistaFormatada = emprestimo.getDataPrevista().format(formatador);
private String dataPrevistaFormatada;
LocalDate dataAtual = LocalDate.now();
if(dataAtual.isAfter(emprestimo.getDataPrevista())){
private String multa = FormatadorDeNumeros.
multa = FormatadorDeNumeros.formatarBigDecimalComoMoeda
formatarBigDecimalComoMoeda(new BigDecimal(0.0d));
(new BigDecimal(15.0d));
}
//Código do método alteradoLivroSelecionado(), apresentado na Listagem 6 }else{
limparCampos();
//Código do método realizarDevolucao(), apresentado na Listagem 7 }
}
//Código do método setarEmprestimo(), apresentado na Listagem 8
//Código do método getLivroSelecionado(), apresentado na Listagem 9 O método principal da classe DevolucaoBean é o realizarDe-

volucao(), exposto na Listagem 7. Esse método primeiramente
//Código do método getEmprestimoDoLivroSelecionado(), apresentado
//na Listagem 10 invoca o setarEmprestimo(), que recupera o empréstimo asso-
ciado ao livro que foi selecionado para ser devolvido e o atribui à
//Código do método limparCampos(), apresentado na Listagem 11
variável de instância emprestimo. Nesse momento é atualizada
//Código do método getLivrosEmprestados(), apresentado na Listagem 12 a data de devolução desse empréstimo com a data atual. Em
seguida essa alteração no empréstimo é persistida no banco
//Métodos de acesso omitidos de dados através de uma classe DAO. Na sequência, a lista dos
} livros emprestados é atualizada para que o livro que acabou de
ser devolvido não apareça mais nela. Por fim, os campos são
limpos através de uma chamada ao método limparCampos()
Esse bean possui alguns métodos importantes que foram extra- e é adicionada uma mensagem informando ao usuário que a
ídos e serão explicados à parte. devolução foi realizada com sucesso. Repare também que o
Começaremos as explicações pelo método alteradoLivroSele- método é marcado com a anotação @Transacional, que criamos
cionado(), presente na Listagem 6. Este método será invocado no segundo artigo da série.
quando o usuário do sistema escolher algum livro na lista de Dando continuidade às explicações dos métodos, veremos a seguir
livros emprestados, que aparece na página devolucao.xhtml. Em como o setarEmprestimo() foi implementado – vide Listagem 8.
outras palavras, o método é chamado toda vez que alteramos a No início ocorre uma chamada a getLivroSelecionado(), que re-
seleção, ou seja, quando mudamos o livro que está selecionado. torna um objeto que representa o livro selecionado pelo usuário
Dentro dele é verificado se o conteúdo da variável idLivro está do sistema. Na próxima linha de código, o livro selecionado é
preenchido, o que significa que algum livro foi selecionado. Se o passado como argumento para o método getEmprestimoDoLi-
conteúdo da variável for nulo, significa que a opção em branco vroSelecionado(), que faz exatamente o que seu nome sugere e
da lista foi selecionada. Se algum livro foi selecionado, o método retorna o objeto empréstimo vinculado ao livro. Antes do método
setarEmprestimo() é chamado para atribuir o empréstimo vigente terminar, o objeto empréstimo que foi retornado é atribuído à
– representado por um objeto – relacionado àquele livro à variável variável membro emprestimo, para que possa ser utilizado em
de instância emprestimo. outros lugares da classe.

Listagem 7. Código do método realizarDevolucao(). lista de livros da página. Caso isso ocorra, os valores dos demais
campos do formulário também devem ficar em branco e nesse
@Transacional
caso limparCampos() é chamado para que esse resultado seja
public void realizarDevolucao(){
setarEmprestimo(); alcançado. Veja o código desse método na Listagem 11.
emprestimo.setDataDevolucao(LocalDate.now()); Para finalizarmos a análise dos métodos de DevolucaoBean, vere-
emprestimoDao.atualizar(emprestimo); mos a implementação de getLivrosEmprestados(). A Listagem 12
livrosEmprestados = livroDao.listarLivrosEmprestados();
exibe o código desse método que, como veremos, é bastante sim-
limparCampos();
MensagemUtil.addMensagemInformativa(“Sucesso - “,
ples. Através de uma chamada a listarLivrosEmprestados(), do
“Devolução realizada com sucesso!”); DAO, é recuperada a lista de livros emprestados e em seguida ela
} é atribuída à variável membro livrosEmprestados. Note ainda
que para que não seja feita uma nova invocação ao método do
Listagem 8. Código do método setarEmprestimo().
DAO caso a variável livrosEmprestados já esteja preenchida
private void setarEmprestimo(){ com a lista, foi colocado um if.
Livro livroSelecionado = getLivroSelecionado();
Emprestimo emprestimoDoLivroSelecionado =
getEmprestimoDoLivroSelecionado(livroSelecionado); Listagem 10. Código do método getEmprestimoDoLivroSelecionado().
emprestimo = emprestimoDoLivroSelecionado;
} private Emprestimo getEmprestimoDoLivroSelecionado(Livro livroSelecionado){
for(Emprestimo emprestimo : livroSelecionado.getEmprestimos()){
if(emprestimo.getDataDevolucao() == null){
return emprestimo;
Note que no parágrafo anterior mencionamos o método getLi- }
vroSelecionado(). Então vejamos agora a sua implementação }
(Listagem 9). Para entendermos a lógica desse método é necessário
relembrar que quando o usuário do sistema escolhe um livro, return null;
}
armazenamos seu id na variável idLivro. Como temos o id do
livro que foi selecionado, iteramos na lista de livros emprestados Listagem 11. Código do método limparCampos().
procurando pelo livro que tenha o mesmo id, e quando o encon-
private void limparCampos(){
tramos retornamos esse livro.
emprestimo = new Emprestimo();
dataEmprestimoFormatada = “”;
Listagem 9. Código do método getLivroSelecionado(). dataPrevistaFormatada = “”;
multa = FormatadorDeNumeros.formatarBigDecimalComoMoeda(new
private Livro getLivroSelecionado(){ BigDecimal(0.0d));
for(Livro livro : getLivrosEmprestados()){ }
if(livro.getId() == idLivro){
Listagem 12. Código do método getLivrosEmprestados().
return livro;
}
@Transacional
}
public List<Livro> getLivrosEmprestados() {

if(livrosEmprestados == null){
return null;
livrosEmprestados = livroDao.listarLivrosEmprestados();
}
}

return livrosEmprestados;
Seguindo com as explicações, analisaremos o código do método get- }
EmprestimoDoLivroSelecionado(), apresentado na Listagem 10.
Visando um melhor entendimento, antes de explicarmos o código
desse método, é válido mencionar que em nosso sistema um livro Antes de encerrarmos esse tópico sobre devolução de livros,
pode estar relacionado a vários empréstimos e o último emprésti- é interessante citar que nos locais onde é necessário formatar
mo realizado é aquele cuja data de devolução está nula. Essa data o valor da multa, o managed bean DevolucaoBean faz uso
permanece nula até o momento em que o livro é efetivamente do método formatarBigDecimalComoMoeda(), presente na
devolvido, e só então ela é atualizada. Dito isso, passemos à im- classe FormatadorDeNumeros. Esse método recebe um obje-
plementação do método em questão. Como podemos verificar, to do tipo BigDecimal e retorna uma String que representa
seu código consiste em iterar sobre os empréstimos do livro que o valor desse BigDecimal no formato da moeda do Brasil,
foi selecionado pelo usuário e retornar o último empréstimo acrescentando para isso o R$. Por exemplo, ao passarmos
realizado, que seria o empréstimo vigente. para o método new BigDecimal(15.0d), receberemos de volta
Outro ponto que deve ser previsto pelo desenvolvedor é a situa- “R$ 15,00”. A Listagem 13 mostra o código da classe e do
ção em que o usuário seleciona a opção em branco disponível na método em questão.

Listagem 13. Código da classe para formatação de números. dastro de funcionários e usuários, mas por enquanto ele consegue.
Para resolver esse problema dos acessos indevidos, vamos criar
package br.com.javamagazine.util;
uma classe que implemente a interface PhaseListener, da API
import java.math.BigDecimal; do JSF. Antes, no entanto, precisamos saber quais são as fases do
import java.text.DecimalFormat;
ciclo de vida do processamento de uma requisição feita a uma
import java.text.DecimalFormatSymbols;
import java.util.Locale; página JSF e entender cada uma delas, já que o uso da interface
public class FormatadorDeNumeros { PhaseListener tem relação direta com essas fases.

A Figura 3 mostra as seis fases do ciclo de vida. São elas:
public static String formatarBigDecimalComoMoeda(BigDecimal numero){
Locale localeBrasil = new Locale(“pt”,”BR”); • Restore view: é nessa fase que a árvore de componentes UI,
DecimalFormatSymbols moedaReal = new DecimalFormatSymbols chamada de view, é criada. No entanto, ela só será criada caso seja
(localeBrasil);
DecimalFormat df = new DecimalFormat(“¤ ###,###,##0.00”, moedaReal);
a requisição inicial à página JSF, caso contrário a view já existirá
return df.format(numero); e apenas será restaurada;
} • Apply request values: nessa fase os valores vindos por parâme-

}
tros na requisição são atribuídos a cada componente da árvore;
• Process validations: é nesta etapa que são processados todos os
validadores associados aos componentes da árvore;
Evitando acessos indevidos com PhaseListener • Update model values: se não ocorreu nenhum erro de validação
A aplicação está quase finalizada, porém, nesse momento, ela tem nem conversão nas etapas anteriores, isso significa que os valores
um problema que precisa ser corrigido. Da forma que está, ela per- são válidos. Então são passados dos componentes para as proprie-
mite que o usuário acesse qualquer página através da URL mesmo dades do managed bean, o que ocorre neste momento;
sem estar logado. E mesmo que o usuário tenha se logado, se ele • Invoke application: depois do modelo ter sido atualizado na
não for administrador, não deveria poder acessar a página de ca- fase anterior, nessa fase são tratados os eventos disparados pelo

usuário (por exemplo, se ele clicou em algum botão) e executadas Dentro do método afterPhase() está toda a lógica que pre-
as regras de negócio; vine os acessos indevidos. Primeiramente, verificamos se o
• Render response: por fim, nesta fase será renderizada a resposta usuário já se logou no sistema. Caso ele esteja logado e seja
para o usuário. administrador, poderá acessar qualquer página, mas caso não
seja administrador, não poderá acessar o cadastro de funcio-
Uma classe que implemente a interface PhaseListener será nários e usuário e se ele tentar, será direcionado para a página
notificada antes e depois do processamento de cada uma dessas menu_principal.xhtml.
fases do ciclo de vida de uma requisição JSF,
ou podemos escolher apenas a fase que nos
interessa. Para o nosso exemplo, só interessa
sermos notificados antes e depois do proces-
samento da fase Restore view. Sendo assim,
criaremos uma classe chamada Autorizador,
que implementará PhaseListener (veja seu
código na Listagem 14).
Note que sobrescrevemos os métodos befo-
rePhase() e afterPhase(), porém todo o nosso
código ficou no afterPhase() e deixamos o
beforePhase() vazio. Isso porque antes da fase
Restore view, a chamada ao método context
.getViewRoot() retorna null, e não conse-
guiríamos utilizar context.getViewRoot()
.getViewId() para descobrir a página que o
usuário estaria tentando acessar. E também
foi sobrescrito o método getPhaseId(), onde
podemos informar qual fase do ciclo de vida
nos interessa para sermos notificados. Figura 3. Ciclo de vida de uma requisição JSF
Listagem 14. Código do PhaseListener Autorizador.
package br.com.javamagazine.listeners; if(“/funcionario_biblioteca.xhtml”.equals(context.getViewRoot().

getViewId()) && !usuarioLogado.getUsuario().isAdmin()){
import javax.faces.context.FacesContext; navegador.redirecionar(“menu_principal”);
import javax.faces.event.PhaseEvent; }
import javax.faces.event.PhaseId; }else {
import javax.faces.event.PhaseListener; if(“/login.xhtml”.equals(context.getViewRoot().getViewId())){
import javax.inject.Inject; return;
}
import br.com.javamagazine.mb.FuncionarioEUsuarioVerificadorBean; if(“/funcionario_biblioteca.xhtml”.equals(context.getViewRoot().
import br.com.javamagazine.mb.UsuarioLogadoBean; getViewId()) && !verificadorBean.existeFuncionarioEUsuarioCadastrado()){
import br.com.javamagazine.util.Navegador; return;
}
public class Autorizador implements PhaseListener {
navegador.redirecionar(“login”);
private static final long serialVersionUID = 1L; }
@Inject }
private UsuarioLogadoBean usuarioLogado;
@Inject @Override
FacesContext context; public void beforePhase(PhaseEvent event) {
@Inject // não é necessário fazer nada antes da fase Restore View
private Navegador navegador; }
@Inject
private FuncionarioEUsuarioVerificadorBean verificadorBean; @Override
public PhaseId getPhaseId() {
@Override return PhaseId.RESTORE_VIEW;
public void afterPhase(PhaseEvent event) { }

if(usuarioLogado.isLogado()){ }

A outra situação ocorre se o usuário ainda não estiver auten- Autor

ticado. Nesse caso, ele não poderá acessar nenhuma página do
sistema, com exceção da página de login, obviamente, e da página Bruno Rafael Sant’ Ana
de cadastro de funcionários e usuários, desde que ainda não exista [email protected]
Graduado em Análise e Desenvolvimento de Sistemas pelo
nenhum funcionário e nenhum usuário cadastrados. Se ele tentar
SENAC. Possui as certificações OCJP e OCWCD. Atualmente tra-
acessar qualquer página diferente dessas duas, será direcionado
balha na Samsung com desenvolvimento Java e atua como CTO na startup
para a página de login. Vesteer. Entusiasta de linguagens de programação e tecnologia.
Por fim, para que os métodos da classe Autorizador sejam re-
almente chamados antes e depois da fase Restore view, devemos
registrá-la no arquivo faces-config.xml, conforme o código da Links:
Listagem 15. Assim concluímos a implementação da aplicação
exemplo, que agora já se encontra 100% funcional. Aplicação reduzida (igual a desenvolvida no artigo) no GitHub.
https://github.com/brunosantanati/javamagazine-app-reduzida
Listagem 15. Código do arquivo faces-config.xml.
Aplicação completa no GitHub.
<?xml version=”1.0” encoding=”UTF-8”?> https://github.com/brunosantanati/javamagazine-app-completa
<faces-config
xmlns=”http://xmlns.jcp.org/xml/ns/javaee” Endereço para download do JDK 8.
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
http://www.oracle.com/technetwork/pt/java/javase/downloads/index.html
xsi:schemaLocation=”http://xmlns.jcp.org/xml/ns/javaee
http://xmlns.jcp.org/xml/ns/javaee/web-facesconfig_2_2.xsd”
version=”2.2”> Endereço para download do Eclipse Luna.
https://www.eclipse.org/downloads/
<lifecycle>
<phase-listener> Endereço para download JBoss WildFly.
br.com.javamagazine.listeners.Autorizador
</phase-listener>
http://wildfly.org/downloads/
</lifecycle>
Endereço para download do instalador do MySQL.
</faces-config> http://dev.mysql.com/downloads/installer/
Endereço para download do driver do MySQL.

Após essas últimas explicações, o leitor estará apto a iniciar o http://dev.mysql.com/downloads/connector/j/
desenvolvimento de aplicações web usando JSF. Ainda assim,
existem muitos assuntos igualmente interessantes que devem
Você gostou deste artigo?
ser estudados pelo leitor para que seja possível desenvolver uma
aplicação completa. Visando simplificar/direcionar este caminho,
Dê seu voto em www.devmedia.com.br/javamagazine/feedback
aconselhamos estudos mais aprofundados sobre JPA, CDI e o
próprio JSF, todos já explorados com grande riqueza de detalhes Ajude-nos a manter a qualidade da revista!
em artigos publicados em outras edições da Java Magazine.
Bons estudos!

Dominando o Java
Collections Framework
e Generics
Conheça a API de coleções do Java e entenda o
papel dos genéricos na criação de código seguro
É Fique por dentro

muito comum escrevermos programas que se
comuniquem passando informações através de
objetos. Mas quando precisamos enviar vários Na linguagem Java existem diversos objetos que servem como con-
objetos para serem processados, torna-se dispendioso tainers de outros objetos, prontos para serem utilizados, facilitando a
fazer o seu envio de forma individual. Melhor seria manipulação e a passagem de informação entre métodos e aplicações.
fazer um único envio de vários objetos agrupados e Estes containers, ou coleções de objetos, possuem funcionalidades
receber uma única resposta, ou uma série de respos- que nos permitem executar as operações básicas que precisamos para
tas agrupadas em um único objeto. Pensando nisso, o seu manuseio, como a inserção, a remoção e a ordenação de dados.
a plataforma Java nos disponibiliza um framework Uma característica muito importante destas estruturas de dados é a
de Collections. flexibilidade que existe sobre o formato dos dados que podem ser
Uma coleção, também designada de container, é um manuseados, pois não ficamos limitados a guardar um determinado
simples objeto que agrupa múltiplos objetos (conhecidos tipo específico de objeto. Por outro lado, de forma a podermos utilizar
como elementos da coleção) numa só unidade. Estas co- vários tipos de objetos de maneira segura, a linguagem Java introdu-
leções são utilizadas para guardar, retornar, manipular ziu o conceito de genéricos, que nos permite fazer operações com
e transmitir dados agregados de maneira simples e estão objetos de vários tipos com “type safety” em tempo de compilação.
disponíveis no framework de Collections do Java, que Com base nisso, vamos ver neste artigo como está construída e como
possui uma arquitetura unificada e criada para permitir podemos utilizar a plataforma de coleções e genéricos da linguagem
que coleções sejam manipuladas de forma independente Java, recursos empregados em qualquer aplicação.
dos detalhes de suas implementações.
As principais vantagens do framework de Collections são:
• Reduz o esforço de programação, fornecendo estrutu-
ras de dados e algoritmos de modo que não tenhamos • Promove a reutilização de software, com interfaces padrão para
que escrevê-los; coleções e algoritmos de dados.
• Por fornecer implementações de estruturas de dados e
algoritmos de alto desempenho, viabiliza um aumento A API Collections
de performance; Para podermos usufruir de todas estas vantagens, temos
• Proporciona interoperabilidade entre APIs não rela- disponível na linguagem Java vários tipos de objetos que
cionadas, ao estabelecer uma linguagem comum para implementam diversos tipos diferentes de coleções. Cada tipo
passar informações através de coleções; de coleção tem suas características específicas e, de forma a
• Reduz o esforço necessário para aprender sobre as organizá-las, a API de coleções do Java foi dividida em inter-
APIs, já que as coleções que nos são disponibilizadas são faces que agrupam as classes das implementações em um dos
comuns em várias linguagens de programação; seguintes tipos:

• Collection: É a raiz da hierarquia das coleções. Define um agru- Temos ainda duas interfaces de coleção, a SortedList e a Sor-
pamento de objetos, denominados de elementos. As suas imple- tedMap, que são meramente versões classificadas/ordenadas
mentações determinam quando existe ou não ordenação e quando das interfaces Set e Map, respectivamente (neste ponto há uma
é possível ou não fazer a inserção duplicada de elementos; “confusão” sobre a palavra ordenada que será explicada a seguir).
• Set: Uma coleção onde não são permitidas inserções de elemen- Não vamos detalhar estas interfaces porque o mais importante
tos repetidos e onde seus elementos não são ordenados. Deste agora é entender o conceito de cada estrutura (Set, List, Queue,
modo, não existe pesquisa através de índices; Deque e Map) e não as suas variações.
• List: Uma coleção ordenada, onde são permitidas inserções A Figura 1 nos mostra a hierarquia das principais interfaces que
duplicadas. Os elementos podem ser inseridos em uma posição es- implementam Collection e a interface Map.
pecífica, o que permite fazer pesquisas através de índices. Na sua
essência, pode ser visto como um array de tamanho variável; Ordernado e classificado
• Queue: Esta interface define uma estrutura de fila, que tipi- Ao explicar as estruturas SortedList e SortedMap, surgiu a
camente (mas não necessariamente) guarda seus elementos na questão sobre um problema de tradução entre o português e o
ordem em que foram inseridos. Ela define o sistema conhecido inglês que muitas vezes causa confusão nas pessoas, o que nem
como “first-in, first out”, onde os elementos são inseridos no fim sempre é explicado da melhor forma nas documentações em por-
da fila e removidos do seu início; tuguês. Anteriormente foi comentado que as implementações de
• Deque: Do inglês “Double Ended QUEue”, representa uma fila Set não são ordenadas e as de List são, e posteriormente foi dito
com duas terminações. Enquanto uma queue apenas permite in- que SortedList e SortedMap são implementações classificadas/
serções no fim da fila e remoções do seu início, um deque permite ordenadas das estruturas List e Map. Mas, por que dissemos
que inserções e remoções sejam feitas no início e no fim da fila, classificadas/ordenadas e não apenas ordenadas?
ou seja, um objeto que implemente Deque pode ser usado tanto
como uma fila FIFO (first-in, first-out), quanto uma fila LIFO
Listagem 1. Exemplo com operações de coleções que existem num objeto do tipo
(last-in, first-out). Map.
A interface Map 01 public static void testHashTable() {

02 Map<String, String> m = new Hashtable<>();
A interface Map representa um tipo abstrato de coleções de 03 m.put(“J”, “José”);
objetos e uma instância de uma classe que implemente esta 04 m.put(“M”, “Miguel”);
interface é um objeto que mapeia chaves a valores, ou seja, para 05 m.put(“B”, “Bruno”);
uma determinada chave (única) existe um valor (único) associado. 06 m.put(“F”, “Fernando”);
07 m.put(“A”, “Alex”);
Assim sendo, um Map não pode ter chaves repetidas e cada chave
08
está associada a, no máximo, um valor. 09 System.out.println(“Key set: “ + m.keySet().toString());
Mas, se Map é vista como uma coleção, então porque não estende 10 System.out.println(“Entry set: “ + m.entrySet().toString());
a interface Collection? Esta é uma opção de desenho dos desenvol- 11 System.out.println(“Values: “ + m.values().toString());
vedores da linguagem Java, que consideraram que Maps não são 12 }
coleções e coleções não são Maps. Maps são pares de chave-valor, -- Output:
que não se encaixam na definição de coleções, que são constituí- Key set: [A, J, F, B, M]
das por elementos simples. No entanto, ao mesmo tempo, podem Entry set: [A=Alex, J=José, F=Fernando, B=Bruno, M=Miguel]
ser vistas como coleções de chaves/valores, ou pares, e este fato Values: [Alex, José, Fernando, Bruno, Miguel]
é refletido nas suas operações de coleções, a saber: keySet(), que

retorna uma estrutura Set com as
chaves de mapeamento dos objetos
contidos na estrutura Map; entrySet(),
que retorna uma estrutura Set com os
pares de chave-valor dos mapeamentos
do objeto Map; e values(), que retorna
uma estrutura do tipo Collection com
todos os valores do mapeamento.
A Listagem 1 mostra um exemplo de
código que cria um objeto Hashtable,
que implementa a interface Map e
mostra as operações de coleções que
Map possui com seus respectivos
outputs. Figura 1. Hierarquia das principais interfaces que implementam Collection

Dominando o Java Collections Framework e Generics
Este problema de linguagem acontece porque no inglês existem de balanceamento, o que faz com que a ordem de inserção não
palavras que significam coisas distintas, mas que são traduzidas seja mantida. Desta forma, é feita uma nova ordenação dos seus
da mesma forma para o português. No caso do nosso problema, dados, o que chamaremos de classificação dos elementos. Assim,
as palavras são ordered e sorted. Ambas podem ser traduzidas vamos denominar este tipo de estrutura de dados de estruturas
para ordenado em português. De forma a tentarmos resolver ordenadas/classificadas. No caso do exemplo, a classificação/
este conflito, vamos traduzir ordered para ordenado e sorted para ordenação dos elementos foi feita por ordem alfabética porque
classificado, para entendermos o que cada uma significa. criamos uma TreeSet de Strings (Set<String>), mas podemos
Quando dissermos que uma estrutura é ordenada, é porque implementar uma árvore com qualquer tipo de classificação/
a ordem de inserção dos elementos é mantida, como acontece ordenação que pretendermos.
nas listas e arrays. Quando dissermos que uma estrutura é
classificada, queremos dizer que um elemento será inserido Implementações das coleções
numa determinada posição da estrutura de acordo com a regra Agora que já vimos as interfaces do framework Collections, va-
de ordenação da mesma, por exemplo: por ordem (classificação) mos conhecer as classes que implementam estas interfaces no Java.
alfabética, numérica, etc. Como você poderá notar, temos disponíveis diversas implementa-
Vejamos um exemplo para ajudar na compreensão destas dife- ções e essas classes tipicamente têm os nomes no formato <estilo de
renças. A Listagem 2 mostra a iteração sobre os elementos de uma implementação><interface>. Por exemplo, a classe ArrayList possui
lista, sobre os elementos de um HashSet e sobre os elementos de o estilo de implementação em Array e implementa a interface List.
um Set. No fim, é mostrado o output dos testes realizados para A Tabela 1 sumariza estas classes.
validarmos os resultados. As implementações de uso geral, ou seja, aquelas que respondem
Como podemos ver pela saída gerada ao executarmos esse códi- melhor a um maior número de casos de uso, que podemos ver na
go, a lista manteve a ordem dos elementos que foram inseridos no Tabela 1, suportam todas as operações opcionais das interfaces e
input; logo, é uma estrutura de dados ordenada, ou que mantém não têm restrições sobre os tipos de elementos que podem conter
a ordem. O HashSet, por sua vez, não é uma estrutura ordena- (vamos falar sobre este assunto mais à frente, no tópico sobre Ge-
da. Isso quer dizer que se fizermos uma iteração sobre os dados nerics). Estas implementações não são sincronizadas, ou seja, não
que foram inseridos, não teremos como garantir a sua ordem, suportam o uso concorrente por mais que uma thread de forma
como visto no exemplo, pois esta depende do valor do hash de segura, mas a classe Collections contém wrappers de sincroni-
cada objeto, assim como do tamanho do array de dispersão. Por zação que podem ser usados para torná-las sincronizadas, caso
último, TreeSet ordena os dados segundo um algoritmo binário seja necessário (veremos um exemplo mais à frente).
Listagem 2. Exemplos para distinção entre as palavras sorted e ordered.
01 public static void testList() { 30 System.out.println();

02 List<String> l = new LinkedList<>(); 31 }
03 l.add(“José”); 32
04 l.add(“Miguel”); 33 public static void testTreeSet() {
05 l.add(“Bruno”); 34 Set<String> s = new TreeSet<>();
06 l.add(“Fernando”); 35 s.add(“José”);
07 l.add(“Alex”); 36 s.add(“Miguel”);
08 37 s.add(“Bruno”);
09 Iterator<String> i = l.iterator(); 38 s.add(“Fernando”);
10 System.out.print(“List: “); 39 s.add(“Alex”);
11 while (i.hasNext()) { 40
12 System.out.print(i.next() + “ “); 41 Iterator<String> i = s.iterator();
13 } 42 System.out.print(“TreeSet: “);
14 System.out.println(); 43 while (i.hasNext()) {
15 } 44 System.out.print(i.next() + “ “);
16 45 }
17 public static void testHashSet() { 46 System.out.println();
18 Set<String> s = new HashSet<>(); 47 }
19 s.add(“José”); 48 public static void main(String[] args) {
20 s.add(“Miguel”); 49 System.out.println(“Input: José Miguel Bruno Fernando Alex”);
21 s.add(“Bruno”); 50 testList();
22 s.add(“Fernando”); 51 testHashSet();
23 s.add(“Alex”); 52 testTreeSet();
24 53 }
25 Iterator<String> i = s.iterator(); -- Output:
26 System.out.print(“HashSet: “); Input: José Miguel Bruno Fernando Alex
27 while (i.hasNext()) { List: José Miguel Bruno Fernando Alex
28 System.out.print(i.next() + “ “); HashSet: José Miguel Fernando Bruno Alex
29 } TreeSet: Alex Bruno Fernando José Miguel

Interface Hash Table Resizable Array Balanced Tree Linked List Hash Table + Linked List Que implementação de List escolher?
Set HashSet TreeSet LinkedHashSet No caso das implementações de List, a sua melhor
List ArrayList LinkedList implementação para uso geral é a ArrayList, devido a
Deque ArrayDeque LinkedList
sua melhor performance em relação à LinkedList. Va-
mos analisar cada uma das estruturas individualmente
Map HashMap TreeMap LinkedHashMap
para entender o porquê.
Tabela 1. Implementações das interfaces do framework Collections Um ArrayList, como o próprio nome indica, é uma
lista em array. Sendo assim, podemos ter acesso di-
Nota reto aos seus elementos através do índice e podemos adicionar
Como os tipos Deque e List implementam Queue e possuem os conceitos de fila, não há necessidade e remover elementos de forma eficiente apenas no fim da fila,
de ter as implementações de Queue na Tabela 1. porém, caso seja necessário aumentar o seu tamanho, o custo
será alto, já que todo o array será copiado para um novo com
maiores dimensões.
Como escolher o tipo de coleção mais adequado? Já uma LinkedList, como o nome indica, é uma lista ligada de
Tão importante quanto conhecer os tipos de coleções que elementos. Para ser mais preciso, a implementação é feita como
temos disponíveis, é saber qual o tipo de coleção mais apro- uma lista duplamente ligada, ou seja, cada elemento sabe quem é o
priado para o que queremos fazer. Para definir o tipo de próximo e quem é o anterior. Sendo assim, temos que as inserções
coleção que devemos usar, nos baseamos nas suas caracterís- e remoções são mais caras em termos de performance, já que cada
ticas de ordenação e a capacidade de inserção de elementos inserção/remoção exige um maior número de operações em cada
repetidos. elemento a ser guardado/removido, pois é necessário informar a
Uma importante regra a ter em mente é: Não devemos es- cada célula qual o elemento que lhe sucede e qual o seu elemento
colher uma classe que implemente recursos que não sejam anterior. No caso das listas ligadas, o primeiro e último elementos
necessários para o que pretendemos! É provável que tenha- podem ser acessados de maneira direta, mas os restantes terão
mos que pagar por esses recursos com custos que nos causem um custo linear, já que para acessarmos um elemento na posição
perda de eficiência. Então, devemos levar em consideração N da lista, temos que passar por todos os elementos de 0 até N-1,
apenas os recursos que realmente necessitamos. Por exem- ou seja, o acesso não pode ser feito diretamente através do índice.
plo, algumas coleções ordenam automaticamente os dados O maior benefício desta estrutura de dados vem do fato de que as
no momento em que são adicionados. Se precisarmos que os listas ligadas têm um crescimento dinâmico, isto é, podem crescer
dados sejam ordenados, geralmente é mais eficiente escolher indefinidamente, sem a necessidade de realocação dos dados, e
uma coleção que já insira os dados de forma ordenada do que as inserções e remoções feitas no meio da lista também são mais
usar uma coleção sem ordenação e depois efetuar a ordenação rápidas, pelo mesmo motivo. A Tabela 2 faz um resumo da com-
no momento que desejarmos. Por outro lado, se não precisa- plexidade das principais operações em uma lista, comparando as
mos que os dados estejam ordenados, então é mais eficiente duas estruturas: ArrayList e LinkedList.
adotarmos uma coleção que não seja ordenada.
Com essas informações, vejamos novamente o tópico “A API Operação ArrayList LinkedList
Collections” no início deste artigo. Se precisarmos de uma get(int index) O(1) O(n)
coleção que não permita a inserção de elementos duplicados add(E element) O(1) O(1)
e onde seus elementos não são inseridos de forma ordenada, add(int index, E element) O(n) O(n)
optaremos por uma implementação do tipo genérico Set. remove(int index) O(n) O(n)
Por outro lado, se precisarmos de uma coleção que permita
Iterator.remove() O(n) O(1)
a inserção de elementos repetidos e onde os seus elementos
ListIterator.add(E element) O(n) O(1)
são inseridos de maneira a manter a ordem de inserção,
optaremos por uma implementação do tipo List. No caso Tabela 2. Complexidade das operações em uma lista
de precisarmos de uma coleção ordenada em fila, onde
queiramos usar uma implementação do tipo “first-in, first- Novamente, num caso de uso geral, um ArrayList conseguirá
out”, podemos optar pelos tipos Queue ou Deque. No caso satisfazer nossas necessidades de maneira mais eficiente. Por
de precisarmos manipular elementos no fim da fila, então outro lado, no caso de não sabermos antecipadamente o número
teremos que optar por uma implementação de Deque. Por aproximado de elementos que a lista terá, existindo a possibili-
último, caso pretendamos guardar dados do tipo chave-valor, dade de a lista ter que crescer muito e várias vezes, ou no caso de
usaremos uma implementação do tipo Map. necessitarmos de alterações constantes no meio da lista, a melhor
Até aqui a escolha parece bastante simples e clara. Mas opção será uma LinkedList.
tendo escolhido qual o tipo de coleção que precisamos, como Também devemos ter atenção ao fato que nenhuma das listas
escolher qual a melhor implementação deste tipo? mencionadas são sincronizadas.

Isso quer dizer que, no caso de acesso concorrente por mais que sobre LinkedList, pelos mesmos motivos que foram explicados no
uma thread, devemos optar por uma implementação que garanta caso da escolha da melhor estrutura que implementa a interface
esse acesso com segurança ou, como informado anteriormente, List. ArrayDeque é uma estrutura baseada em array (mais efi-
utilizar um wrapper de sincronização fornecido pela classe ciente) e a LinkedList é uma estrutura de lista duplamente ligada
Collections na estrutura de lista escolhida, como nos mostra o (mais dinâmica, mas menos eficiente).
código a seguir:
Que implementação de Map escolher?
List<String> l = Collections.synchronizedList(new ArrayList<String>()); Do mesmo modo que foi explicado nas implementações de
Queue, o caso da interface Map é muito semelhante ao da escolha
Um wrapper nos permite adotar uma estrutura que já conhece- da implementação de estruturas Set, como podemos verificar na
mos, e com isso evita o trabalho de termos que procurar por uma Tabela 1. Deste modo, para estruturas de dados do tipo Map,
nova implementação para um caso específico. a melhor implementação para uso geral é a LinkedHashMap,
por ser mais flexível que uma HashMap e mais rápida que uma
Que implementação de Set escolher? TreeMap. Para mais detalhes sobre esta explicação, veja o tópico
No caso da estrutura de dados do tipo Set, a melhor implemen- “Que implementação de Set escolher?”.
tação para uso geral é a LinkedHashSet, por ser mais flexível que
uma HashSet e mais rápida que uma TreeSet. Ordenação de coleções de dados
No entanto, vamos começar nossa análise pela HashSet. Esta Uma das ações mais comuns que temos que fazer com uma cole-
collection é implementada usando uma Hashtable e pode ser ção de dados é ordenar os elementos nela contidos. Para nos ajudar
vista, basicamente, como uma Hashtable onde só existem chaves. neste sentido, a linguagem Java disponibiliza duas opções para
Logo, não existem elementos duplicados. Por ser baseada nesta ordenarmos uma coleção: através da implementação da interface
estrutura de dados que é organizada por um array de dispersão, Comparable, por parte dos objetos a serem guardados numa cole-
os seus elementos não são ordenados. Ademais, os métodos add(), ção, ou através da implementação da interface Comparator, num
remove() e contains() são de complexidade constante O(1), o que objeto de comparação que serve apenas para este fim.
é o melhor caso em termos de eficiência. A interface Comparable transmite ordenação natural para
Os objetos do tipo TreeSet são implementados numa estrutura classes que a implementam. Esta interface especifica uma re-
de árvore binária balanceada, utilizando o algoritmo de árvores lação de ordem, que também pode ser usada para substituir a
preta-vermelha, para ser mais preciso. Os seus elementos são ordenação natural.
ordenados e, por ser uma árvore ordenada binária, significa Vejamos um exemplo para ilustrar essa informação. Para isso,
que os métodos básicos add(), remove() e contains() possuem suponha que precisamos de uma classe para representar um
complexidade logarítmica O(log(n)), o que é pior que o caso de estudante, onde apenas necessitamos saber qual o seu nome, a
complexidade constante O(1), mas melhor que o caso de comple- idade e uma nota que o estudante tenha no estabelecimento de
xidade linear O(N). Apesar de ter uma maior complexidade que ensino. Neste cenário, sabemos que iremos manusear coleções de
a estrutura anterior, ela nos oferece funcionalidades para lidar estudantes e que precisaremos listar os estudantes destas coleções
com conjuntos classificados, como retornar o primeiro ou último pela ordem alfabética dos seus nomes. Dito isso, a Listagem 3
elemento da classificação e listar os dados de forma classificada, apresenta um exemplo de implementação desta classe.
da maneira que acharmos mais conveniente através da implemen- Como podemos verificar, a classe Student implementa a interface
tação da interface Comparable ou através de um Comparator. Comparable. Sendo assim, deve implementar o método compare-
Por fim, uma LinkedHashSet é implementada com uma Hashta- To(), que é quem viabiliza a ordenação natural a instâncias desta
ble e uma lista duplamente ligada (LinkedList) sobre os elementos classe. Neste exemplo, este método apenas usa o compareTo() da
contidos em sua Hashtable. Isso quer dizer que temos a vantagem classe String, já que esta classe também implementa a interface
de ter a complexidade constante na utilização dos métodos básicos, Comparable. Logo, temos que a ordenação natural de um estu-
como temos na HashSet (com um ligeiro comprometimento de- dante é estabelecida pela ordem alfabética do seu nome.
vido à adição da lista ligada), mas ao mesmo tempo conseguimos Vamos ver o que isso quer dizer observando o resultado desta
manter a ordem de inserção dos objetos através da ligação feita implementação através de um método de testes que cria uma
pela LinkedList. Por estar num meio termo entre a eficiência e a coleção ordenada e depois itera sobre seus elementos. Para isso,
flexibilidade de utilização, esta é a implementação que geralmente adotamos a opção TreeSet, já que precisamos apenas ordenar e
satisfaz mais casos de uso para estruturas do tipo Set. iterar sobre a lista. A Listagem 4 mostra o nosso código de teste
e o respectivo output.
Que implementação de Queue escolher? Ótimo! Como podemos constatar, inserimos os alunos aleato-
O caso da Queue é semelhante ao da List, como podemos ver riamente, com os nomes não ordenados e o output nos mostra a
pela Tabela 1. Assim sendo, a melhor implementação para uso lista de alunos ordenados alfabeticamente pelos nomes, mas o
geral de filas é a ArrayDeque, devido a sua melhor performance que aconteceu com os alunos com o mesmo nome?

Por que aparece apenas um aluno com o nome Bruno? Se relem- Os três objetos com nome de Bruno não são o mesmo objeto, mas
brarmos o que foi dito sobre as coleções de Set, vamos ver que Set num Set, um objeto é igual ao outro se o método compareTo() da
é “Uma coleção onde não são permitidas inserções de elementos classe de elementos que são inseridos na coleção retornar o valor 0.
repetidos”. Mas o que é um elemento repetido? Como estamos apenas comparando os nomes dos alunos, todos
os objetos Student com o mesmo nome serão considerados como
Listagem 3. Classe que representa um estudante e implementa a interface sendo o mesmo elemento a ser inserido. Como as coleções Set não
Comparable. permitem inserções duplicadas, apenas o primeiro objeto com o
nome Bruno é inserido.
01 package Collections;
02 Deste modo, vamos melhorar o nosso algoritmo de ordenação
03 public class Student implements Comparable<Student> { para fazer com que alunos com o mesmo nome não sejam consi-
04 private String _name;
05 private int _age;
derados iguais. Para isso, iremos comparar todos os seus membros
06 private int _score; de classe, ou seja, vamos comparar os alunos por nome, idade e
07 pontuação. A ordem com que as regras do algoritmo de compa-
08 public Student(String name, int age, int score) {
09 _name = name; ração são feitas é muito importante, pois ela vai decidir qual a
10 _age = age; ordenação no output da iteração na lista.
11 _score = score; Decidimos então que um aluno deve ser ordenado primeiro
12 }
13 pelo seu nome, em ordem alfabética, depois pela sua nota, em
14 @Override ordem decrescente, ou seja, da maior nota para a menor, e depois,
15 public String toString() {
por sua idade, por ordem crescente. A Listagem 5 nos mostra
16 return “Name: “ + _name + “ Age: “ + _age + “ Score: “ + _score;
17 } a alteração que precisamos fazer no método compareTo() da
18 classe Student para conseguirmos adicionar estas regras e seu
19 @Override
respectivo output.
20 public int compareTo(Student student) {
21 return _name.compareTo(student.getName());
22 }
Listagem 5. Alteração das regras do método compareTo() da classe Student.
23
24 public String getName() {
01 @Override
25 return _name;
02 public int compareTo(Student student) {
26 }
03 if (!_name.equalsIgnoreCase(student.getName())) {
27
04 return _name.compareTo(student.getName());
28 public int getAge() {
05 }
29 return _age;
06 else if (_score != student.getScore()) {
30 }
07 return student.getScore() - _score;
31
08 }
32 public int getScore() {
09 else {
33 return _score;
10 return _age - student.getAge();
34 }
11 }
35
12 }
36 }
-- Output:
Listagem 4. Código de teste para iteração sobre uma lista ordenada de alunos.
Name: Alex Age: 28 Score: 78
Name: Bruno Age: 26 Score: 82
01 public static void testComparable() {
02 Set<Student> set = new TreeSet<>();
03 set.add(new Student(“José”, 34, 100));
Name: Fernando Age: 30 Score: 80
04 set.add(new Student(“Miguel”, 32, 94));
Name: José Age: 34 Score: 100
05 set.add(new Student(“Bruno”, 36, 56));
Name: Miguel Age: 32 Score: 94
08 set.add(new Student(“Fernando”, 30, 80));
09 set.add(new Student(“Alex”, 28, 78)); Como podemos verificar, agora temos todos os alunos inseridos
10 na ordem que desejávamos. Para alcançarmos este resultado,
11 Iterator<Student> it = set.iterator();
12 while (it.hasNext()) { alteramos o método compareTo() para validarmos se um campo
13 System.out.println(it.next()); é diferente do mesmo campo de outro objeto da mesma classe e,
14 } se for, então retornamos o resultado de sua comparação.
15 }
Em primeiro lugar, ordenamos o nome através do método com-
-- Output: pareTo() da classe String, que, como vimos, nos ordena as strings
Name: Alex Age: 28 Score: 78
por ordem alfabética crescente. Em segundo lugar, comparamos
Name: Fernando Age: 30 Score: 80 as notas dos alunos, devolvendo a nota do aluno a ser comparado
Name: José Age: 34 Score: 100 menos a nota do aluno atual. Se a nota do aluno a ser comparado
for maior que a nota do aluno atual, então o resultado será um

número positivo, ou seja, este aluno virá depois que o aluno com- Listagem 7. Exemplo de utilização da classe para comparação da idade dos
parado. Explicando de outra maneira, se o resultado do método alunos.
compareTo() for igual a 0, isso significa que os dois objetos são 01 public static void testComparable() {
iguais. Se o resultado for menor do que 0, significa que o objeto 02 Comparator<Object> csa = new CompareStudentAge();
é “menor” (vem antes) que o objeto comparado, e se o resultado 03 Set<Student> set = new TreeSet<>(csa);
04
for maior do que 0, significa que o objeto é “maior” (vem depois)
05 set.add(new Student(“José”, 34, 100));
que o objeto comparado. 06 set.add(new Student(“Miguel”, 32, 94));
Caso analisemos com atenção a comparação da idade do aluno, 07 set.add(new Student(“Bruno”, 36, 56));
vamos notar que invertemos a ordem de comparação para con- 08 set.add(new Student(“Bruno”, 30, 56));
seguirmos um resultado por ordem crescente, ou seja, se a idade 10 set.add(new Student(“Fernando”, 30, 80));
do aluno atual for menor que a idade do aluno a ser comparado, 11 set.add(new Student(“Alex”, 28, 78));
então o resultado será negativo, o que quer dizer que o aluno 12
13 Iterator<Student> it = set.iterator();
atual é “menor” (vem antes) que o aluno a ser comparado. Para
14 while (it.hasNext()) {
alterarmos a ordem de crescente para decrescente, basta modificar 15 System.out.println(it.next());
a ordem da subtração, assim como foi feito para a comparação da 16 }
idade dos alunos. 17 }
Esta ordem criada na classe Student, através da implementação

-- Output:
da interface Comparable e do método compareTo(), é chamada Name: Bruno Age: 26 Score: 82
de ordem natural do objeto. Mas e se quisermos ordenar objetos Name: Alex Age: 28 Score: 78
que não implementem a interface Comparable, ou se quisermos Name: Bruno Age: 30 Score: 56
alterar a ordem natural do objeto que temos em uma coleção, o Name: José Age: 34 Score: 100
que podemos fazer? Para estes casos existe a interface Comparator. Name: Bruno Age: 36 Score: 56
Um comparator representa uma relação de ordem que pode ser
passada para um método de ordenação. Quando implementamos
a interface Comparator, temos que escrever o método compare(), Como poderíamos resolver este problema em uma situação real?
muito semelhante ao que acontece com a interface Comparable e Uma maneira simples e elegante seria adicionar um identificador
o seu método compareTo(). a cada aluno e inclui-lo em todas as comparações. Assim, nenhum
A Listagem 6 nos mostra o código de uma classe para compara- aluno será igual ao outro e todos os alunos sempre serão listados,
ção de idade de alunos que implementa a interface Comparator independente do campo de comparação que utilizarmos.
e seu método compare(). Vamos então inserir um identificador na classe Student, adicio-
nando private int _id às nossas variáveis de classe, refazer a nossa
classe de ordenação por idade e comparar com o resultado anterior.
Listagem 6. Exemplo de classe para comparação da idade dos alunos. A Listagem 8 apresenta a nova classe de comparação.
01 public class CompareStudentAge implements Comparator<Object> {
02 public int compare(Object o1, Object o2) { Listagem 8. Nova classe para comparação da idade de alunos.
03 return ((Student) o1).getAge() - ((Student) o2).getAge();
04 }
01 public class CompareStudentAge implements Comparator<Object> {
05 }
02 public int compare(Object o1, Object o2) {
03 Student s1 = (Student) o1;
04 Student s2 = (Student) o2;
Note que ela é muito simples e pode ser usada como compa- 05 if (s1.getAge() != s2.getAge()) {
06 return s1.getAge() - s2.getAge();
rador de objetos em coleções, quer estes objetos implementem a 07 }
interface Comparable ou não. Tendo desenvolvido a nossa nova 08 else {
classe de comparação, vamos alterar o nosso método de testes 09 return s1.getId() - s2.getId();
10 }
para usar o novo objeto criado. A Listagem 7 nos mostra o que
11 }
fazer para usarmos o nosso comparador de idades de alunos e 12 }
seu respectivo output.
-- Output:
Como podemos notar, conseguimos ordenar uma listagem de
Id: 5, Name: Bruno, Age: 26, Score: 82
alunos somente pela idade e de forma crescente, sobrepondo a Id: 7, Name: Alex, Age: 28, Score: 78
ordenação natural da classe Student. No entanto, mais uma vez Id: 4, Name: Bruno, Age: 30, Score: 56
não temos uma listagem com todos os alunos inseridos na coleção. Id: 6, Name: Fernando, Age: 30, Score: 80
Id: 2, Name: Miguel, Age: 32, Score: 94
Isso acontece porque existem alunos com a mesma idade, o que Id: 1, Name: José, Age: 34, Score: 100
torna os objetos iguais para o nosso comparador, fazendo com Id: 3, Name: Bruno, Age: 36, Score: 56
que as repetições não sejam inseridas no objeto Set.

Conforme constatado nos resultados obtidos, também expostos segundo cast (linha 10), onde tentamos ler uma String como se
nesta listagem, agora temos a listagem completa dos alunos (note fosse um inteiro. Apesar disso, o programa compila corretamente,
que o aluno Fernando voltou a fazer parte do output). Assim, não sem qualquer problema, mas em tempo de execução teremos uma
teremos mais o problema de remoção não intencional de objetos exceção do tipo ClassCastException.
de nossas coleções.
No caso de querermos implementar diferentes tipos de compa- Listagem 10. Exemplo de código sem erros de compilação, mas com erro de
runtime.
rações, temos a liberdade de criar quantas classes de comparação
desejarmos e as passarmos para nossas coleções para ordená-las 01 public static void testNonGenericList() {
da maneira pretendida. Como exercício para colocar o conheci- 02 List list = new ArrayList();
03 list.add(41005);
mento adquirido em prática, experimente criar uma classe para 04 list.add(“Iasmin”);
ordenação das notas dos alunos, da mesma forma que foi feito para 05
06 Integer i = (Integer)list.get(0);
a classe de ordenação da idade, mas com a ordenação decrescente 07 System.out.println(“First item: “ + i);
das notas e crescente dos identificadores, e compare os resultados 08
com os valores da Listagem 9. 09 // Código que não causa erros de compilação, mas causa um erro em runtime!
10 i = (Integer)list.get(1);
11 System.out.println(“Second item: “ + i);
Listagem 9. Resultado da ordenação dos alunos por ordem decrescente das notas 12 }
e crescente dos ids.
-- Output:
Id: 1, Name: José, Age: 34, Score: 100 First item: 41005
Id: 2, Name: Miguel, Age: 32, Score: 94 Exception in thread “main” java.lang.ClassCastException: java.lang.String cannot
Id: 5, Name: Bruno, Age: 26, Score: 82 be cast to java.lang.Integer
Id: 6, Name: Fernando, Age: 30, Score: 80 at TestClassCollectionsAndGenerics.testNonGenericList(TestClassCollections
Id: 7, Name: Alex, Age: 28, Score: 78 AndGenerics.java:10)
Id: 3, Name: Bruno, Age: 36, Score: 56 at TestClassCollectionsAndGenerics.main(TestClassCollectionsAndGenerics.java)
Id: 4, Name: Bruno, Age: 30, Score: 56
Este é um simples exemplo do problema que podemos evitar

Genéricos usando uma lista genérica. No caso da listagem anterior, temos
Para melhorar o conhecimento adquirido sobre como usar cole- uma lista com apenas dois elementos, mas imagine um caso mais
ções, vamos falar agora sobre um estilo de programação que nos complexo. Por exemplo: suponha que temos uma aplicação que
ajuda a trabalhar com coleções de maneira mais flexível e segura: recebe uma lista de objetos para processar, tendo definido que
os genéricos! Este recurso adiciona estabilidade em nosso código a lista deve conter apenas objetos do tipo inteiro, mas de tama-
por fazer com que a maior parte de nossos bugs sejam detectáveis nho indeterminado (10.000, ou 1.000.000 de elementos). E se nos
em tempo de compilação. Mas, afinal, o que são genéricos? E o enviarem elementos que não sejam inteiros? Ok, podemos nos
que é programação genérica? precaver deste problema perguntando qual o tipo do elemento
A programação genérica é um estilo de programação na qual os da lista antes de processá-lo, utilizando o operador instanceof,
algoritmos são escritos com tipos a serem especificados poste- através de um comando como if (list.get(i) instanceof Integer)
riormente, ou seja, são instanciados posteriormente para um tipo ..., mas adicionaríamos um pouco mais de complexidade ao códi-
específico fornecido como parâmetro. Genéricos são uma facilida- go, perdendo alguma performance e remediando um problema,
de da programação genérica que foi adicionado à linguagem Java mas não impedindo realmente que ele aconteça. Então, vamos
na versão 5.0. Este tipo de programação permite que um método conhecer uma melhor solução, com genéricos, como nos mostra
opere sobre objetos de vários tipos, fornecendo “type safety” em a Listagem 11.
tempo de compilação e promovendo a eliminação da necessidade
de casts. Sem genéricos é possível escrever código com erros de Listagem 11. Exemplo de leitura em uma lista genérica.
tipificação de objetos que passem pela fase de compilação com 01 public static void testGenericList() {
sucesso, sendo detectados apenas em tempo de execução. E, como 02 List<Integer> list = new ArrayList<>();
sabemos, corrigir erros de compilação é mais fácil do que corrigir 03 list.add(41005);
04 list.add(“Iasmin”);
erros de execução. 05
Para entendermos o problema da não utilização de genéricos 07 Integer i = list.get(0);
em nosso código e qual a motivação para adotá-los, vejamos um 08 System.out.println(i);
09
exemplo simples, mostrado na Listagem 10, que também apresenta 10 i = list.get(1);
o seu respectivo output. 11 System.out.println(i);
Como podemos constatar, criamos uma lista de objetos onde 12 }
inserimos primeiro um valor numérico e, em seguida, uma -- Erro:

String. No momento de visualizar os objetos da lista, fizemos o The method add(Integer) in the type List<Integer> is not applicable for the
arguments (String) - line 4
cast correto do primeiro elemento, mas tivemos um problema no

Desta vez, criamos uma lista de inteiros. Ao fazer isso, o com- Listagem 13. Código exemplo utilizando a classe Box.
pilador Java sabe que só é possível inserir e retornar inteiros
01 public static void testBox() {
da lista. Deste modo, a tentativa de inserir uma String, como
02 Box box = new Box();
acontece na linha 4, gera o erro de compilação apresentado no 03
fim da listagem, informando que o método add() para uma lista 04 box.set(1324);
de inteiros não é aplicável a argumentos do tipo String. Como 05 Object o = box.get();
o compilador nos garante que só existirão inteiros na lista, não 06 if (o instanceof Integer) {
07 Integer i = (Integer) o;
existe a necessidade de casts no momento da leitura dos seus
08 System.out.println(“Box has: “ + i);
valores, como podemos confirmar nas linhas 7 e 10. Assim, não 09 }
temos que remediar o problema perguntando os tipos de elemen- 10
tos que estão na lista antes de os ler. Em vez disso, impedimos 11 box.set(“Another object”);
12 o = box.get();
que o problema possa acontecer, criando uma restrição sobre o
13 if (o instanceof String) {
que pode ser inserido na lista. 14 String s = (String) o;
15 System.out.println(“Box has: “ + s);
Como escrever uma classe genérica? 16 }
17 }
Agora que já sabemos quais as vantagens de se utilizar classes
genéricas, vamos aprender como escrever uma. Para isso, cria- -- Output
remos primeiro uma classe da maneira “tradicional” e depois Box has: 1324
vamos transformá-la numa classe genérica para entendermos Box has: Another object
quais as diferenças. Listagem 14. Código da classe Box na sua forma genérica – GenericBox.
Seja Box uma classe que representa uma caixa que pode guardar
apenas um objeto de cada vez e da qual podemos retornar o objeto 01 public class GenericBox<T> {
que está dentro dela, vejamos como escrever um possível código 02 private T t;
03
para esta classe na sua forma tradicional (vide Listagem 12).
04 public void set(T t) {
05 this.t = t;
Listagem 12. Classe que representa uma caixa que guarda um objeto. 06 }
07
01 public class Box { 08 public T get() {
02 private Object object;
09 return t;
03
10 }
04 public void set(Object object) {
05 this.object = object; 11 }
06 }
07
08 public Object get() {
09 return object;
Comparando a classe Box com GenericBox, podemos notar que
10 } todas as ocorrências de Object foram substituídas pela variável
11 } de tipo T, que poderá ser especificada com qualquer tipo não
primitivo que desejarmos. Esta mesma técnica pode ser usada
Como podemos verificar, uma caixa pode conter um objeto de para criar interfaces genéricas.
qualquer tipo. Isso quer dizer que quando retornarmos o objeto da Para compreendermos o resultado desta alteração, vejamos como
caixa, teremos que perguntar que tipo de objeto ela contém antes podemos utilizar a classe GenericBox na Listagem 15.
de fazermos o cast para o seu tipo específico e assim podermos Com a nova classe, somos obrigados a identificar, no momento
trabalhar com ele. Para entendermos melhor este fato, analisemos da sua instanciação, que tipo de objeto ela (GenericBox) pode
a Listagem 13, que nos mostra um exemplo de utilização segura guardar. Deste modo seremos impedidos de guardar objetos
da classe Box e o output gerado pelo código. que sejam de um tipo diferente do previamente acordado e, se
Para verificarmos as diferenças entre as implementações no tentarmos burlar esse acordo, teremos um erro de compilação e
modelo tradicional e com genéricos, vamos reescrever a classe Box não conseguiremos executar o programa. Portanto, ganhamos a
de forma a transformá-la numa classe genérica e assim podermos segurança do “type safety” e não temos mais que nos preocupar
usufruir da segurança do type safety. A Listagem 14 nos mostra a com casts aos objetos guardados pela caixa.
implementação dessa classe, a qual chamamos de GenericBox.
Por regra, uma classe genérica é definida no formato Convenções de nomeação para parâmetros de classes genéricas
NomeDaClasse<T1, T2, T3, ..., Tn>, onde T representa um tipo Uma ressalva importante é que T não é uma palavra-chave do
de parâmetro da classe. Em GenericBox, introduzimos apenas Java. Portanto, a classe GenericBox poderia ser escrita da mesma
uma variável do tipo T, que será o parâmetro recebido pela classe forma como se encontra na Listagem 16, sem qualquer tipo de
e que irá determinar o tipo de objeto que ela poderá usar. problema.

Listagem 15. Código que demonstra a utilização da classe GenericBox. Felizmente, alguns bugs são mais fáceis de detectar do que
outros. Erros de compilação, por exemplo, podem ser detectados
01 public static void testGenericBox() {
02 GenericBox<Integer> box = new GenericBox<>();
precocemente e podemos usar as mensagens que nos são dadas
03 pelo compilador para chegar facilmente à causa do problema e
04 box.set(1324); corrigi-lo. Erros de runtime, por outro lado, podem ser muito
05 Integer i = box.get();
06 System.out.println(“Box has: “ + i); mais problemáticos, já que não surgem imediatamente e, quando
07 ocorrem, podem acontecer em um ponto distante da real causa
08 box.set(5678);
do problema, tendo se propagado no código.
09 i = box.get();
10 System.out.println(“Box has: “ + i); Os genéricos adicionam estabilidade ao nosso código por possi-
11 } bilitar que mais bugs sejam detectados em tempo de compilação,
-- Output tornando mais fácil e rápida a sua correção. Com a adoção dos
Box has: 1324 genéricos na API Java Collections, além de termos disponível uma
Box has: 5678
série de classes e interfaces que tornam mais simples a tarefa de
Listagem 16. Alteração da variável de tipo T para A. manipulação de coleções de objetos, obtemos mais segurança para
o nosso código. Fundamentada na segurança e na flexibilidade,
01 public class GenericBox<A> {
02 private A a;
esta API nos oferece um código maduro e estável, com algoritmos
03 de excelente desempenho nas implementações de cada interface.
04 public void set(A a) { E por serem implementações de estruturas comuns a diversas
05 this.a = a;
06 } linguagens de programação orientadas a objetos, a sua utilização
07 também viabiliza um código mais legível e fácil de manter.
08 public A get() {
Um sólido conhecimento do framework de Collections do Java
09 return a;
10 } nos permitirá escolher as melhores estruturas de dados para cada
11 } situação, nos ajudando a aprimorar o nosso código em termos de
reutilização, desempenho, legibilidade e segurança.
Por que então usamos o T e não outra letra qualquer do alfabeto?
Por convenção! E isso é algo muito importante e que não pode Autor
ser negligenciado. As convenções melhoram a leitura do código
e sua manutenção. T vem de Type, ou Tipo, traduzindo do inglês, José Fernandes A. Júnior
e poderá ser visto em muitas classes genéricas que pertencem às [email protected]
É Mestre em Engenharia Informática pela Faculdade de
bibliotecas core do Java.
Ciências e Tecnologias da Universidade Nova de Lisboa (FCT-
Sendo assim, é importante conhecermos os padrões usados na
UNL). Trabalha com Java há 10 anos, mas vem atuando com diversas
linguagem Java para que possamos seguir a mesma nomenclatura, linguagens, em diversos ramos e áreas, desde core engines de empresas
não causando confusões sobre que tipo de parâmetro desejamos de telecomunicação, até aplicações móveis para Android e iOS. Trabalhou como formador
em nossas classes genéricas. autorizado da Sun Microsystems nos cursos de Java, Unix, Shell Programming e JCAPS.
A seguir apresentamos os nomes convencionados para os dife- Possui as certificações de Java Swing, Enterprise Java Beans, Java Composite Application
rentes tipos de parâmetros genéricos: Platform Suite (JCAPS), Certificado de Aptidão Profissional (CAP) e Titanium Certified
• E – Element (muito usado pela Java Collections Framework): App Developer (TCAD).
Elemento;
• K – Key: Chave; Links:
• N – Number: Número;
• T – Type: Tipo; The Java Tutorials: Collections.
• V – Value: Valor; http://docs.oracle.com/javase/tutorial/collections/interfaces/index.html
• S, U, V etc. – 2º, 3º, 4º tipos. Choosing the right Collection.
http://www.javapractices.com/topic/TopicAction.do?Id=65
Nota
Generics (Updated).
Sempre que for escrever uma classe genérica, siga estas regras de convenção de nomenclatura para
http://docs.oracle.com/javase/tutorial/java/generics/index.html
obter um código mais legível e de fácil manutenção.
Quanto mais complexo é um projeto de software, mais difícil Você gostou deste artigo?
torna-se encontrar os seus bugs. Sendo assim, um planejamento
cuidadoso e uma série de testes bem executados podem ajudar a Dê seu voto em www.devmedia.com.br/javamagazine/feedback
reduzir o número destes, mas não nos garante a sua eliminação Ajude-nos a manter a qualidade da revista!
por completo.

Refatoração com
padrões de projeto e
boas práticas
Identifique e refatore códigos mal escritos
utilizando padrões de projetos e boas práticas
Este artigo é do tipo mentoring Cenário

saiba mais: www.devmedia.com.br/mentoring-saibamais
A manutenção de um software compreende a maior parte de sua
vida útil e também costuma ser mais trabalhosa do que o seu de-
senvolvimento. Portanto, um código mal escrito pode trazer muitos
P
rojetar e desenvolver um software de qualidade problemas durante o desenvolvimento de novas funcionalidades e
não é uma tarefa trivial. Muitos softwares levam manutenção de um software. Neste contexto, este artigo é útil para
incontáveis meses para serem desenvolvidos, a identificação de códigos mal escritos, que podem trazer problemas
gerando altos custos e jamais chegam a ser entregues. em tempo de manutenção, e também para a aplicação de refatoração
Um dos fatores mais comuns para o insucesso na criação nestes códigos, utilizando para isso alguns padrões de projetos e
de softwares é o código mal escrito, também conhecido boas práticas.
como code smell.
Por isso, é importante que a equipe de desenvolvimen-
to se preocupe desde o início do projeto em entregar Diante disso, o objetivo deste artigo é mostrar como identificar
um software de qualidade, de modo a evitar futuros códigos mal escritos e como refatorar estes códigos utilizando
problemas. No entanto, se um software é entregue padrões de projetos e boas práticas de programação. Deste modo,
com trechos de código mal escritos, ele fatalmente durante o artigo serão mostrados exemplos de códigos mal
apresentará problemas em tempo de manutenção e até escritos, a identificação do mesmo e a aplicação da refatoração,
mesmo para o incremento de novas funcionalidades. apresentando, por fim, os ganhos obtidos.
Neste ponto, o software pode tornar-se inviável, pois
um código ruim tende a gerar mais código ruim, além Padrões de Projeto
de diminuir a produtividade no desenvolvimento. Este O foco principal deste artigo não é esmiuçar em detalhes os
é o momento de identificar os pontos de código mal conceitos dos padrões de projetos. No entanto, é importante ter
escrito e refatorá-los. conhecimento das características dos padrões utilizados no de-
Para auxiliar e orientar os desenvolvedores neste pro- correr do artigo, de modo que se possa tomar a decisão de qual
cesso, existem diversos padrões de projetos e boas práti- padrão utilizar em determinadas situações.
cas de programação que podem ser aplicados como base Um padrão é composto basicamente por uma solução robusta
para a refatoração de códigos mal escritos. No entanto, para problemas comuns. Em outras palavras, um padrão é uma
antes de iniciar a refatoração de um código, deve-se levar solução que pode ser facilmente adaptada para resolver problemas
em consideração qual a característica que torna o código semelhantes, em diferentes contextos.
ruim e avaliar qual o padrão ou boa prática que melhor Existem basicamente duas maneiras de se utilizar padrões em
se encaixa para refatoração de tal código. um projeto de software. Uma delas é a utilização dos padrões já

no momento em que o software está sendo projetado, ou seja, na O objetivo é facilitar a comunicação entre as classes distribuindo
modelagem do software, antes mesmo do código começar a ser as responsabilidades. A seguir são listados alguns exemplos de
escrito. A outra opção, que será abordada neste artigo, é através padrões de projetos comportamentais:
da refatoração de código, onde os padrões são utilizados com • Chain of Responsibility;
o objetivo de eliminar trechos de código mal escritos, mas sem • Command;
modificar seu comportamento. • Interpreter;
O livro Design Patterns: Elements of Reusable Object-Oriented • Iterator;
Software, da Gang of Four (vide BOX 1), lista vinte e três padrões • Mediator;
de projetos, divididos em três categorias – padrões de projeto • Observer;
criacionais, padrões de projeto estruturais e padrões de projeto • State;
comportamentais. • Strategy;
• Template Method;
Box 1. Gang of Four • Visitor.
Em 1994 os autores Erich Gamma, Richard Helm, Ralph Johnson e John Vlissides publicaram o
Boas práticas
famoso livro Design Patterns: Elements of Reusable Object-Oriented Software (Padrões de Projeto:
Escrever um código limpo e legível não é fácil. O código deve
Soluções Reutilizáveis de Software Orientado a Objetos) com o objetivo de conceituar alguns
ser frequentemente revisado e refatorado. Para isso, o desenvol-
padrões de projeto para o desenvolvimento de softwares orientados a objetos. Depois disso, estes
vedor deve partir do princípio de que um código sempre pode
autores ficaram conhecidos como Gang of Four, ou ainda, GoF.
melhorar, por mais limpo e bem escrito que possa parecer. Com
O livro busca documentar soluções recorrentes para tipos de problemas parecidos, que se agrupam
este objetivo, existem diversas boas práticas de programação
em contextos semelhantes. Os vinte e três padrões abordados no livro estão divididos em três
que, se utilizadas, podem melhorar muito a legibilidade do
categorias: padrões criacionais, estruturais e comportamentais.
código de um projeto, facilitando a manutenção e a evolução
do mesmo. Lembre-se: um código fácil de ler é um código fácil
Padrões de Projeto Criacionais de manter e evoluir.
Os padrões de projeto criacionais, como o próprio nome indica, O famoso livro Clean Code, do autor Robert C. Martin, também
são padrões utilizados para a criação de objetos. A ideia é separar conhecido como Uncle Bob, é uma leitura ótima neste sentido,
a lógica de criação de modo que a mesma possa ser encapsulada e e apresenta conceitos e exemplos interessantíssimos no que diz
reaproveitada facilmente. A seguir são listados alguns exemplos respeito a código limpo e legível e sua importância para o sucesso
de padrões de projeto criacionais: dos projetos. O livro também faz uma abordagem interessante
• Abstract Factory; sobre os princípios S.O.L.I.D (vide BOX 2).
• Builder; Veremos agora alguns exemplos de boas práticas de progra-
• Factory Method; mação e como elas podem ajudar na refatoração de códigos mal
• Prototype; escritos.
• Singleton.
Box 2. Princípios S.O.L.I.D
Padrões de Projeto Estruturais Os Princípios SOLID representam cinco princípios de design de softwares orientados a objetos.
Os padrões de projeto estruturais focam na organização das Abordados inicialmente por Robert C. Martin, são considerados um conjunto de boas práticas
classes e objetos de um sistema. O propósito é evitar o alto acopla- de programação que visa separar responsabilidades e diminuir o acoplamento entre classes,
mento entre as classes, modularizando o sistema em componentes melhorando a legibilidade e a organização do código. A seguir, apresentamos um breve resumo de
com responsabilidades específicas. A seguir são listados alguns cada um dos cinco princípios:
exemplos de padrões de projeto estruturais: 1. Single Responsibility Principle: cada classe ou método de um projeto deve ter apenas uma
• Adapter; responsabilidade, ou seja, deve fazer apenas uma coisa. E deve fazer da melhor forma possível;
• Bridge; 2. Open Closed Principle: princípio do aberto/fechado. Diz que as classes do projeto podem ter seu
• Composite; comportamento facilmente estendido, seja por herança, interfaces ou composição. Por outro lado,
• Decorator; as classes não devem ser abertas para pequenas modificações;
• Facade; 3. Liskov Substitution Principle: é uma extensão do princípio aberto/fechado e diz que uma classe
• Flyweight; base deve poder ser substituída por qualquer uma de suas classes derivadas;
• Proxy. 4. Interface Segregation Principle: define que uma interface não pode fazer com que uma
classe implemente métodos que não sejam dela. Além disso, as interfaces devem ter poucos
Padrões de Projeto Comportamentais comportamentos, evitando o alto acoplamento e procurando manter a coesão;
Os padrões de projeto comportamentais definem como as res- 5. Dependency Inversion Principle: este princípio diz que as classes de um nível mais alto de abstração
ponsabilidades são atribuídas entre as classes do sistema, ou seja, não podem depender de seus detalhes de implementação, ou seja, devem ser independentes.
atuam sobre o comportamento das classes.

Refatoração com padrões de projeto e boas práticas
Nomes Significativos deve ser agregada uma nova funcionalidade no sistema e aquele
Para o desenvolvimento de um projeto, utilizamos vários trecho de código será impactado. Por fim, um terceiro desenvol-
pacotes, classes, métodos e variáveis. São esses elementos que vedor recebe a demanda e se depara com um código confuso e
compõem um projeto e o desenvolvedor é o responsável por dar que faz uma coisa diferente do que diz o comentário.
nome a eles. Diante disso, é muito importante que o desenvolvedor No entanto, existem alguns tipos de comentários que podem
escolha nomes que expressem realmente o que aquela classe ou ser utilizados. É o caso dos Javadocs, que podem ser definidos
variável representa dentro do contexto do projeto, com o objetivo em métodos públicos e classes que sejam disponibilizadas como
de facilitar a leitura do código. bibliotecas para uso em outros módulos ou projetos.
Infelizmente, não é difícil encontrar classes com incontáveis Analisando as vantagens e desvantagens, o ideal é evitar os
linhas de código, com métodos gigantescos e se deparar com comentários. Afinal, um código bem escrito e fácil de entender
nomes de variáveis que não fazem sentido algum. Isso dificulta, não precisa de comentários.
e muito, a manutenção do código, pois consome um tempo bem
maior de leitura e interpretação para realmente compreender o Refatorando na prática
que determinada variável ou método faz, ou deveria fazer. Por Para demonstrar na prática a refatoração utilizando padrões de
isso, é preferível perder um pouco de tempo definindo bons no- projeto e boas práticas de programação, será utilizado um exem-
mes para suas classes, variáveis e métodos, do que perder muito plo de um projeto que requer uma refatoração de código, com o
tempo depois tentando entender o que cada um destes elementos objetivo de melhorar a legibilidade do mesmo e facilitar as futuras
significa dentro do contexto do projeto. manutenções e evoluções que se façam necessárias.
Métodos curtos Entendendo o problema

Os métodos são os elementos do projeto responsáveis por definir Suponha que um desenvolvedor recebe a tarefa de refatorar um
o comportamento dos objetos. Eles devem ser curtos e fáceis de módulo de um projeto que realiza o cálculo da conta de utiliza-
entender e, principalmente, devem seguir o princípio da responsa- ção de um estacionamento. As tarifas para o cálculo seguem os
bilidade única. Devem fazer uma coisa só e bem feita. Um método valores da Tabela 1.
muito grande indica que ele provavelmente está fazendo mais de
uma coisa. Isso é péssimo para a manutenção por dois motivos: Tempo Carro de Passeio Caminhonete
um método extenso é difícil de ler e entender e praticamente Até ½ hora R$ 5,00 R$ 7,00
impossível de ser reutilizado. Até 1 hora R$ 8,00 R$ 10,00
Quando um desenvolvedor se deparar com um código extenso, Hora adicional R$ 3,00 R$ 5,00
deve refatorá-lo, extraindo métodos menores que tenham apenas
Diária R$ 20,00 R$ 30,00
uma responsabilidade e dando um nome que represente o que
estes métodos façam. Tabela 1. Valores de tarifas do estacionamento
Métodos com poucos parâmetros As regras para o cálculo do valor dessa conta são as seguintes:
Procure sempre criar métodos que recebam poucos parâmetros. • Para os veículos que permanecerem no estacionamento por até
De preferência, nenhum, e no máximo, três. Mais que isso pode meia hora, o valor da conta será correspondente ao da linha Até
ser um indício de que seu método está fazendo mais coisas do que ½ hora da referida tabela;
deveria fazer, quebrando o princípio da responsabilidade única. • Para os veículos que permanecerem no estacionamento por mais
Métodos com muitos parâmetros são também mais difíceis de de meia hora, até uma hora, o valor da conta será correspondente
serem reutilizados. ao da linha Até 1 hora;
Caso seja necessário criar métodos com mais de três parâmetros, • Para os veículos que permanecerem no estacionamento por mais
avalie a possibilidade de encapsular estes parâmetros em um de uma hora, as regras são as seguintes:
objeto, aumentando assim a possibilidade de reuso. - Para os veículos que permanecerem no estacionamento até
seis horas, o valor da conta será o valor da linha Até 1 hora,
Comentários mais o valor da linha Hora Adicional da Tabela 1, multiplicado
Comentários devem ser evitados. Uncle Bob diz que um comen- pelo número de horas adicionais de utilização;
tário é uma tentativa de explicar um código confuso e mal escrito. - Para os veículos que permanecerem no estacionamento por
Além disso, existe um problema maior ainda com comentários. mais de seis horas, o valor da conta será correspondente ao
Imagine que um desenvolvedor escreveu um código confuso para valor da linha Diária;
implementar uma regra de negócio e utilizou um comentário para • Para os veículos do tipo carro de passeio, devem ser utilizados
explicar o que o código faz. Pouco tempo depois, a regra de negócio os valores da coluna Carro de Passeio;
muda e outro desenvolvedor recebe a tarefa de aplicar a alteração • Para veículos do tipo caminhonete, devem ser utilizados os
no código. Ele o faz, porém, não altera o comentário. Mais tarde, valores da coluna Caminhonete;

• Para gerar a conta da utilização do estacionamento, devem ser Analisando o código, pode-se observar que o método
considerados a hora de entrada do veículo, a hora de saída do responsável por gerar a conta do estacionamento é confuso
veículo e o tipo do veículo. e de difícil leitura. Note que o método é grande, indicando
a quebra do princípio da responsabilidade única, além de
Identificando código mal escrito apresentar uma alta complexidade ciclomática, que pode
Depois de ler os requisitos do módulo de cálculo da conta de ser observada pela grande quantidade de condicionais.
utilização do estacionamento, o próximo passo do desenvolvedor É possível também observar duplicação de código, pois
é começar a leitura do código a ser refatorado. O código da classe o trecho de código que implementa as regras de cobrança
responsável por calcular o valor da conta do estacionamento está para carros de passeio é praticamente igual ao trecho que
representado na Listagem 1. implementa as regras para caminhonetes, com exceção das
tarifas, que mudam conforme o tipo do veículo. O código
Listagem 1. Classe Conta, contendo a lógica para cálculo do valor da conta do também está cheio de números soltos e contém alguns
estacionamento.
comentários que pouco acrescentam, além de varáveis de
01 public class Conta { nome pouco expressivo. Outro aspecto importante é que o
02 método pode retornar null, e retornar null nunca é uma boa
03 private long entrada; ideia, pois obriga a todos os clientes deste método tratarem
04
05 private long saida;
um possível NullPointerException.
06 Apesar de todos os problemas identificados, o código
07 private Veiculo veiculo; compila e atende às regras especificadas. Porém, há um
08 perigo muito grande com códigos desse tipo. Imagine que
09 public Conta(long entrada, long saida, Veiculo veiculo) {
10 this.entrada = entrada;
em determinado momento, o estacionamento passe a traba-
11 this.saida = saida; lhar com veículos de outros tipos, como motocicletas, vans,
12 this.veiculo = veiculo; ônibus e caminhões. Para cada novo tipo de veículo, teria
13 } de ser adicionado um novo condicional, replicando mais
14
15 public Double gerarConta() {
código, para atender o cálculo de acordo com as tarifas do
16 novo tipo de veículo. E se o estacionamento passasse a contar
17 //Obtém o período de utilização em minutos com planos de pernoite e mensalidade, o método precisaria
18 long periodo = (saida - entrada) / 1000 / 60;
de mais condicionais dentro do tratamento de cada tipo de
19
20 if (veiculo.getTipoVeiculo().equals(TipoVeiculo.CARRO_PASSEIO)) { veículo para implementar as novas regras.
21 // gera conta para carros de passeio Neste cenário, o código tende a crescer de forma exponencial,
22 if (periodo <= 30) { chegando a um ponto em que fique inviável manter ou evoluir
23 return 5.0;
o projeto. Lembre-se que código ruim gera código ruim.
24 } else if (periodo > 30 && periodo <= 60) {
25 return 8.0; Para completar o código do projeto, a classe que representa
26 } else if (periodo > 60 && periodo / 60 <= 6) { um veículo é apresentada na Listagem 2 e a Listagem 3
27 //Obtém horas adicionais de utilização apresenta uma enumeração contendo os tipos de veículos.
28 long horas = (periodo - 1) / 60;
29 return horas * 3.0 + 8.0;
30 } else { Listagem 2. Classe que representa um veículo.
31 return 20.0;
32 } 01 public class Veiculo {
33 } else if (veiculo.getTipoVeiculo().equals(TipoVeiculo.CAMINHONETE)) { 02
34 // gera conta para caminhonetes 03 private String placa;
35 if (periodo <= 30) { 04
36 return 7.0;
05 private String modelo;
37 } else if (periodo > 30 && periodo <= 60) {
06
38 return 10.0;
39 } else if (periodo > 60 && periodo / 60 <= 6) { 07 private TipoVeiculo tipoVeiculo;
40 //Obtém horas adicionais de utilização 08
41 long horas = (periodo - 1) / 60; 09 // gets e sets omitidos
42 return horas * 5.0 + 10.0; 10 }
43 } else {
44 return 30.0; Listagem 3. Enumeração com os tipos de veículos.
45 }
46 } 01 public enum TipoVeiculo {
47 return null; 02 CARRO_PASSEIO,
48 } 03 CAMINHONETE;
49 } 04 }

A Figura 1 representa o diagrama de Aplicando boas práticas na refatoração confusa para obter o período que o veículo
classes da versão atual do módulo de Feita a análise e a identificação dos pro- utilizou o estacionamento. No entanto, o
cálculo da conta de utilização do estacio- blemas no código, o desenvolvedor deve ideal seria eliminar o comentário, extrair
namento. Com o intuito de facilitar a com- agora começar a refatoração. O primeiro a lógica para obter o período de utilização
preensão do conteúdo apresentado a partir passo é aplicar boas práticas para eliminar em um método privado e renomear a va-
deste ponto, conforme o código for sendo alguns problemas levantados. Como é riável para indicar que o período armaze-
refatorado, o diagrama será evoluído, para possível observar na Listagem 1, o método nado é em minutos.
ilustrar a utilização de alguns padrões de responsável por gerar a conta do estaciona- Outro ponto a se observar, é que o méto-
projetos e boas práticas na refatoração. mento começa com uma linha um pouco do pode retornar null, o que nunca é uma
boa ideia. Analisando o código, pode-se
Listagem 4. Aplicando boas práticas na refatoração. constatar que o método só retorna null se
o veículo não tiver nenhum valor defini-
01 public Double gerarConta() { do para o atributo que representa o tipo
02
03 long periodoEmMinutos = obtemPeriodoDeUtilizacaoEmMinutos(); de veículo ou se o valor for diferente de
04 CAMINHONETE ou CARRO_PASSEIO.
05 //lógica omitida... Neste caso, o método pode lançar uma
06
07 throw new IllegalStateException(“Tipo de veículo indefinido”); exceção indicando que o estado do objeto
08 } é inválido. A Listagem 4 mostra como fica
09
o código após a refatoração.
10 private long obtemPeriodoDeUtilizacaoEmMinutos() {
11 return (saida - entrada) / 1000 / 60; Note que o código pertinente à lógica de
12 } geração da conta do estacionamento foi
omitido dessa listagem, pois neste ponto
da refatoração ele ainda não foi alterado.
Aplicando o padrão Strategy na refatoração

Agora, vamos começar a eliminar o
código replicado e alguns condicionais.
Uma boa abordagem para a eliminação
de código duplicado e dos condicionais é
a utilização do padrão Strategy. A ideia é
utilizar composição e uma estrutura de he-
rança para criar subclasses que especiali-
zem o comportamento dos tipos de veículo
e onde a execução possa ser delegada para
estas subclasses em tempo de execução.
Neste caso, a classe que representa um
veículo passará a ser uma classe abstrata
Figura 1. Diagrama de classes do módulo de cálculo da conta de utilização do estacionamento e possuirá duas subclasses, uma para re-
presentar um carro de passeio e outra para
representar uma caminhonete.
Para dar início à refatoração utilizando
o padrão Strategy, a classe Veiculo será
modificada e terá agora métodos abstratos
para recuperar o valor da tarifa, conforme
o período que o veículo permanecer no
estacionamento. A Figura 2 ilustra a evo-
lução do diagrama de classes para atender
as alterações.
Este modelo permite que, caso a apli-
cação passe a suportar novos tipos de
veículos, não seja necessário criar mais
código duplicado e métodos extensos.
Figura 2. Diagrama de classes utilizando Strategy na refatoração Basta criar uma nova subclasse de veículo

e implementar os métodos necessários. Em outras palavras, a Listagem 6. Classe que representa um veículo, após a refatoração com Strategy.
modelagem segue o princípio aberto para expansão e fechado
01 public abstract class Veiculo {
para alteração. 02
Com a alteração, o método responsável por gerar a conta de uti- 03 private String placa;
lização do estacionamento não precisa mais duplicar código para 04 private String modelo;
05
cada tipo de veículo. A Listagem 5 apresenta o código da classe 06 public abstract double tarifaAteMeiaHora();
responsável pela geração da conta após a refatoração utilizando 07 public abstract double tarifaAteUmaHora();
o padrão Strategy. Note que o código melhorou, mas ainda apre- 08 public abstract double tarifaHoraAdicional();
09 public abstract double tarifaDiaria();
senta um grande número de condicionais para calcular o valor 10
da conta de acordo com tempo. Para resolver isso, será aplicado 11 // gets e sets omitidos
outro padrão de projeto, abordado mais à frente. 12 }
Listagem 7. Classe que representa um carro de passeio.

Listagem 5. Classe responsável pela geração da conta, após a refatoração com
Strategy. 01 public class CarroDePasseio extends Veiculo {
02
01 public class Conta { 03 @Override
02 04 public double tarifaAteMeiaHora() {
03 private long entrada; 05 return 5.0;
04 06 }
05 private long saida; 07
06 08 @Override
07 private Veiculo veiculo; 09 public double tarifaAteUmaHora() {
08 10 return 8.0;
09 public Double gerarConta() { 11 }
10 12
11 long periodoEmMinutos = obtemPeriodoDeUtilizacaoEmMinutos(); 13 @Override
12 14 public double tarifaHoraAdicional() {
13 if (periodoEmMinutos <= 30) { 15 return 3.0;
14 return veiculo.tarifaAteMeiaHora(); 16 }
15 } else if (periodoEmMinutos > 30 && periodoEmMinutos <= 60) { 17
16 return veiculo.tarifaAteUmaHora(); 18 @Override
17 } else if (periodoEmMinutos > 60 && periodoEmMinutos / 60 <= 6) { 19 public double tarifaDiaria() {
18 // Obtém horas adicionais de utilização 20 return 20.0;
19 long horas = (periodoEmMinutos - 1) / 60; 21 }
20 return horas * veiculo.tarifaHoraAdicional() + veiculo.tarifaAteUmaHora(); 22
21 } else { 23 //Demais atributos e métodos específicos da classe omitidos...
22 return veiculo.tarifaDiaria(); 24 }
23 }
Listagem 8. Classe que representa uma caminhonete.
24 }
25
01 public class Caminhonete extends Veiculo {
02
27 return (saida - entrada) / 1000 / 60;
03 @Override
28 }
04 public double tarifaAteMeiaHora() {
29 05 return 7.0;
30 } 06 }
07
08 @Override
Para aplicar o padrão Strategy, foi alterada a classe que repre- 09 public double tarifaAteUmaHora() {
10 return 10.0;
senta um veículo, de modo que ela fosse especializada em duas 11 }
novas subclasses. A Listagem 6 apresenta a nova estrutura 12
da classe que representa um veículo, contendo agora apenas 13 @Override
14 public double tarifaHoraAdicional() {
atributos pertinentes aos veículos em geral e métodos abstratos
15 return 5.0;
que contêm comportamentos que variam conforme o período 16 }
de utilização do estacionamento. A Listagem 7 apresenta a 17
subclasse que representa um carro de passeio e a Listagem 8 18 @Override
19 public double tarifaDiaria() {
apresenta a subclasse que representa uma caminhonete. Nas 20 return 30.0;
classes CarroDePasseio e Caminhonete, os métodos abstratos 21 }
da classe Veiculo são implementados de modo a especializar a 22
23 //Demais atributos e métodos específicos da classe omitidos...
lógica das tarifas por tempo de utilização de acordo com cada
24 }
tipo específico de veículo.

Figura 3. Diagrama de classes utilizando Template Method na refatoração
Aplicando o padrão Template Method na refatoração Dito isso, a seguir serão apresentadas as subclasses criadas
Finalmente, será demonstrada a aplicação do padrão Template para implementar as regras de cada tarifa. A Listagem 9 ilustra
Method, para reduzir o restante da lógica condicional da classe que a subclasse responsável por calcular a tarifa de veículos que
gera a conta do estacionamento. Este padrão consiste na utilização permanecem no estacionamento até meia hora. A Listagem 10
de herança para variar partes de um algoritmo. Basicamente, a apresenta a classe para veículos que permanecem de meia hora
classe principal possui uma lógica genérica, onde apenas algu- até uma hora. A Listagem 11 mostra a classe com o cálculo para
mas partes mudam. E esses pontos do algoritmo que variam são veículos que ficam até seis horas, onde temos o cálculo de horas
especializados nas subclasses. adicionais de utilização.
No exemplo da geração da conta do estacionamento, temos uma
lógica genérica que obtém o tempo de utilização e, de acordo Listagem 9. Classe que representa o cálculo de tarifa para até meia hora de utilização.
com as tarifas do tipo do veículo, calcula o valor da conta sobre 01 public class ContaAteMeiaHora extends Conta {
o tempo que o veículo permaneceu no estacionamento. Porém, 02
03 @Override
a tarifa varia para cada faixa de tempo de utilização. Com essa
04 protected double calcularContaDeUtilizacao(long periodoEmMinutos) {
leitura, pode-se delegar o cálculo para subclasses da classe Conta, 05 return getVeiculo().tarifaAteMeiaHora();
permitindo o isolamento da lógica do cálculo para classes espe- 06 }
07 }
cíficas, facilitando a manutenção e melhorando a legibilidade e
organização do código. Para tanto, a classe Conta deve passar a ser Listagem 10. Classe que representa o cálculo de tarifa para mais de meia hora, até
uma hora de utilização.
abstrata, forçando a implementação do cálculo do valor da conta
nas subclasses específicas para cada faixa de tempo. 01 public class ContaAteUmaHora extends Conta {
02
A Figura 3 ilustra como fica o diagrama de classes do módulo de
03 @Override
cálculo do valor da conta de utilização do estacionamento com a 04 protected double calcularContaDeUtilizacao(long periodoEmMinutos) {
aplicação do Template Method após a refatoração do código. 05 return getVeiculo().tarifaAteUmaHora();
06 }
A partir dessa refatoração, além da eliminação dos condicionais 07
no código para gerar a conta de utilização do estacionamento, 08 }
resolvemos também o problema do crescimento da complexidade Listagem 11. Classe que representa o cálculo de tarifa para mais de uma hora, até
ciclomática do código, em caso da adição de novas regras de tarifa seis horas de utilização.
como, por exemplo, valores para pernoites e mensalidades.
01 public class ContaHoraAdicional extends Conta {
Para a utilização do Template Method, foram criadas quatro 02
subclasses para a classe Conta, uma para cada tarifa entre as faixas 03 @Override
de valores definidas na Tabela 1. Assim, caso alguma nova tarifa 05 long horasAdicionais = (periodoEmMinutos - 1) / 60;
seja criada, basta criar uma nova subclasse e implementar nela 06 return horasAdicionais * getVeiculo().tarifaHoraAdicional() + getVeiculo()
a regra representando a tarifa. Com isso, o código fica isolado e .tarifaAteUmaHora();
07 }
cada classe tem apenas a responsabilidade de implementar a regra 08
específica daquela tarifa. 09 }

E, por fim, a Listagem 12 apresenta a classe com o cálculo de forma que outro profissional consiga ler e entender rapidamente
veículos que ficam mais de seis horas no estacionamento, confi- o que o código escrito faz.
gurando a cobrança de uma diária. Além disso, a refatoração deve ser contínua, partindo do prin-
Encerrando nosso estudo, a Listagem 13 apresenta a classe Con- cípio que, por mais que um código pareça limpo e bem escrito,
ta, responsável pela geração do valor da conta de utilização do sempre pode ser melhorado. Boas práticas como nomes signifi-
estacionamento, após a aplicação de boas práticas e dos padrões cativos e extração de métodos para encapsular responsabilidades
Strategy e Template Method para refatoração do código. Observe que em métodos menores podem ser aplicadas constantemente nos
a classe ficou limpa, com pouco código, fácil de ler e entender e, projetos. Sendo assim, sempre que você começar a trabalhar em
consequentemente, fácil de manter e evoluir. alguma nova funcionalidade ou melhoria, procure tentar aplicar
Enfim, o código agora está preparado para suportar novas boas práticas para deixar o código melhor do que quando você
regras de tarifas e novos tipos de veículos, de modo a crescer de começou a trabalhar nele. Se você encontrar um método com um
forma organizada, sem duplicação de código e sem adição de nome pouco intuitivo, altere esse nome. Caso se depare com um
condicionais. método muito grande e confuso, quebre-o em métodos menores e
mais coesos. Se encontrar um comentário desatualizado, remova-o
Listagem 12. Classe que representa o cálculo de tarifa para mais de seis horas de do código.
utilização. Os padrões de projeto também podem e devem ser utilizados,
tanto em tempo de modelagem, quanto em tempo de refatoração.
01 public class ContaDiaria extends Conta {
02 Se você recebe uma demanda para evoluir um módulo de um sis-
03 @Override tema e se depara com um código confuso, com trechos duplicados
05 return getVeiculo().tarifaDiaria();
e excesso de lógica condicional, considere a aplicação de algum
06 } padrão para refatorar o código e torná-lo mais simples, antes de
07 adicionar mais complexidade ao mesmo. Talvez você até perca
08 }
algum tempo neste momento, mas com certeza será recompensado
Listagem 13. Classe Conta, após a refatoração com boas práticas e padrões de no médio e longo prazo.
projetos.
O importante é conseguir identificar o código mal escrito e evitar
01 public abstract class Conta { que aquele código cresça de maneira desordenada e confusa, a
02 ponto de tornar a evolução ou manutenção do projeto imprati-
03 private long entrada;
04
cável. Neste caso, o profissional deve parar de produzir código
05 private long saida; e avaliar se algum padrão de projeto se encaixa na refatoração
06 do mesmo, para permitir que o código possa evoluir de maneira
07 private Veiculo veiculo;
08
clara e organizada.
09 public double gerarConta() {
10 long periodoEmMinutos = obtemPeriodoDeUtilizacaoEmMinutos();
11 return calcularContaDeUtilizacao(periodoEmMinutos); Autor
12 }
13 Alex Radavelli
15 return (saida - entrada) / 1000 / 60;
[email protected]
16 } Desenvolvedor Java EE com mais de cinco anos de experiência.
17 Bacharel em Ciência da Computação e cursando MBA em Ge-
18 protected abstract double calcularContaDeUtilizacao(long periodoEmMinutos); renciamento de Projetos. Possui a certificação Oracle Certified Associate,
19
Java SE 7 Programmer.
20 protected Veiculo getVeiculo() {
21 return veiculo;
22 }
23 Links:
24 }
Artigo sobre os princípios SOLID.
http://butunclebob.com/ArticleS.UncleBob.PrinciplesOfOod
O desenvolvedor de software conta hoje com uma vasta docu-
mentação de padrões de projetos consolidados, que podem ajudar
a resolver problemas de maneira limpa e elegante. A adoção de
boas práticas também ajuda muito na criação de códigos bem
escritos. Mas como ponto de partida, é indispensável que o de-
senvolvedor tenha como uma das suas principais metas escrever Ajude-nos a manter a qualidade da revista!
o código pensando na manutenção e na evolução do mesmo, de

Elaborando projetos
com a Arquitetura
Orientada a Eventos
Evolua sua arquitetura de integração com os
conceitos da Event Driven Architecture
U
ma das maneiras de tentar estabelecer uma Fique por dentro
comunicação organizada e controlada entre
os componentes que formam o conjunto de Neste artigo apresentaremos um exemplo prático para demonstrar
sistemas de uma empresa/departamento seria utilizar o que é e como pode ser concebida uma Arquitetura Orientada a
a ocorrência de um fato, ou seja, um evento, pois desta Eventos. Para isso, implementaremos todas as partes relevantes de
forma teríamos a comunicação entre as partes mantida uma arquitetura completa de integração, incluindo componentes
com um baixo acoplamento, onde emissores e assinantes que compõem a Arquitetura Orientada Serviços (SOA). Em seguida,
estariam ligados apenas pela criação destes eventos. complementaremos nosso estudo abordando algumas ferramentas
Além dos eventos definirem o momento em que a que ajudam a conceber a EDA (Event Driven Architecture).
integração pode ocorrer, possuem as informações ne- Portanto, este artigo é útil para profissionais envolvidos em ambien-
cessárias que serão trocadas entre as peças, efetivando tes nos quais há necessidade de comunicação entre os participantes
as integrações. No acontecimento de um evento, ações (sistemas e componentes) que formam todo o conjunto de sistemas
podem ser tomadas pelos interessados sem a necessi- de software da empresa.
dade de qualquer tipo de atuação por parte do gerador
do evento.
Mas dentro do nosso contexto de tecnologia: o que
são estes eventos? A resposta é: depende! Apesar de ou a quantidade de execuções de um serviço no mês. Porém, na
a resposta parecer uma tentativa de ludibriar alguém maioria dos cenários, ao estabelecer uma arquitetura orientada
que você gostaria de convencer, ela realmente depende a eventos, a prioridade fica para a definição e captura de eventos
do contexto envolvido, ou seja, do modelo do domínio do negócio em questão, para que a empresa tenha mais benefícios
de negócio que estamos nos referindo. O evento é algo sobre o orçamento investido em tecnologia. Os eventos de natu-
relevante para o negócio da empresa, podendo ser: a reza técnica (como tempo de resposta) ganham maior prioridade
ocorrência de uma venda, o cadastro de um novo cliente, quando afetam diretamente os negócios da empresa.
a desistência de uma assinatura de revista, saques em Em uma arquitetura orientada a eventos, colocamos obviamente
locais geograficamente distantes do mesmo correntista, como ator principal o evento, estabelecendo assim o elo que cau-
ou o valor acumulado de pedidos realizados dentro de sará a integração entre os sistemas e componentes. Vale ressaltar
um período. ainda que um evento é autocontido, isto é, carrega consigo a
A definição do que pode ser considerado um evento informação de quando está preparado para ser disparado e quais
está muito mais orientada ao negócio da empresa do informações deve conter.
que a decisões técnicas. É claro que é possível também O que de fato a Arquitetura Orientada a Eventos (EDA – Event
estabelecer eventos de natureza técnica como, por Driven Architecture) deve promover é uma estrutura que possa
exemplo: o tempo médio da execução de transações estabelecer o alicerce de apoio à integração entre os sistemas e/ou

componentes do ambiente – usufruindo da ocorrência de evento específicos por sistema, desconhecimento de assinantes e acopla-
–, de forma que ainda se mantenha um baixo acoplamento entre mento mais alto entre as partes.
os participantes. Na Figura 1 podemos analisar uma ilustração de como seria um
Obviamente, assim como a definição de um modelo de domínio ambiente previamente concebido estabelecendo uma arquitetura
para a criação de uma aplicação, a modelagem de quais eventos orientada a eventos sem nenhuma organização e controle sobre
serão tratados deve fazer parte da análise da solução. Principal- as integrações.
mente porque estes eventos serão utilizados por vários sistemas
distintos da corporação, o que sugere colocá-los como parte do
modelo canônico, junto com as entidades de negócio e mensagens
comuns utilizadas pelos diferentes sistemas da empresa.
Dentro do ambiente de uma empresa com vários sistemas dis-
tintos, existem potenciais emissores e assinantes destes eventos.
Neste cenário, os emissores de eventos possuem as informações e
o contexto associado ao disparo, fazendo o evento existir de forma
consistente e válida para consumo por todos os interessados.
A complexidade para a definição de uma estrutura que possa
auxiliar o controle e organização entre emissores e assinantes de
eventos, estabelecendo uma Arquitetura Orientada a Eventos, vai
depender da maturidade de integração existente na empresa. É
nesse momento que a adoção e estabelecimento de uma Arquite-
tura Orientada a Serviços mostra suas vantagens. Ao temos um
mediador responsável por tratar as integrações, que centraliza
os serviços existentes no ambiente, criar uma arquitetura para
eventos se torna mais fácil.
Pelo barramento de serviços podemos identificar os serviços
expostos de sistemas que são potenciais emissores (origem de
eventos), deixando a responsabilidade de gerenciamento dos
eventos ao barramento de serviços. É possível até ir além. Ao re-
alizar o cruzamento de eventos de um ou mais sistemas, pode-se Figura 1. Integração entre sistemas utilizando eventos sem o apoio do barramento de serviços
estabelecer a criação de eventos mais complexos, que são derivados
do cruzamento de informações de outros, realizando o conceito Observe que os eventos são emitidos diretamente entre os sis-
de processamento de eventos complexos (CEP) – vide BOX 1. temas do ambiente por causa da falta de um mediador que tenha
o conhecimento e controle de todos que necessitam se integrar
BOX 1. Complex Event Processing no ambiente. Mesmo ainda sendo possível, o esforço será maior
para estabelecer e gerenciar este cenário.
Conceito que consiste na captura de informações no formato de eventos significativos que
Já na Figura 2 podemos observar uma ilustração de uma Ar-
acontecem na organização. Possibilita a realização de ações em tempo real como, por exemplo,
quitetura Orientada a Eventos funcionando com o apoio de um
identificar possíveis fraudes em andamento durante transações financeiras.
barramento de serviços de uma arquitetura SOA. Neste cenário,
o barramento é responsável por centralizar a emissão dos eventos
Os eventos são identificados e disparados durante a análise da do ambiente, realizando a inspeção do fluxo de informações que
“corrente” (stream) de informações que trafega no barramento está trafegando durante a execução dos serviços expostos pelos
durante as execuções de serviços que ocorrem nas transações de sistemas. Assim que identificado e criado um evento pelo barra-
negócio da empresa. Neste cenário de integrações é fácil perceber mento, os assinantes podem, em seguida, recebê-lo.
a simplificação que se obtém possuindo um ambiente SOA bem A forma como o barramento de serviços analisa os streams de
organizado, pois o controle das integrações já deve existir. O que informação, identifica e lança os eventos, é uma definição asso-
falta é aproveitar a oportunidade deste fluxo de informações ciada ao desenho da Arquitetura Orientada a Eventos. Apesar de
para identificar, criar e disparar eventos. Por outro lado, em um facilitar, não é obrigatório possuir já estabelecida uma arquitetura
ambiente onde as integrações entre sistemas não possuem um orientada a serviços para concretizar a arquitetura orientada a
controle consistente e o desenho destas integrações é normal- eventos. As duas arquiteturas podem se complementar. Portanto,
mente definido em salas de reuniões em que apenas duas partes se o SOA já estiver presente, é possível evoluir sua arquitetura de
estão presentes, aumenta a complexidade para estabelecer uma integração de serviços para se beneficiar dos eventos. Enfim, SOA
arquitetura orientada a eventos. O descontrole sobre a integração e EDA podem coexistir, mas não é necessário possuir SOA para
acaba se espalhando, resultando em: eventos duplicados, eventos implantar EDA, e vice-versa.

Elaborando projetos com a Arquitetura Orientada a Eventos
A característica comum de um ambiente nante (publish/subscriber). A outra opção informações desde o início do cenário tran-
SOA é a existência de consumidores e pro- seria utilizar ferramentas especializadas sacional, passando pelo sistema de vendas,
vedores, ao passo que em EDA possuímos no gerenciamento e tratamento de eventos, barramento de serviços, processamento de
assinantes e emissores. Como um dife- como o Esper, que iremos analisar em se- eventos, chegando até a visualização do
rencial, na arquitetura EDA os emissores guida no nosso cenário de exemplo. monitoramento das atividades de negócio.
não sabem quem são os seus assinantes, Desta maneira, podemos ter uma melhor
viabilizando assim uma integração de Arquitetura Orientada a Eventos na demonstração prática do papel dos eventos
acoplamento baixo. prática dentro desta arquitetura.
Na implementação de uma Arquitetura O nosso exemplo de Arquitetura Orienta- A visão lógica e completa da arquitetura
Orientada a Eventos, uma das opções mais da a Eventos provém de um cenário simples implementada nesta solução pode ser ob-
simples seria utilizar filas de mensagerias de e-commerce, onde uma loja on-line servada na Figura 3.
(normalmente disponíveis em ferramentas fornece seus produtos. Apesar de ser um Nesta solução temos os clientes realizan-
ESB), através de tópicos, colocando em cenário simples de compras via internet, do os pedidos no site da empresa ou com
ação o padrão de comunicação editor/assi- implementamos o fluxo de integração das representantes de vendas via telefone, o
que é ilustrado nos quadros número um e
dois. As compras são registradas através
do serviço Registar Pedido, que está expos-
to no Barramento de Serviços Corporativos
(ESB) da empresa (vide quadro número
três). O barramento realiza o roteamento
do request para o sistema atual, responsá-
vel na empresa por manusear e gerenciar
as transações de vendas (vide quadro
número quatro).
Até este momento observamos que não
temos nada muito diferente de uma Ar-
quitetura Orientada a Serviços, onde cada
sistema realiza a sua tarefa (motivo pelo
qual foi criado) e as integrações ocorrem
de forma controlada pelo Barramento
de Serviços. Neste são tratados todos os
aspectos de integração, desonerando os
sistemas de tarefas como: transformações,
enriquecimento, mapeamento, roteamen-
to, orquestração, protocolos e adaptadores
de tecnologia.
Os pedidos irão para o sistema deno-
Figura 2. Integração entre sistemas utilizando eventos com o apoio de um barramento de serviços (SOA)
minado SalesCenter, que após confirmar
com sucesso o registro da compra, eventos
de interesse da empresa nesta transação
de registro de compra serão capturados
e lançados pelo ESB para o componente
que realiza o processamento de eventos
(vide quadro número cinco). Aqueles que
tenham alguma relevância informacional
serão, também, armazenados em uma
base de dados (vide quadro número seis).
O sistema de monitoramento, denominado
MiniJS-BAM, faz uso destes dados para
apresentar informações das atividades de
negócio que estão ocorrendo na empresa
simultaneamente à ocorrência dos fatos
Figura 3. Visão holística da arquitetura lógica da solução de vendas on-line (vide quadros de número sete e oito).

Internet Front End Middleware Back End Intranet
Web Store TeleVendas ESB SalesCenter Eventos Database MiniJS-BAM
Clientes Executivos
Compras()
Registrar Compras()
Registrar Pedido de Compra()
Lançar Ev entos()
Armazenar Eventos()
Monitoração()
Ler Eventos()
Figura 4. Visão dinâmica da solução de vendas on-line
Possui a função de prover o Barramento de Serviço, conhecido pelo acrônimo em inglês ESB (Enterprise Service Bus). Este componente é
Mule ESB responsável por estabelecer o barramento dos fluxos de mensagens de integrações entre consumidores e provedores de serviços. A versão
(Anypoint Studio) utilizada é a Community Edition 4.1.1, representada nesta solução pelo IDE Anypoint Studio, que possui uma versão reduzida do Mule ESB
embutido para a execução dos fluxos.
Servidor de aplicação Java certificado para o Web Profile Java EE 6 da Apache, com alguns adicionais, por exemplo, em vez de termos dispo-
nível o EJB Lite, como diz a especificação Web Profile Java EE, temos uma implementação completa da API EJB. Utilizaremos este servidor de
Apache TomEE+
aplicação para fazer a implantação das nossas soluções Java, o SalesCenter e o MiniJS-BAM. O Apache TomEE+ é praticamente o OpenEJB
com “esteroides”. Ele nasceu e cresceu deste projeto. A versão utilizada na solução é a 1.7.1.
Banco de dados utilizado como repositório das informações capturadas durante o processamento dos eventos pelo Esper. Assim, mais tarde,
ferramentas e/ou aplicações interessadas em mostrar estas informações em uma perspectiva analítica, podem fazê-lo. Nesta base de dados
MySQL
armazenamos o resultado final do processamento dos eventos, apenas para que nossa solução MiniJS-BAM possa usufruir e montar seu
cockpit. Veremos mais informações sobre isso no nosso exemplo.
Componente de software para trabalhar com o processamento do fluxo de eventos, criado pela empresa EsperTech. Iremos analisar em mais
Esper
detalhes esta ferramenta a seguir.
Tabela 1. Tecnologias utilizadas na implementação da solução de vendas on-line
A apresentação provida pelo sistema de monitoramento ocorre das e o seu propósito básico perante a implementação desta
na forma de gráficos que, juntos, caracterizam uma espécie de solução.
cockpit. A partir dele, os executivos da empresa podem ter a visão A representação da arquitetura desta solução, agora traduzindo
do que acontece nos negócios de sua corporação – neste caso em do conceito para a tecnologia implementada, pode ser observada
tempo real –, o que pode trazer mais segurança e precisão para a na Figura 5. Nesta tradução, temos cada um dos elementos que
tomada de decisões, pois imagine como seria difícil pilotar um utilizamos na composição do cenário.
Boeing 777-200 sem nenhum painel de informações: sem saber A visão da implantação final de nossa solução pode ser vista no
a altitude, velocidade vertical, velocidade em relação ao solo, Diagrama de Deployment na Figura 6. Este digrama é muito útil
velocidade do ar, inclinação, posição dos flaps e a proa, e ainda para conciliar de forma organizada os dois mundos: software e
assim ter que conduzir um “negócio” de U$ 269.500.000,00. infraestrutura. Os nossos componentes de software (WAR e EAR,
Na Figura 4 podemos verificar em uma visão mais conven- neste caso), com as necessidades de infraestrutura (Apache TomEE,
cional, utilizando UML, a dinâmica de funcionamento desta Mule ESB e o MySQL). Infelizmente é pouco usado na prática.
solução. Observe que o fluxo das mensagens inicia no momento Um detalhe importante que podemos verificar nesse modelo
em que o cliente realiza a compra. Em um dado momento após de implantação e que passa despercebido em nossos modelos
a realização da compra, mais tarde ou mesmo simultaneamente, dinâmicos apresentados é a presença do JAR com o nome de Do-
os interessados em analisar as informações coletadas pelos main Model – Canonical. Neste componente estão presentes todos
eventos acessam via Intranet o MiniJS-BAM. os objetos que representam as entidades, mensagens e eventos
Para implantar o nosso exemplo de arquitetura orientada a comuns do modelo de domínio da empresa em questão. Portanto,
eventos, na Tabela 1 temos a lista das tecnologias seleciona- desta forma, mantemos o modelo canônico como um componente

o qual todos os demais podem (na verdade, deveriam) utilizar em devem ser utilizados pelos mecanismos de persistência e serializa-
suas soluções como dependência externa. ção/deserialização REST/XML. Como estas anotações não são intru-
Contido neste componente canônico, dentre outros, há dois sivas, no final as classes continuam sendo simples objetos POJO que
elementos comuns que ultrapassam a fronteira das aplicações da podem ser utilizados por qualquer classe Java, sem a necessidade
empresa, que são os objetos Order e Customer. Estes, respecti- da presença de um container, como um EJB para JPA.
vamente, representam as entidades Pedido de Compra e Cliente, Para controle dos projetos da organização, utilizamos a ferra-
pertencentes ao domínio de negócio da corporação. Na Listagem 1 menta Maven. Assim, este componente do modelo canônico estará
são demonstrados estes objetos. Perceba que eles possuem anota- presente no repositório Maven para ser utilizado pelos demais
ções JPA e JAXB, pois assim levam consigo as definições de como projetos de forma organizada e centralizada.
Figura 5. Elementos de tecnologia utilizados na concepção da solução
Mule ESB
Apache Tomee
«Services»
Message Flow s
«EAR» depends
«Customers Simulation» «use» SalesCenter
Front End
«use» depends
«JAR»
SoapUI depends :Domain Model
- Canonical
«JAR»
Domain Model - «WAR»
Canonical MiniJS-BAM
«JAR» depends
Esper Ev ent
Processing
«use»
Persistence
«Database»
«use»
MySQL
«use»
Figura 6. Diagrama de deployment da solução

Listagem 1. Exemplo de dois objetos canônicos contidos no componente Domain nada especialmente para trabalhar com soluções que envolvam
Model – Canonical. a Arquitetura Orientada a Eventos (EDA).
@Entity
O Esper permite a análise de eventos em séries, ou executar a
@Table(name=”Customer”) análise fazendo a correlação entre um grupo de eventos e, a partir
@XmlRootElement disto, realizar alguma ação no momento da captura destes eventos
public class Customer {
lançados. Neste contexto, o evento é um grupo de informações
@Id @GeneratedValue(strategy = GenerationType.AUTO) que são originárias de uma ou mais transações. E estas informa-
private Integer id; ções, contidas nos eventos, devem ser relevantes para o negócio
private String name;
private String city;
da empresa, algo que tenha semântica dentro do seu cenário de
private String country; negócio. Por exemplo, na lista a seguir temos alguns eventos que
podem ser do interesse da empresa:
public Customer(Integer id, String name, String city, String country) {
super();
• Quantidade de pedidos por minuto maior que R$ 2.000,00;
this.id = id; • Quantidade de pedidos nas principais cidades da região Sudeste;
this.name = name; • Valor total de pedidos nos últimos 60 minutos;
this.city = city;
• Valor total do maior pedido realizado nos últimos 60 minutos.
this.country = country;
}
A identificação do evento está relacionada ao cenário transa-
// Setters and Getters
cional onde se originam os dados, sendo deste cenário extraídas
}
as visões que a área de negócio possui interesse em analisar. No
@Entity entanto, é possível não só capturar eventos que sejam relevantes ao
@Table(name=”Orders”)
negócio, como também lançar eventos com visões de perspectiva
@XmlRootElement
public class Order implements Serializable { mais técnica como, por exemplo: o tempo de execução de uma
operação. Porém, para conseguir trabalhar com estes eventos de
@Id @GeneratedValue(strategy = GenerationType.AUTO)
natureza técnica, as informações devem ser capturadas durante a
private Integer number;
execução das transações de negócio, pois informações de negócio
@ManyToOne(cascade={CascadeType.PERSIST}) são naturalmente tratadas, mas os dados técnicos nem sempre são
@JoinColumn(name=”id_customer”)
capturados durante as transações, tornando mais tarde pratica-
private Customer customer;
mente impossível o lançamento de eventos de natureza técnica.
@OneToMany(cascade={CascadeType.PERSIST}, fetch = FetchType.EAGER)
@JoinColumn(name=”id_order”) EPL – Event Processing Language
private List<OrderItem> itens;
O Esper possui uma linguagem específica de domínio (DSL) para
@Temporal(TemporalType.TIMESTAMP) o tratamento de eventos. À primeira vista, bem semelhante ao SQL
@Column(name = “Date”) para bancos de dados. Ela é chamada de EPL, acrônimo do inglês
private Date dateTime;
Event Processing Language. Através desta linguagem filtramos o fluxo
public Order(Customer customer, List<OrderItem> itens) { de dados transacional detectando os eventos alvos de interesse,
super(); simultaneamente à sua ocorrência. No site do Esper temos dispo-
this.customer = customer;
this.itens = itens; nível uma referência completa da linguagem EPL, inclusive uma
} área onde é possível realizar testes de declarações EPL de forma
on-line. Os endereços estão disponíveis na seção Links.
// Setters and Getters
}
Sendo baseada em SQL, vários dos comandos da EPL são muito
semelhantes ou exatamente iguais ao da linguagem padrão de
bancos de dados, tais como: SELECT, FROM, WHERE, GROUP
Esper – O componente de processamento dos eventos BY e ORDER BY.
Um componente importante que deve ser destacado em nossa Alguns exemplos da sintaxe e funcionamento desta linguagem
solução é a ferramenta Esper, pois é esta que nos fornece os recur- estão ilustrados na Listagem 2.
sos para trabalharmos com o processamento e interpretação dos Para o Esper, os eventos são representados como classes POJO,
eventos lançados durante as transações. O Esper é uma aplicação que detêm todas as informações que estes devem encapsular.
criada em 2006 pela empresa EsperTech que possui diferentes No exemplo da Listagem 1 temos os seguintes eventos: StockTi-
versões disponíveis. Dentre essas versões, algumas são mais ro- ckEvent e OrderEvent, que nada mais seriam do que as classes
bustas e requerem o pagamento de licenças. No entanto, garantem demonstradas na Listagem 3. Desta forma, podemos fazer uso de
recursos mais avançados, como aspectos de alta disponibilidade. características da orientação a objetos, como herança e polimor-
Felizmente, a empresa disponibiliza também uma versão livre, fismo, para conceber uma cadeia de eventos que represente de
a qual adotaremos em nossa solução. Esta ferramenta é direcio- forma eficiente o domínio de negócio da empresa.

Vale ressaltar novamente a grande utilidade que o conceito podemos padronizar eventos (por exemplo: Quantidade Total
de Canônico pode trazer. Para criar um padrão de comunicação de Ordem de Compra no dia), pois tais eventos também serão de
entre os sistemas da empresa, entidades e mensagens podem ser uso corporativo, ou seja, não pertencem apenas a uma aplicação,
padronizadas dentro do barramento de serviços, onde os sistemas e sim à corporação.
se integram “falando” a mesma língua. E da mesma maneira que Em nossa solução é importante observar que o Esper atua como
podemos padronizar entidades comuns (por exemplo: Cliente), um filtro, coletando apenas informações que são alvos de interes-
se. Apenas estes dados, no formato de eventos, são direcionados
para o armazenamento na base de dados MySQL. Portanto, hipote-
Listagem 2. Exemplos de declarações da linguagem específica de domínio EPL da ticamente, se 100 milhões de transações passarem pelo Barramento
ferramenta Esper.
de Serviços, apenas uma fração destes dados, já processados no
// Busca o símbolo, o preço e o total do volume dos preços de movimentações da formato de eventos, serão selecionados e lançados pelo Esper como
// ação da IBM dentro objeto de análise. A quantidade de eventos, é claro, dependerá
// dos últimos 60 segundos
do desenho concebido para a solução em questão, o que definirá
select symbol, price, sum(volume) from StockTickEvent(symbol=’IBM’).win:time(60 sec)
também a existência da característica de integração por eventos
// Busca a média e o total do preço nas movimentações da ação da IBM dentro da arquitetura orientada a eventos. A Figura 7 representa uma
// dos últimos 10 elementos
ilustração do fluxo de dados deste cenário.
select avg(price) as avgPrice, sum(price) as sumPrice from
StockTickEvent(symbol=’IBM’).win:length(10) where symbol=’IBM’
Implementação da solução de Arquitetura Orientada a Eventos
// Busca o total das movimentações de ações dentro dos últimos 30 segundos, A partir de agora iremos abordar a implementação, características
// quando o volume for maior que 100
select count(*) from StockTickEvent.win:time(30 sec) where volume > 100 group e principal propósito de cada uma das camadas e componentes que
by symbol fazem parte da nossa solução exemplo de Arquitetura Orientada
a Eventos. Dentro de cada tópico, todo o código fonte relevante à
// Busca a cada 60 segundos o total dos preços dos Pedidos
// nos últimos 30 minutos principal função do componente será apresentado e explicado.
select sum(price) from OrderEvent.win:time(30 min) output snapshot every
60 seconds Front End – SoapUI
// Busca a cada 1.5 minutos as informações das movimentações de ações Para representar o cliente navegando no site e realizando as
// dentro das últimas cinco movimentações ocorridas compras, utilizamos a ferramenta SoapUI, que simula a execução
select * from StockTickEvent.win:length(5) output every 1.5 minutes destas chamadas. Como adendo, podemos aproveitar alguns
Listagem 3. Objetos POJO que representam para o Esper as entidades de eventos. recursos como, por exemplo, simular uma quantidade ininter-
rupta de chamadas ao nosso sistema de vendas. Esta ferramenta
public class StockTickEvent {
irá implementar a ação de enviar pedidos para o Barramento de
private String symbol;
private float price; Serviços Corporativos (ESB) da empresa.
private int volume; Na ferramenta SoapUI criamos um caso de teste onde são orga-
// setters e getters
nizados os requests que simulam as chamadas de clientes. Estes
}
requests se apresentam no formato JSON e possuem todas as
public class OrderEvent { informações de um registro de compra realizado por um cliente.
private float price;
// setters e getters
Utilizamos o formato JSON porque o Mule ESB (Barramento de
} Serviços) fornece um Serviço de Registro de Pedido via proto-
colo REST. Na Listagem 4 podemos conferir o conteúdo desta
mensagem enviada para o ESB.
Para garantir que as execuções dos requests
do caso de teste ocorram com sucesso, cria-
mos assertions no SoapUI para estes requests,
conferindo informações básicas que deveriam
estar presentes na resposta. Nestes assertions
validamos ao menos:
• Que o status do código de retorno HTTP seja
200 – OK;
• Que o conteúdo da resposta contenha o texto
“orderNumber”;
• Utilizamos uma declaração XPath procuran-
do pelo orderNumber na resposta e conferindo
Figura 7. Cenário do fluxo de dados e a filtragem dos eventos pelo Esper que seu valor seja maior que zero.

Dentro deste caso de teste temos dez requests que serão exe-
cutados. Eles possuem exatamente a mesma estrutura. Apenas
alteramos os valores dos atributos para simular diferentes pedidos
sendo realizados. Podemos observar a interface da ferramenta
SoapUI executando estes requests de registro de compra na
Figura 8.
Middleware – Mule ESB

No barramento temos exposto o serviço que permite o registro
de um pedido de compras no sistema de vendas SalesCenter. Para
isto, criamos um Fluxo de Mensagem conforme observamos na
Figura 9. Nesta imagem marcamos cada um dos elementos do
fluxo de mensagens com um número, para que passo a passo
possamos explicar o objetivo de cada componente.
No componente de número um do fluxo, rotulado de “HTTP/
REST”, criamos um canal de entrada HTTP que recebe os pedidos
em protocolo REST. Para este componente HTTP, atribuímos o
endereço http://localhost:9081/mule para receber os pedidos.
No componente de número dois, rotulado de “Receive Sales
Order”, está a classe Java que expõe efetivamente o endpoint
REST, realizando o suporte de implementação para o componente
HTTP anterior. Esta classe Java utiliza a API JAX-RS para expor um
serviço RESTful, onde no método receiveSalesOrder() recebemos
Figura 8. Caso de teste SoapUI com dez requests de criação de pedidos de compra o request com o Pedido de Compra encapsulado. Este código é
apresentado na Listagem 5.
Listagem 4. Mensagem REST no SoapUI que simula um request de registro de
uma compra.
Listagem 5. Classe Java que implementa o serviço RESTful (via API JAX-RS) para
{ recebimento dos registros dos pedidos de compras.
“order” :
{ @Path(“/rest”)
“customer” : { public class ReceiveSalesOrder {
“id” : 1,
“name” : “Ualter”, @POST
“city” : “Sao Paulo”, @Path(“/sales/order/”)
“country” : “Brasil” @Consumes({MediaType.APPLICATION_JSON})
}, @Produces({MediaType.APPLICATION_JSON})
“itens” : [ { public MessageRequest receiveSalesOrder(MessageRequest request) {
“product” : {
“id” : 1,
br.com.ujr.isus.canonical.Order order = request.getOrder();
“description” : “66 Audio BTS”,

“price” : 12.30,
return request;
“unit” : “UNITARIO”
}
},
“quantity” : 5
}, {
“product” : { @GET
“id” : 2, @Path(“/hello/{nome}”)
“description” : “MP3 PLAYER”, @Produces({MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON})
“price” : 250, public String hello(@PathParam(“nome”) String name, @QueryParam(“param”)
“unit” : “UNITARIO” String param) {
}, return “Hello “ + name + “, “ + param;
“quantity” : 2 }
}, {
“product” : { }
“id” : 3,
“description” : “BATTERIES”,
“price” : 5,
“unit” : “UNITARIO” No código podemos observar que fazemos uso de recursos
}, fornecidos pela API JAX-RS utilizando a anotação @Path(“/rest”)
“quantity” : 4
na classe e a anotação @Path(“/sales/order/”) no método. Desta
}]
} forma, definimos que a URL final de comunicação com o barra-
} mento será: http://localhost:9081/mule/rest/sales/order.

Figura 9. Fluxo de mensagem do serviço de registro de pedido de compras exposto no barramento
Esta URL é o endereço utilizado pelo caso de teste do SoapUI O componente de número quatro é uma referência a um subflow,
explicado no tópico anterior. um outro fluxo de mensagem que deve ser chamado neste momen-
Na sequência do fluxo temos o componente de número três, de to. O objetivo deste subflow é realizar a chamada ao provedor do
nome “Save Order to Variable”. Neste elemento temos uma classe serviço, o sistema que registra os pedidos de compra.
Java a qual o Mule ESB executa durante o fluxo da mensagem, Entrando no subflow, de nome SendOrderToSalesCenter, temos
passando para ela todo o contexto de informações. Isto permite o componente de número cinco, que realiza a chamada HTTP/
a realização de algum tratamento dos dados sendo trafegados REST ao sistema SalesCenter. Ele executa o request ao endereço
utilizando código Java. A função deste componente, neste caso, é http://localhost:8083/SalesCenter-Web/rest/order/register/, no qual
apenas armazenar em memória o objeto Order (Pedido de Com- está exposto o serviço de Registro de Compras no protocolo
pra) original que foi enviado no request executado pelo cliente. REST. Este web service RESTful encontra-se em um Servidor de
Para isso, ele converte a String JSON recebida para o objeto do Aplicação Java EE Apache TomEE+, o qual iremos verificar du-
tipo Order e, em seguida, o armazena como uma variável do rante a análise da aplicação SalesCenter nos tópicos a seguir. No
Fluxo de Mensagem. O código da classe SaveOrderToVariable é momento, desempenhando o papel de barramento de serviços,
apresentado na Listagem 6. precisamos entender apenas que este é o provedor do serviço
que registra a ordem de compra. Este serviço recebe o Pedido
de Compra (Order) no protocolo REST e nos retorna um número
Listagem 6. Classe Java executada pelo componente “Save Order to Variable” no
fluxo de mensagem do ESB. gerado caso a transação tenha sido executada com sucesso.
Continuando no subflow SendOrderToSalesCenter, temos o
public class SaveOrderToVariable implements Callable {
componente de número seis, nomeado “Save Order Response to
@Override Variable”, outra classe Java que tem a oportunidade de interagir
public Object onCall(MuleEventContext eventContext) throws Exception { com a mensagem. Neste caso, não alteramos em nada a mensagem.
String restOrder = eventContext.getMessage().getPayloadAsString();
ObjectMapper om = new ObjectMapper(); Apenas a interceptamos para armazenar a reposta do SalesCenter
om.configure(Feature.UNWRAP_ROOT_VALUE, true); em variáveis do fluxo de mensagem do Mule ESB. Na Listagem 7
Order order = om.readValue(restOrder, Order.class); podemos observar o código desta classe.
eventContext.getMessage().setInvocationProperty(“Order”, order);
return eventContext.getMessage().getPayload(); As informações retornadas após a execução da transação do
} pedido de compras estão encapsuladas no objeto Java de nome
ResponseSaveOrder, que pertence ao nosso modelo canônico,
}
presente no JAR mencionado anteriormente.

Neste objeto temos a data e o número da ordem gerado, que Listagem 8. Classe Java utilizada no componente “Build Message Response” para
armazenamos separadamente em variáveis do nosso fluxo de compor a reposta do serviço de Registro de Compras.
mensagem. public class CompoundMessageResponseObject extends AbstractMessage-

Transformer {
Listagem 7. Classe Java executada pelo componente “Save Order Response to @Override
Variable” no fluxo de mensagem do ESB.
public Object transformMessage(MuleMessage message, String outputEncoding)
throws TransformerException {
public class SaveOrderResponseToVariables implements Callable{

String uuid = “”;
@Override
public Object onCall(MuleEventContext eventContext) throws Exception { String orderNumber = “”;
String date = “”;
String jsonString = eventContext.getMessageAsString(); try {
ObjectMapper mapper = new ObjectMapper(); uuid = message.getPayloadAsString();
mapper.configure(DeserializationFeature.UNWRAP_ROOT_VALUE, true); orderNumber = message.getInvocationProperty(“orderNumber”);
ResponseSaveOrder responseSaveOrder = mapper.readValue date = message.getInvocationProperty(“date”);
(jsonString, ResponseSaveOrder.class); } catch (Exception e) {
e.printStackTrace();
Order order = (Order)eventContext.getMessage().getInvocationProperty(“order”); }
order.setDateTime(responseSaveOrder.getDate()); return new MessageResponse(new Integer(orderNumber),uuid,date);
}
eventContext.getMessage().setInvocationProperty(“responseSaveOrder”, }
responseSaveOrder);
eventContext.getMessage().setInvocationProperty(“orderNumber”,
String.valueOf(responseSaveOrder.getNumber()));
eventContext.getMessage().setInvocationProperty Antes de retornar a resposta, no entanto, iremos realizar um
(“date”, responseSaveOrder.getDate().toString());
passo que não impacta mais no término transacional deste fluxo
return eventContext.getMessage().getPayload(); de mensagens, que é lançar o evento ocorrido para a nossa ins-
} tância do Esper. Isto é realizado através de um conector específico
} feito para a comunicação com o Esper. Estamos nos referindo ao
componente de número nove, denominado Esper.
Este componente de conexão com o Esper não está presente na
O componente de número sete trata-se de um script Groovy, versão livre do Anypoint (Mule ESB) disponível para a comu-
que gera um código aleatório, “praticamente” único, utilizando nidade. Sendo assim, é necessária a instalação deste conector
o padrão de identificação UUID. Retornamos este número ao executando os seguintes passos:
consumidor do serviço de Registro de Pedido com uma espécie • No Anypoint Studio, navegue pelo menu seguindo o caminho:
de Ticket que ele pode utilizar para referenciar mais tarde um Help > Install New Software;
determinado request feito ao serviço fornecido pelo Mule ESB, • Na janela seguinte, escolha a opção Anypoint Connectors Update
caso seja necessário. Rotulamos este componente de “Generate Site no campo Work with;
UUID for Request”. • Procure pelo módulo Mule Esper Module Mule Studio Extension
Seguindo para o componente de número oito, rotulado de “Build nas opções de Community.
Message Response”, encontramos um componente transformador • Na Figura 10 podemos verificar o conector que deve ser instalado.
de informações de mensagens, implementado com uma classe
Java. Neste ponto, todas as informações trafegando pelo fluxo de Após a instalação, precisamos criar uma configuração para o
mensagem serão passadas para uma classe Java, que irá reunir conector no Fluxo de Mensagem, a qual será utilizada por todas
todas as informações consideradas relevantes que coletamos as instâncias do componente Esper, seja para lançar eventos ou
durante todo o fluxo para compor a mensagem de resposta para para interceptá-los. Para isto, criamos um arquivo XML de nome
o nosso consumidor. Na Listagem 8 temos o código da classe esper-config.xml, apresentado na Listagem 9, e adicionamos este
CompoundMessageResponseObject. Observe que no final re- arquivo ao fluxo de mensagem como um Global Element.
tornamos o objeto MessageResponse, criado especialmente para Nas primeiras linhas desta configuração informamos ao Esper
ser a reposta deste fluxo de mensagens, fazendo parte do contrato quais são os tipos de eventos que poderão existir, e como men-
do serviço exposto. cionado anteriormente, são apenas classes POJO Java. Em nosso
Neste ponto da análise do fluxo chegamos ao último componente exemplo, informamos que as seguintes classes são tipos de eventos
do nosso subflow SendOrderToSalesCenter. Este realiza uma tarefa que poderão ser lançados ou interceptados:
importante para a nossa arquitetura orientada a eventos. No en- • OrderPedido;
tanto, do ponto de vista transacional, já temos tudo finalizado: o • TotalOrderByCity;
pedido foi gravado com sucesso no sistema SalesCenter e temos • TotalOrderByDate;
todas as informações para retornar ao consumidor. • TotalOrderByTimeFrame.

Em seguida, configuramos um dos adaptadores de entrada e

saída do Esper, que em nosso exemplo iremos utilizar apenas
como adaptador de saída, sendo responsável pela conexão com a
base de dados MySQL para armazenar as informações dos eventos
capturados. Para tanto, configuramos o adaptador com.espertech.
esperio.db.EsperIODBAdapterPlugin. Na configuração deste
plugin, preparamos uma conexão JDBC na seção jdbc-connection
para a comunicação com o MySQL.
No arquivo de configuração do Esper, esper-config.xml, as seções
que possuem as tags <upsert> são onde configuramos as execu-
ções de Insert ou Update na base de dados dos eventos capturados
pelos conectores Esper. Para cada um destes comandos upserts,
temos que, no mínimo, prover as seguintes informações:
• connection: Conexão JDBC com o MySQL;
• stream: Tipo do evento capturado a ser armazenado;
• name: Nome para o Upsert;
• table-name: Nome da tabela na base de dados MySQL que irá
armazenar os dados do evento capturado em questão;
• executor-name: Configuração do executor que definirá a quan-
tidade de threads utilizada para este Upsert;
Figura 10. Instalação no AnyPoint Studio do conector para comunicação com o Esper • retry: Quantidade de tentativas a serem feitas em caso de falha;
Listagem 9. Configuração da instância do Esper para os conectores do Mule ESB lançar ou interceptar eventos.
<esper-configuration xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” table-name=”TableTotalOrderByDateStream”

xmlns=”http://www.espertech.com/schema/esper” executor-name=”queue2” retry=”3”>
xsi:schemaLocation=” <keys>
http://www.espertech.com/schema/esper <column property=”date” column=”DATE” type=”integer”/>
http://www.espertech.com/schema/esper/ </keys>
esper-configuration-2.0.xsd”> <values>
<event-type name=”OrderPedido” class=”br.com.ujr.isus.canonical.Order”/> <column property=”total” column=”QTDE” type=”integer”/>
<event-type name=”TotalOrderByCity” class=”br.com.ujr.isus.canonical.events </values>
.TotalOrderByCity”/> </upsert>
<event-type name=”TotalOrderByDate” class=”br.com.ujr.isus.canonical.events <upsert connection=”esperEvents” stream=”TotalOrderByTimeFrame”
.TotalOrderByDate”/> name=”UpdateTotalOrderByTimeFrameStream” table-name=”TableTotalOrderBy
<event-type name=”TotalOrderByTimeFrame” class=”br.com.ujr.isus.canonical TimeFrameStream” executor-name=”queue3” retry=”3”>
.events.TotalOrderByTimeFrame”/> <keys>
<plugin-loader name=”EsperIODBAdapter” class-name=”com.espertech.esperio <column property=”timeFrame” column=”TIMEFRAME” type=”varchar”/>
.db.EsperIODBAdapterPlugin”> </keys>
<config-xml> <values>
<esperio-db-configuration> <column property=”qtdeTotal” column=”QTDE” type=”integer”/>
<jdbc-connection name=”esperEvents”> </values>
<drivermanager-connection class-name=”com.mysql.jdbc.Driver” <values>
url=”jdbc:mysql://localhost:3306/dbevents” user=”esper” password=”esper” /> <column property=”valueTotal” column=”VALUE” type=”decimal”/>
<connection-settings auto-commit=”true” catalog=”dbevents”/> </values>
</jdbc-connection> </upsert>
<executors>
<upsert connection=”esperEvents” stream=”TotalOrderByCity” <executor name=”queue1” threads=”3”/>
name=”UpdateTotalOrderByCityStream” </executors>
table-name=”TableTotalOrderByCityStream” <executors>
executor-name=”queue1” retry=”3”> <executor name=”queue2” threads=”3”/>
<keys> </executors>
<column property=”city” column=”CITY” type=”varchar”/> <executors>
</keys> <executor name=”queue3” threads=”3”/>
<values> </executors>
<column property=”total” column=”QTDE” type=”integer”/> </esperio-db-configuration>
</values> </config-xml>
</upsert> </plugin-loader>
<upsert connection=”esperEvents” stream=”TotalOrderByDate”
name=”UpdateTotalOrderStream” </esper-configuration>

• keys: Nesta seção devem ser informa-
dos todos os campos que formam a chave
primária da tabela/evento. A informação
destes campos será processada nas cláu-
sulas WHERE pelo adaptador Esper, defi-
nindo por exemplo, se será uma instrução
SQL de Update ou de Insert que deve ser
executada;
• values: Nesta seção informamos todo
o restante das informações do evento,
que estão também na tabela da base de
dados.
Com o arquivo de configuração pronto,

podemos preencher as propriedades do Figura 11. Configuração do componente de comunicação Esper no fluxo de mensagem do Mule ESB
componente Esper. Na Figura 11 obser-
vamos quais são os atributos necessários.
Além da referência à configuração do
Esper (Config Reference), escolhemos a
operação (Operation) que deve ser realiza-
da e qual será o payload enviado. Neste
ponto do fluxo, estamos lançando um
evento que se trata da ordem de compra
realizada. Por isso, informamos a ope-
ração Send, e no Payload (Event Payload
Reference) passamos o caminho onde está
a informação (evento) a ser lançada. Em
passos anteriores, armazenamos como
uma variável do Fluxo de Mensagem a
Ordem de Compra. Neste momento esta-
mos enviando-a para o Esper utilizando
a literal #[flowVars.Order].
Neste passo do fluxo estamos apenas in-
formando a ocorrência de um fato ao Esper
(Ordem de Compra realizada). Veremos
mais adiante como realizar a configuração
dos filtros no Esper, os quais irão proces-
sar, identificar, criar e lançar determinados
eventos de interesse da empresa.
No componente de número dez, para Figura 12. Fluxos de Mensagens contendo o componente Esper para processamento dos eventos
finalizar a transação de ordem de compra,
retornamos ao fluxo principal, denomina- tamos ao Esper para interceptar, processar um elemento do Esper configurado para
do “REST-Endpoint”. Aqui executamos o e lançar os eventos de nosso interesse. processar eventos, seguido de um compo-
último passo antes de retornar a resposta Em nosso exemplo iremos trabalhar nente simples de Log.
para o consumidor. Neste componente, o com seis eventos, que serão explicados As configurações das instâncias destes
objeto MessageResponse é transformado em mais detalhes no tópico “Configura- componentes Esper inseridos nos seis
então em uma String JSON que será o re- ção de componentes Esper”. Para estes Fluxos de Mensagem são quase equiva-
torno do request realizado no início pelo eventos serem lançados, criamos outros lentes. Praticamente apenas um atributo
cliente ao serviço Registro de Compras. seis Fluxos de Mensagem muito simples é distinto entre eles, e esta diferença está
Neste momento já temos realizada a no Mule ESB. Em cada um deles utiliza- no comando EPL que realiza o processa-
transação de compra do cliente e a infor- mos o mesmo componente com atributos mento e lançamento do evento. A sintaxe e
mação do evento Ordem de Compra para o de configuração diferentes. Na Figura 12 objetivo da EPL foram abordados no tópico
Esper. Vamos verificar agora como requisi- podemos verificar estes fluxos com apenas “EPL – Event Processing Language”.

Figura 13. Componente Esper configurado para leitura dos eventos realizando o processamento das informações
Na Figura 13 podemos observar como é a configuração de um - EPL:

componente Esper que irá manipular os eventos que estamos - insert into TotalOrderByTimeFrame select ‘10secs’ as timeFrame,
interessados, realizando o processamento das informações sum(totalOrder) as valueTotal, count(*) as qtdeTotal from Order-
enviadas. Pedido.win:time(10 sec).
Informamos no campo Operation que este componente irá reali- - Objetivo:
zar a inspeção dos eventos que são lançados ao Esper utilizando - Capturar o total do valor e da quantidade de pedidos
a opção Listen. A configuração mais relevante e que justifica realizados dentro de uma janela de tempo dos últimos 10
a existência de seis diferentes componentes Esper é o atributo segundos.
Statement, que recebe um comando EPL. Com esses comandos - Resultado:
instruímos ao Esper o que deve ser processado para eventual- - Conforme configuração realizada no Upsert que apon-
mente lançar um determinado evento, se a condição no script ta para o evento/stream TotalOderByTimeFrame, as
EPL for encontrada. informações do valor total dos pedidos e quantidade
de pedidos efetuados nos últimos 10 segundos serão
Configuração de componentes Esper gravadas na tabela TableTotalOrderByTimeFrameStream.
Para cada uma das configurações feitas nestes componentes Es- Observe que colocamos a literal ‘10secs’ como valor para
per, vamos inspecionar e analisar as instruções EPL utilizadas: o campo timeFrame. Assim rotulamos essa informação
• Componente: Total Order By City Today para gravação na tabela.
- EPL: • Componente: Total Order Last 30 Secs
- insert into TotalOrderByCity select distinct customer.city as - EPL:
city, count(*) as total from OrderPedido.win:time(1 day) group - insert into TotalOrderByTimeFrame select ‘30secs’ as timeFrame,
by customer.city. sum(totalOrder) as valueTotal, count(*) as qtdeTotal from Order-
- Objetivo: Pedido.win:time(30 sec).
- Capturar o total de Pedidos por cidade dentro do período - Objetivo:
de um dia. - Capturar o total do valor e da quantidade de pedidos
- Resultado: realizados dentro de uma janela de tempo dos últimos 30
- Conforme a configuração do plugin Esper de I/O de segundos.
base de dados no arquivo esper-config.xml, as informa- - Resultado:
ções capturadas por esta EPL serão gravadas na tabela - Neste componente escrevemos uma EPL que realiza a
TableTotalOrderByCityStream do MySQL, no caso: cidade mesma tarefa do componente explicado anteriormente. As-
e total de pedidos, dentro da janela de um dia. Observe sim, o evento/stream, tabela e o resultado das informações
que estamos realizando a inserção de dados no evento/ capturadas são os mesmos. O que muda é que solicitamos
stream TotalOrderByCity, configurado no esper-config uma janela de tempo diferente, de 30 segundos.
.xml. Nesta configuração, o Upsert que trata do evento • Componente: Total Order Today
TotalOrderByCity realizará a associação deste evento - EPL:
com a tabela da base de dados em que serão registradas - insert into TotalOrderByDate select distinct date as date, count(*)
as suas informações. as total from OrderPedido.win:time(1 day) group by date.
• Componente: Total Order Last 10 Secs - Objetivo:

- Capturar o total da quantidade de pedidos realizados Os componentes do Esper agem posteriormente, recebendo
diariamente. o evento Pedido, lançado na parte transacional, processando e
- Resultado: filtrando os eventos/stream de interesse da empresa a serem
- Conforme a configuração realizada no Upsert que aponta capturados como, por exemplo, o total de pedidos nos últimos
para o evento/stream TotalOderByDate, as informações 30 segundos. Essa divisão entre o escopo transacional e o escopo
da quantidade total de pedidos efetuados por dia serão analítico deste cenário pode ser observada na Figura 14.
gravadas na tabela TableTotalOrderByDateStream.
• Componente: Higher Order Last 60 secs
- EPL:
- insert into TotalOrderByTimeFrame select ‘HigherOrder60secs’
as timeFrame, max(totalOrder) as valueTotal, count(*) as qtdeTotal
from OrderPedido.win:time(60 sec).
- Objetivo:
- Capturar o pedido de maior valor efetuado no último
minuto.
- Resultado:
- Novamente utilizamos o mesmo evento/stream (TotalOr-
derByTimeFrame) para configurar um Upsert que irá gravar
na tabela TableTotalOrderByTimeFrameStream as informações
do evento. Nesta captura solicitamos o pedido de maior valor
realizado nos últimos 60 segundos e o gravamos na tabela
com o rótulo ‘HigherOrder60secs’ no campo timeFrame.
• Componente: Sum Order Value
- EPL: Figura 14. Divisão entre os escopos transacional e analítico do cenário desta solução
- insert into TotalOrderByTimeFrame select ‘SumOrderValue’ as
timeFrame, sum(totalOrder) as valueTotal, count(*) as qtdeTotal Back-End – SalesCenter
from OrderPedido. Por trás do barramento, portanto desacoplado de seus consu-
- Objetivo: midores, está a aplicação atualmente responsável por gerenciar
- Capturar a soma de todos os valores e a quantidade de os pedidos de compras da empresa, conhecida como SalesCenter.
pedidos realizados. Trata-se de uma aplicação Java EE distribuída implantada em um
- Resultado: servidor de aplicação Apache TomEE+.
- Como resultado, geramos o evento/stream TotalOrder- A aplicação é composta por um arquivo EAR contendo dois
ByTimeFrame. No processamento da EPL, capturamos a módulos:
soma do total de todos os pedidos e também a quantidade • SalesCenter-Services.JAR: Módulo onde estão os serviços provi-
de pedidos realizados em todo o tempo decorrido desde o dos pela aplicação;
início da execução da aplicação. Para criarmos a identificação • SalesCenter-Web.WAR: Módulo web que provê as interfaces de
dos registros dos eventos gravados na tabela, utilizamos o Front-End Intranet necessárias aos usuários da aplicação. Em
rótulo ‘SumOrderValue’ como chave da unicidade destes nosso cenário, este módulo não tem relevância, já que fazemos o
registros de eventos. Assim, através do campo timeFrame, uso apenas dos serviços expostos pela aplicação.
presente na tabela da base de dados, podemos identificar as
informações capturadas com tal rótulo para o evento ‘Soma Para compreender melhor o papel desta aplicação, vamos ana-
do Valor e Quantidade Total de Ordens de Compra’. lisar o código construído que representa os serviços providos
pelo SalesCenter, os quais são acessados pelo Mule ESB em nosso
A linguagem EPL fornece um acervo completo de recursos para estudo de caso. Comecemos pela interface criada para definir
a configuração do evento/stream a ser processado. Nestes exem- o contrato do que um serviço do SalesCenter deve prover. Esta
plos vimos apenas uma pequena demonstração do que é capaz de interface está representada na Listagem 10 e como podemos ve-
prover esta linguagem de processamento de eventos do Esper. rificar, temos um código muito simples, com apenas um método
Com isso, finalizamos a inspeção do Fluxo de Mensagem que permite o registro de uma ordem de serviço.
que expõe no barramento o Serviço de Registro de Pedidos Como próximo passo, iremos analisar a implementação desta
para os consumidores. A parte transacional foi encerrada no interface, ISalesCenterService. A classe que a implementa tem
momento em que o Pedido é gravado com sucesso pelo prove- como função executar a transação de registro do pedido, codifi-
dor do serviço, o sistema SalesCenter, que retorna a resposta cação esta que é realizada por um EJB Stateless, apresentado na
ao Mule ESB. Listagem 11. Este EJB recebe o request utilizando o protocolo REST

(JAX-RS) com o objeto Order no formato JSON. Em seguida, com interessados em receber nesta injeção contém um qualificador
a referência a outro EJB, SalesCenterFacade, executa o registro que deve ser considerado no processamento desta dependência.
do pedido e retorna a resposta ao cliente. Nas Listagens 13 e 14 temos, respectivamente, o código fonte da
interface ISalesRepository e da classe SaleRepositoryQualifiers.
Listagem 10. Interface de definição do contrato de um serviço do SalesCenter.
Esta última possui os qualificadores criados para identificação
precisa da classe alvo de nosso interesse que será instanciada para
public interface ISalesCenterService { a injeção da dependência. Esta classe injetada é a que realiza o

public ResponseSaveOrder placeOrder(Order order); contrato de ISalesRepository.
} Listagem 12. EJB que implementa o componente Facade da aplicação SalesCenter.
Listagem 11. EJB Stateless que realiza o contrato de um serviço do SalesCenter. @Stateless
public class SalesCenterFacade {
@Stateless
public class SalesCenterService implements ISalesCenterService { @Inject @MySQL
ISaleRepository repository;
private final static Logger LOGGER = LoggerFactory.getLogger
(SalesCenterService.class); public Order registerSale(Order order) {
return repository.save(order);
@EJB }
private SalesCenterFacade facade;
public boolean getStatusSale(Order order) {
@POST return repository.checkStatus(order);
@Path(“/order/register/”) }
@Consumes(MediaType.APPLICATION_JSON)
@Produces({MediaType.APPLICATION_JSON, MediaType.APPLICATION_XML}) public boolean cancelSale(Order order) {
public ResponseSaveOrder placeOrder(Order order) { return repository.cancel(order);
LOGGER.info(“Receiving order from customer: \”{}\””,order.getCustomer() }
.getName());
facade.registerSale(order); }
Integer orderNumber = order.getNumber();
Date date = order.getDateTime(); Listagem 13. Interface que estabelece as funções de persistência do SalesCenter.
LOGGER.info(“Generated order \”#{}\””,orderNumber.toString());
return new ResponseSaveOrder(orderNumber,date); public interface ISaleRepository {
}
public abstract Order save(Order sale);
@GET public abstract boolean cancel(Order sale);
@Path(“/hello/{nome}”) public abstract boolean checkStatus(Order sale);
public String ping(@PathParam(“nome”) String name) {
return “Hello there, “ + name + “!”; }
}
Listagem 14. Qualificadores criados para classificação de classes que implemen-
} tam a interface ISalesRepository.
public class SaleRepositoryQualifiers {

O próximo objeto que irá receber o request, seguindo o fluxo @Qualifier
da aplicação SalesCenter, é o SalesCenterFacade, chamado pelo @Retention(RUNTIME)
@Target({TYPE, METHOD, FIELD, PARAMETER})
serviço SalesCenterService. O SalesCenterFacade é um EJB Sta- public @interface MySQL {}
teless que centraliza todos os serviços disponíveis pelo modelo
de domínio da aplicação. Dentre eles está o registro da ordem do @Qualifier
@Retention(RUNTIME)
pedido. Na Listagem 12 temos o código fonte desta classe. Para @Target({ TYPE, METHOD, FIELD, PARAMETER })
colocar em exposição o serviço de Registro de Ordem de Compra, public @interface Fake {}
o disponibilizando para os consumidores, precisamos apenas }
utilizar o método registerSale() do SalesCenterFacade.

Neste EJB utilizamos o recurso de injeção de dependência Criamos estes qualificadores para a injeção de dois tipos de
usando a anotação @Inject, provido pela API CDI da plataforma ISaleRepository: um “falso”, o qual não persiste as informações
Java EE, para realizar a associação do SalesCenterFacade com a e retorna sempre as mesmas respostas inventadas (mocks), e a
instância da classe que implementa a interface ISalesRepository. outra implementação sendo a “verdadeira” do ISaleRepository.
Esta interface estabelece o contrato de persistência dos serviços Esta última implementação é a classe MySQLDatabase, que leva
do SalesCenter. consigo a anotação @MySQL, que efetiva a gravação dos pedi-
Através da anotação @MySQL presente em SalesCenterFacade, dos em uma base de dados MySQL. Esta classe é apresentada na
informamos ao container CDI que a implementação que estamos Listagem 15.

Listagem 15. Classe que realiza o contrato de persistência do SalesCenter e registra as informações no MySQL.
@MySQL return false;

public class MySQLDatabase implements ISaleRepository { }
private final static Logger LOGGER = LoggerFactory.getLogger(MySQLDatabase.class); private void checkPersistenceProduct(Order sale, EntityManager em) {
List<OrderItem> ordersItens = new ArrayList<OrderItem>();
public Order save(Order sale) { for(Iterator i = sale.getItens().iterator(); i.hasNext();) {
EntityManagerFactory factory = null; OrderItem item = (OrderItem)i.next();
try { if ( item.getProduct().getId() != null ) {
factory = Persistence.createEntityManagerFactory(“SalesCenterJPA”); Product product = em.find(Product.class, item.getProduct().getId());
EntityManager em = factory.createEntityManager(); if ( product == null ) {
product = item.getProduct();
em.getTransaction().begin(); product.setId(null);
/** em.persist(product);
* Persist Customer }
*/ item.setProduct(product);
checkPersistenceCustomer(sale, em); } else {
/** Product product = item.getProduct();
* Persist Products em.persist(product);
*/ item.setProduct(product);
checkPersistenceProduct(sale, em); }
sale.setDateTime(Calendar.getInstance().getTime()); ordersItens.add(item);
em.persist(sale); }
em.getTransaction().commit(); sale.setItens(ordersItens);
}
} catch (Exception e) {
LOGGER.error(e.getMessage(), e); private static void checkPersistenceCustomer(Order sale, EntityManager em) {
throw new RuntimeException(e); if (sale.getCustomer().getId() != null) {
} finally { Customer c = em.find(Customer.class, sale.getCustomer().getId());
factory.close(); if (c == null) {
} c = sale.getCustomer();
return sale; c.setId(null);
} em.persist(c);
}
public boolean cancel(Order sale) { sale.setCustomer(c);
return false; }
} }
public boolean checkStatus(Order sale) { }
Podemos observar que além de implementar e cumprir o contra- É importante mencionar que esta mini aplicação de monito-
to da interface ISalesRepository, MySQLDatabase contém a ano- ramento de atividades de negócio não foi testada em ambiente
tação do qualificador @MySQL. Esta classe grava as informações produtivo com alta escala e sob alto estresse de carga. Como pre-
do pedido que chegam via o objeto Order utilizando a API JPA. viamente apontado, é uma aplicação ilustrativa para demonstrar
Lembre-se que a classe Order provém do componente (JAR) que o resultado de nossa solução, criada apenas para este contexto.
compõe o modelo canônico de nossa corporação, e estas classes Para ambientes mais robustos e complexos, existem no mercado
estão com as configurações de anotações para uso do JPA. soluções prontas que são coesas às famílias de produtos de seus
Com isso chegamos ao final da análise da parte transacional de fabricantes.
nossa solução. No próximo tópico vamos analisar um pequeno Por exemplo: para a IBM Integration Bus (outrora conhecida
exemplo de monitoramento das atividades de negócio. Para isso, como IBM WebSphere Message Broker) ferramenta ESB da
utilizaremos uma simples solução web – que faz o uso de Java- IBM, temos a opção de utilizar o IBM Business Monitor como
Script como Front-End – para ilustrar em tempo real a captura de ferramenta de monitoração de atividades de negócio. As duas
eventos durante as transações. ferramentas possuem recursos que permitem a integração entre
elas provida pelo fabricante. Assim, na maioria das vezes, temos
Monitoramento – MiniJS-BAM apenas o trabalho de configurar a comunicação entre estas fer-
Criamos esta simples aplicação web/JavaScript somente para ramentas e, é claro, talvez a parte mais difícil, implementar uma
tornar mais dinâmica e interessante a demonstração de nossa solução de arquitetura que faça uso intensivo destes Monitores
solução baseada em arquitetura orientada a eventos. De fato, de Negócio.
é nessa parte que reside o “marketing” de todo o esforço, pois A aplicação MiniJS-BAM é composta por apenas um arquivo
esta é a “janela” que é apresentada aos senhores de negócio, que WAR (Web Archive) Java EE, que possui como principais compo-
investem seu orçamento em tecnologia. nentes os seguintes itens:

• MiniJsBamController: Servlet que recebe as requisições via a comunicação com a base de dados, executando as queries de
protocolo HTTP, no formato REST, realiza as consultas e retorna consulta nas tabelas em que foram gravadas as informações
os resultados no mesmo formato; durante a captura dos eventos pelo Esper, e para isto ela utiliza
• MiniJSBamServices: Classe Java comum (POJO) que executa a API JDBC.
as consultas na base de dados MySQL via JDBC, respondendo as
requisições enviadas pelo Servlet Controller. Solução em Ação
Com todas as peças de nossa solução ligadas e funcionando,
O código fonte do MiniJsBamController é apresentado na podemos ver em ação o monitoramento executando enquanto os
Listagem 16. Esta classe desempenha o papel de controlador requests de pedidos chegam ao nosso barramento de serviços.
principal, que recebe as requisições dos clientes que desejam Os componentes e as soluções neles implantadas que devem
informações sobre eventos já capturados durante a execução de estar funcionando são:
transações de negócio. Este servlet é disponibilizado com quatro • Mule ESB – Responsável pela disponibilização do Serviço Re-
diferentes padrões de URL para receber as chamadas dos clientes gistro de Pedidos;
(podemos observar o atributo urlPatterns na anotação @Web- • Apache TomEE+ – Responsável por prover o ambiente de
Servlet). Assim, conforme o padrão de URL utilizado pelo cliente execução Java EE ao Sistema de gerenciamento de pedidos (Sa-
no request, decidimos quais informações devemos disponibilizar lesCenter);
na resposta. • MySQL – Base de dados responsável pelo registro dos eventos
No método principal do servlet recepcionamos as requisições capturados pelo Esper no Mule ESB.
via GET, analisamos a URI fornecida e, através dela, definimos
qual ação do serviço de consulta deve ser executada. Para iniciar a simulação, abrimos o SoapUI, responsável por
Como o foco de nosso artigo é Arquitetura, o código fonte da executar os requests dos clientes conforme explicado nos tópicos
classe MiniJsBamServices não é tão relevante para ser apre- anteriores. Uma vez iniciado o cenário de testes na ferramenta,
sentado. Por isso seu conteúdo não está presente na forma de simultaneamente abrimos no navegador a nossa aplicação de
listagem, mas está disponível para download junto com toda a monitoramento MiniJS-BAM. Desta forma, em tempo real, pode-
solução exemplo. A classe MiniJsBamServices apenas realiza mos acompanhar as informações capturadas nos eventos durante
Listagem 16. Servlet Controller da mini aplicação web MiniJS-BAM.
@Named break;
@WebServlet(name=”MiniJsBamController”, default:
urlPatterns = {“/totalOrderByCities”,”/totalOrderByDate”,” break;
/totalOrderByTimeFrame”,”/ping”}, loadOnStartup = 1) }
public class MiniJsBamController extends HttpServlet { resp.getWriter().write( jsonContent );
}
private static final long serialVersionUID = 1L;
@Override
private MiniJsBamServices services = new MiniJsBamServices(); protected void doPost(HttpServletRequest req, HttpServletResponse resp)
throws IOException {
@Override resp.getWriter().write(“Sorry! We are working only with GET for the sake of
protected void doGet(HttpServletRequest req, HttpServletResponse resp) simplicity, this is not a real project.”);
throws IOException { }
String path = req.getServletPath();
private String transformToJson(Object obj) {
String jsonContent = “”; String result = “”;
switch (path) { ObjectMapper mapper = new ObjectMapper();
case “/totalOrderByCities”: mapper.setSerializationInclusion(Include.NON_NULL);
jsonContent = this.transformToJson ( this.services.getTotalOrderByCity() ); mapper.enable(SerializationFeature.INDENT_OUTPUT);
break; mapper.enable(SerializationFeature.CLOSE_CLOSEABLE);
case “/totalOrderByDate”: mapper.configure(SerializationFeature.WRAP_ROOT_VALUE, false);
int dateRequest = Integer.parseInt(req.getParameter(“date”));
jsonContent = this.transformToJson ( this.services.getTotalOrderByDate try {
(dateRequest)); result = mapper.writeValueAsString(obj);
break; } catch (JsonProcessingException e) {
case “/totalOrderByTimeFrame”: throw new RuntimeException(e);
String timeFrameRequest = req.getParameter(“timeFrame”); }
jsonContent = this.transformToJson return result;
( this.services.getTotalOrderByTimeFrame(timeFrameRequest)); }
break;
case “/ping”: }
jsonContent = this.ping();

o movimento das transações que passam
pelo barramento de serviços. Na Figura 15
apresentamos a tela da nossa monitoração
de eventos.
Nesta imagem podemos observar que as
informações que capturamos utilizando o EPL
do Esper estão sendo mostradas em gráficos
como, por exemplo, o total de pedidos diários,
o total de pedidos diários nas principais cida-
des e o total de pedidos realizados nos últimos
trinta segundos.
A integração entre sistemas sempre será um
tema presente no contexto de tecnologia da
informação. Dificilmente, dentro de uma cor-
poração, haverá uma aplicação que não neces-
sitará de informações de outros sistemas para
complementar ou aprimorar o seu trabalho. Se
aparentemente isso parecer existir, pode acre-
ditar que existe uma planilha Excel em alguma
pasta de algum funcionário da empresa, cheia
de macros VBA, que está fazendo o trabalho Figura 15. Tela de monitoração do MiniJS-BAM dos eventos capturados durante as transações
de integração de informações que poderia/
deveria ser feito automaticamente pelos sistemas.
Não organizar e controlar a integração de sistemas nos leva a Autor
um ambiente muito mais complexo para realizar manutenções Ualter Azambuja Junior
e também evoluir numa velocidade satisfatória para o negócio [email protected]
(time-to-market). Sem uma organização satisfatória, os custos Atua como profissional na área de tecnologia há dezenove
são normalmente mais altos e os riscos maiores quando preci- anos, dos quais doze dedicados à plataforma Java no de-
samos realizar alterações corretivas ou evolutivas nos sistemas senvolvimento de softwares e soluções de Arquitetura de Aplicação/
do ambiente. Integração/Serviços. Trabalha como Arquiteto de TI para a GFT em São
Paulo/SP, é pós-graduado em Tecnologia Orientada a Objetos e possui as certificações:
É neste ponto que a arquitetura tem um papel importante
SCJP, SCWCD e SCEA.
quanto a definições e gerenciamento de integrações de sistemas.
Para auxiliar na implantação de uma arquitetura de integração,
existem opções desde as mais simples, como adotar boas práticas Links:
e padrões de integrações, até opções para o estabelecimento de
Comparação dos recursos que estão disponíveis entre as versões do Apache
arquiteturas mais complexas, como SOA e EDA.
TomEE.
A Arquitetura Orientada a Eventos tem aspectos que são inte- http://tomee.apache.org/comparison.html
ressantes para realizar integrações, como: baixo acoplamento e
disponibilização de informações simultaneamente à ocorrência Documentação de referência da linguagem específica de domínio EPL da fer-
de fatos. Fatos estes que são os eventos os quais a corporação, ramenta Esper.
departamentos e/ou indivíduos, têm total interesse em conhecer http://esper.codehaus.org/esper-4.2.0/doc/reference/en/html/epl_clauses.html
e analisar. Site da empresa EsperTech, desenvolvedora dos produtos Esper, EsperHA, Esper
Mas como sempre, toda definição deve ser baseada principal- Enterprise Edition.
mente no bom senso. Ou seja, os benefícios devem compensar http://esper.codehaus.org/
os custos e dificuldades de implantação de uma arquitetura
Esper Online, área para teste e execução de declarações de código EPL.
complexa de integração. Por isso, somente após uma análise do http://esper-epl-tryout.appspot.com/epltryout/mainform.html
ambiente, identificando seus problemas e carências, é que se pode
afirmar se uma Arquitetura Orientada a Eventos será uma boa
opção de escolha. Você gostou deste artigo?

Ajude-nos a manter a qualidade da revista!

Gerenciamento de
dependências no Java
Conheça as principais ferramentas para gerir as
bibliotecas de seu projeto
L Fique por dentro

inguagens orientadas a objetos são, hoje em dia,
dominantes na maioria dos sistemas corporativos
em funcionamento. Com diversos benefícios como Este artigo será útil por apresentar as principais ferramentas que
o baixo acoplamento e a divisão de responsabilidades, a existem para gerenciar e adicionar dependências externas a projetos
criação e manutenção de aplicações projetadas a partir Java, mostrando as vantagens e desvantagens de cada uma e em quais
desse conceito se torna uma tarefa extremamente produ- cenários se encaixam melhor. Conheceremos o Maven, o Ivy e o Gradle,
tiva e, devido a isso, altamente atrativa para a indústria. soluções de grande relevância por simplificar o controle da execução
Essa produtividade se deve, principalmente, à capaci- de tarefas repetitivas que podem tirar o foco do desenvolvedor no que
dade de reuso de componentes criados seguindo os con- realmente agrega valor ao projeto, as regras de negócio.
ceitos da orientação a objeto. Explicando um pouco mais,
linguagens que seguem esse tipo de paradigma (orientado
a objetos) tendem a permitir que o desenvolvedor crie apresentar exemplos de situações em que o uso de dependências
módulos totalmente desacoplados, ou seja, sem nenhuma se faz necessário, mostrando sua utilidade no dia a dia.
dependência entre si. Portanto, a solução de um problema
maior pode ser dividida em diversas soluções menores Reuso de componentes no Java
que, em conjunto, resolvem o objetivo principal. A aplicação dos conceitos do paradigma de orientação a objetos
A vantagem disso é que, caso surja um novo projeto dentro de um projeto tende a permitir que o desenvolvedor possa
que seja semelhante a um já resolvido, essas pequenas dividir sua aplicação em módulos de baixo acoplamento entre
soluções podem ser reaproveitadas, evitando duplicação si. E graças a essa baixa dependência entre os componentes, é
de código e outros problemas. possível a utilização dos mesmos em não somente um, mas em
No Java, o reuso de código pode ser feito através da diversos outros projetos.
utilização de pacotes JAR, arquivos compactados que Por padrão, no Java, o uso desses pacotes é possível ao adicionar
contêm classes já desenvolvidas e que podem ser adicio- o arquivo JAR no classpath da aplicação em desenvolvimento.
nados a um projeto. No entanto, para projetos de grande Para quem não está familiarizado com o termo classpath, este
porte, a configuração manual dessas bibliotecas se representa o caminho, dentro de sua máquina, que a JVM utiliza
torna extremamente complexa e custosa, especialmente para carregar, dinamicamente, as classes e bibliotecas que são
do ponto de vista de manutenção da aplicação, o que utilizadas dentro de um sistema Java.
pode gerar um oneroso trabalho na busca e inclusão Portanto, a adição de dependências pode ser feita simplesmente
de todos os arquivos necessários para o funcionamento copiando arquivos .jar para os diretórios de classpath de nossa
de uma biblioteca. aplicação, sem nenhum segredo. O grande problema, no entanto,
Visando resolver esse problema, foram criadas al- vem quando precisamos gerenciar essas dependências, ou seja,
gumas ferramentas chamadas de Gerenciadores de alterar versões, corrigir conflitos de pacotes e encontrar as depen-
dependências que têm como objetivo gerenciar essas dências encadeadas dos arquivos JAR que desejamos utilizar.
bibliotecas externas ao projeto. Em nosso artigo, pre- Exemplificando, vamos imaginar que, em um projeto, se faça
tendemos introduzir algumas delas, explicando seu uso da biblioteca A.jar. Esse pacote, por sua vez, faz referência
funcionamento e mostrando suas vantagens e desvanta- à biblioteca B.jar e C.jar. Portanto, para conseguirmos utilizar A,
gens. Também pretendemos, no decorrer da explicação, precisamos, obrigatoriamente, adicionar B e C em nosso classpath,

uma tarefa um tanto trabalhosa. Pior ainda, caso B ou C façam
referência a uma biblioteca D.jar, também precisaríamos adicionar
essa ao nosso projeto. Através desse exemplo é fácil observar como
uma situação de gerenciamento de dependências pode fugir do
controle de nosso time de desenvolvimento, causando um trabalho
enorme no gerenciamento de um projeto.
Ferramentas para gerenciar suas dependências

Com o intuito de resolver esse problema, existem os chamados
gerenciadores de dependências. Esse tipo de aplicação serve para
que seja possível, ao desenvolvedor, facilmente definir as bibliote-
cas que devem ser incluídas, bem como a versão de cada uma.
Além disso, uma das grandes vantagens desse tipo de ferramenta
é a capacidade de realizar o download das bibliotecas automati-
camente, através do uso de certos sites que fornecem o chamado
repositório de dependências. Esses repositórios servem como uma
espécie de arquivo público com diversos pacotes, que por sua vez
podem ser baixados através dos gerenciadores de dependências.
Figura 1. Plugins a serem baixados pelo Eclipse Marketplace
Em nosso artigo, iremos abordar três ferramentas para geren-
ciar dependências: o Apache Maven, o Apache Ivy e, por fim, o
Gradle. Pretendemos introduzir as características de cada uma, Nota
bem como suas vantagens e desvantagens, expondo exemplos de
Caso você queira saber um pouco mais sobre o Apache Ant, adicionamos um link ao fim do artigo
utilização de cada uma.
com algumas informações sobre esse projeto da Apache.
Configurando nossa IDE

Antes de começarmos a desenvolver nossos exemplos, no en- Entre essas funcionalidades, uma das mais úteis e que será o foco
tanto, é necessário adequarmos nossa IDE a trabalhar com esses de nosso artigo é a capacidade de automatizar o gerenciamento
três tipos de ferramentas. Para isso, existem diversos plug-ins de dependências de um projeto. Seu funcionamento é bastante
prontos que, uma vez baixados e instalados, facilitam a utilização simplificado: através de um repositório online, o Maven baixa
e o desenvolvimento com essas ferramentas. todas as bibliotecas especificadas dentro do projeto em que está
Nesse artigo, a IDE de escolha para trabalharmos será o Eclipse. sendo utilizado.
Caso você não tenha essa aplicação instalada, o download da Essas bibliotecas, por sua vez, são definidas dentro de um ar-
mesma pode ser feito através do endereço que apresentamos no quivo XML denominado pom.xml, onde, além das dependências,
fim do artigo, na seção Links. também podemos especificar alguns passos no processo de build
Uma vez que o Eclipse esteja instalado, precisamos baixar nossos de um projeto. Na Listagem 1 apresentamos um exemplo de pom
plug-ins. Isso é feito clicando no menu Help > Eclipse Marketplace, .xml, que usaremos mais adiante, em nosso projeto exemplo.
localizado no menu superior da IDE, e escolhendo, dentro da lista de Após essa análise, podemos constatar que o pom.xml possui um
plug-ins disponíveis, os que iremos utilizar. Para auxiliar no processo formato bastante intuitivo. Em primeiro momento, definimos uma
de encontrar os plug-ins, na Figura 1 colocamos todos os que iremos tag “pai”, que representa nosso projeto, denominada <project>.
utilizar e que precisam ser instalados pelo Eclipse Marketplace. Dentro dela, por sua vez, incluímos algumas informações de nosso
Esses plug-ins servem para, respectivamente, controlar as ferra- projeto, tal como versão, nome do projeto, tipo de empacotamento,
mentas de gerenciamento de dependências do Gradle, Apache Ivy entre outras.
e Maven. Será necessário baixar um de cada vez e, ao final da insta- Logo em seguida, definimos outra tag, chamada de <build>.
lação, reiniciar o Eclipse para que as alterações tomem efeito. Esta será responsável por especificar os itens relacionados exclu-
sivamente ao processo de construção de nosso projeto como, por
Apache Maven exemplo, o tipo do compilador, a versão do Java que desejamos
Agora que configuramos nossa IDE, vamos introduzir nossa utilizar e se queremos usar algum plugin ou não.
primeira (e talvez a mais famosa) ferramenta de gerenciamento Por fim, o trecho que mais nos interessa está entre as tags
de dependências. O Apache Maven foi criado com o princípio de <dependencies>. É neste espaço que podemos especificar as bi-
ser uma aplicação capaz de automatizar o processo de compila- bliotecas que iremos utilizar como dependência de nosso projeto,
ção, muito semelhante ao Apache Ant e, também, trazer outras através de tags <dependency>. É importante notar que, para cada
diversas funcionalidades interessantes ao processo de build de dependência do Maven, precisamos definir três itens: groupId,
um projeto. artifactId e version.

Gerenciamento de dependências no Java
O groupId (especificado através da tag <groupId>) representa, Logo após, na tag <artifactId>, informamos o nome da biblioteca
na maioria dos casos, a empresa ou projeto do qual a biblioteca em em si e, na tag <version>, a versão da mesma. Em nosso caso,
questão faz parte. No caso de nosso projeto, como estamos usando determinamos os seguintes valores: commons-lang3 e 3.3.2,
uma biblioteca do projeto Apache Commons, nosso groupId ficou respectivamente.
definido como org.apache.commons.
Nota
Listagem 1. Exemplo de pom.xml para definir as dependências do Maven. Para auxiliar os desenvolvedores a encontrar as bibliotecas que necessitam, os repositórios
remotos do Maven normalmente disponibilizam uma interface web que permite a busca de
<project xmlns=”http://maven.apache.org/POM/4.0.0”
bibliotecas e devolve, como retorno, as configurações do pom.xml para adicionar a mesma em
xmlns:xsi=”http://www.w3.org/2001/XMLSchema- instance”
xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 seu projeto. Na seção Links adicionamos o caminho para o site Maven repository, que possui
http://maven.apache.org/xsd/maven-4.0.0.xsd”> uma interface desse tipo.
<modelVersion>4.0.0</modelVersion>
<groupId>br.com.javamagazine</groupId>
<artifactId>mavenProject</artifactId>
<version>0.0.1-SNAPSHOT</version>
Agora que entendemos as partes do arquivo pom.xml, vamos criar
<packaging>jar</packaging> nosso projeto que utiliza o Maven como gerenciador de depen-
<build> dências. Para isso, com o plugin do Maven instalado no Eclipse,
<sourceDirectory>src</sourceDirectory>
<plugins> basta criarmos um projeto do tipo Maven Project. Na Figura 2
<plugin> apresentamos as telas de criação para nosso projeto exemplo e os
<artifactId>maven-compiler-plugin</artifactId> passos que devemos seguir.
<version>3.1</version>
<configuration> Conforme podemos verificar, a criação de um projeto Maven
<source>1.8</source> é dividida em um wizard composto por duas telas principais.
<target>1.8</target>
A primeira, localizada à esquerda, apresenta algumas configu-
</configuration>
</plugin> rações básicas como a localização de nosso projeto (workspace)
</plugins> e, também, se desejamos utilizar algum tipo de Working set do
</build>
Eclipse. É importante notar ainda que selecionamos o primeiro
<dependencies>
<dependency> checkbox dessa tela, que indica que não queremos usar nenhum
<groupId>org.apache.commons</groupId> archetype do Maven para criar nosso projeto.
<artifactId>commons-lang3</artifactId>
<version>3.3.2</version>
Os chamados archetypes são espécies de templates que nos ajudam
</dependency> a criar um esqueleto de nosso projeto, com as source folders e configu-
</dependencies> rações iniciais a partir de diversos modelos pré-definidos (aplicações
</project>
web, EARs, aplicações desktop, etc.). Como em nosso exemplo iremos
criar o projeto sozinhos, optamos por não os utilizar.
Figura 2. Telas para configuração do projeto Maven

Na tela seguinte temos a opção de definir o nome do nosso pro- Listagem 3. pom.xml com o uso do módulo moduloMaven.
jeto. É interessante observar que, assim como as dependências que
adicionamos, os projetos no Maven são nomeados por três atributos: xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
Group id, Artifact id e Version. Para o nosso projeto, definimos os xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0
nomes como br.com.javamagazine, para o groupId, e mavenProject http://maven.apache.org/xsd/maven-4.0.0.xsd”>
para o artifact id. Em relação à versão, escolhemos atribuir ao nosso <groupId>JavaMagazineMaven</groupId>
exemplo o versionamento 0.1, ficando a critério do leitor atribuir <artifactId>JavaMagazineMaven</artifactId>
<version>0.0.1-SNAPSHOT</version>
uma versão diferente ao projeto que está criando.
<packaging>pom</packaging>
Uma vez criado o projeto, podemos ver que foi adicionado um <build>
arquivo pom.xml à raiz do mesmo, local onde também adicionare- <sourceDirectory>src</sourceDirectory>
<plugins>
mos as suas dependências. Para isso, vamos copiar o trecho entre <plugin>
as tags <dependencies> da Listagem 1 e adicionar no pom.xml <artifactId>maven-compiler-plugin</artifactId>
que acabou de ser criado. Feito isso, para permitir que o plugin <version>3.1</version>
<configuration>
do Maven faça o download automático das bibliotecas, basta <source>1.8</source>
clicarmos com o botão direito em cima do projeto e escolher a <target>1.8</target>
</configuration>
opção Run As > Maven Install.
</plugin>
Logo após, você poderá observar pelo console de saída do </plugins>
Eclipse, que o Maven automaticamente irá baixar as bibliotecas </build>
<dependencies>
indicadas no pom.xml e também empacotar seu projeto de acordo <dependency>
com as instruções do mesmo arquivo. Caso você queira testar a <groupId>org.apache.commons</groupId>
biblioteca recém-baixada do Apache Commons, apresentamos na <artifactId>commons-lang3</artifactId>
<version>3.3.2</version>
Listagem 2 o código da classe TesteDependencias, que utiliza essa </dependency>
dependência para imprimir um texto no terminal da IDE. </dependencies>
<modules>
<module>../moduloMaven</module>
Listagem 2. Classe de exemplo que utiliza as dependências do Apache Commons.
</modules>
</project>
public class TesteDependencias {
public static void main(String[] args) { A segunda mudança, indicada pelas tags <modules> e <mo-
System.out.println(StringUtils.capitalize(“usando a dependência do Apache
Commons!”));
dule>, serve para, explicitamente, indicar onde está localizado
} nosso módulo. Como ainda não criamos esse módulo, para que
essa configuração funcione, podemos seguir os mesmos procedi-
}
mentos para criação de um projeto Maven e criar um novo, com
o nome moduloMaven.
Múltiplos módulos Uma vez criado esse projeto, precisamos apenas modificar seu
Além dos archetypes e do gerenciamento de dependências, o pom.xml para referenciarmos o projeto pai do qual esse subprojeto
Maven também permite a criação de módulos dentro de seus pro- depende – em nosso exemplo, o projeto JavaMagazineMaven.
jetos. Um módulo funciona como uma dependência, mas, dentro Na Listagem 4 apresentamos o pom.xml do projeto recém-criado
do workspace, é representado por um projeto Java tradicional. indicando esse relacionamento.
Para trabalhar com módulos, basta adicionar essa informação Nesse código podemos ver que o relacionamento de um pro-
em nosso pom.xml. Visando demonstrar esse recurso, vamos al- jeto com seu “pai” é indicado pela tag <parent>. Dentro dessa
terar esse arquivo em nosso projeto Maven adicionando algumas tag, relacionamos todos os dados do projeto pai, inclusive seu
linhas. Na Listagem 3 apresentamos o novo pom.xml, já com as caminho relativo.
informações de nosso módulo. Assim que os dois projetos estiverem configurados, ao rodar o
Foram realizadas duas alterações para a inclusão do novo mó- comando mvn install no projeto pai, veremos que todos os projetos
dulo. A primeira, relacionada à tag <packaging>, é a modificação declarados na seção de módulos serão compilados e seus pacotes
do tipo de empacotamento de jar para pom. Essa mudança é finais adicionados à pasta target de cada um.
necessária para projetos Maven que utilizam módulos em sua
construção e irá, automaticamente, disparar o build e empacota- Vantagens e desvantagens do Maven
mento dos subprojetos declarados no pom.xml. Agora que completamos nosso primeiro exemplo utilizando o
É importante observar que, ao escolher o tipo de empacotamento Maven, vamos analisar os pontos positivos e negativos de usar
pom, nosso projeto pai deixa de ser compilado e passa a servir essa tecnologia.
somente de referência para que os projetos declarados na seção Conforme dissemos no início do artigo, a tarefa de gerenciamen-
de módulos sejam empacotados to de dependências é extremamente complexa.

Listagem 4. Pom.xml indicando o relacionamento entre o módulo e o projeto pai. Apache Ivy
Com o intuito de possibilitar uma maior liberdade para o de-
senvolvedor construir seus projetos, a Apache desenvolveu outro
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://maven.apache.org/POM/4.0.0 projeto, implementado em paralelo ao Apache Maven, chamado
http://maven.apache.org/xsd/maven-4.0.0.xsd”> Apache Ivy. Essa ferramenta tem como objetivo propiciar as van-
<parent> tagens do gerenciamento de dependências do Maven integradas
<groupId>JavaMagazineMaven</groupId>
com um processo de build mais dinâmico.
<artifactId>JavaMagazineMaven</artifactId>
<version>0.0.1-SNAPSHOT</version> Para isso, esse processo utiliza outra solução da Apache, o
<relativePath>../JavaMagazineMaven/pom.xml</relativePath> chamado Apache Ant. Para quem não está familiarizado, o Ant
</parent> permite que se especifique instruções para a construção de um
<groupId>br.com.javamag</groupId> projeto, tais como cópia de arquivos e execução de comandos shell,
<artifactId>moduloMaven</artifactId> através de um arquivo XML denominado build.xml. Você pode
<version>0.0.1-SNAPSHOT</version> encontrar a URL oficial do projeto na seção Links.
<name>moduloMaven</name>
As dependências do Ivy, por sua vez, são gerenciadas pelo pró-
</project>
prio Ivy, em um arquivo denominado ivy.xml. Sua configuração
é bastante semelhante ao pom.xml do Maven e um exemplo desse
Com a capacidade de baixar automaticamente as dependências arquivo pode ser visto na Listagem 5.
de repositórios online, o Maven traz como grande vantagem a
praticidade e simplicidade na configuração dessas bibliotecas Listagem 5. Exemplo de arquivo ivy.xml.
e, como ponto extra, também permite a criação de esqueletos
<ivy-module version=”2.0”>
de aplicações, através dos archetypes. Essa automação, se <info organisation=”java-mag” module=”ivy”/>
comparada com a configuração manual dos projetos, traz um <dependencies>
ganho enorme tanto em manutenção, ao evitar a verificação e <dependency org=”commons-lang” name=”commons-lang” rev=”2.0”/>
<dependency org=”commons-cli” name=”commons-cli” rev=”1.0”/>
atualização das bibliotecas manualmente, como em velocidade
</dependencies>
de desenvolvimento, diminuindo bastante a complexidade do </ivy-module>
gerenciamento das dependências.
Além disso, ao especificar seu projeto com os mesmos atributos
que definem uma dependência (criando o artifactId, groupId e Como podemos verificar, a sintaxe do Ivy é muito semelhante
version), o Maven permite que, facilmente, possa se compartilhar à do Maven, com apenas algumas pequenas diferenças. As bi-
o projeto como dependência de outros projetos. Essa facilidade de bliotecas declaradas como dependências são, da mesma forma
uso é um dos pontos mais vantajosos do Maven e, devido a isso, que no Maven, especificadas dentro da tag <dependencies>,
podemos dizer que essa ferramenta é uma das mais utilizadas porém, em vez de possuírem os parâmetros groupId, artifactId
por desenvolvedores em todo o mundo. e version, característicos do Maven, possuem os atributos org,
No entanto, também existem alguns pontos negativos com a name e rev que, em conjunto, identificam a dependência que
utilização dessa ferramenta. O primeiro deles, relacionado ao queremos utilizar.
gerenciamento de dependências, é a dificuldade de se eliminar Ainda de modo semelhante ao Maven, onde utilizamos a tag
conflitos de dependências, ou seja, quando temos duas depen- project, declaramos na tag info do Ivy as informações de nosso
dências iguais (mas de versões diferentes) no mesmo projeto. projeto. E dentro dessa tag também declaramos o atributo or-
Apesar de ser possível excluir bibliotecas, quando temos uma ganisation e module. É importante notar que, ao contrário do
árvore muito grande de dependências, a tarefa de encontrar e re- Maven, o Ivy não possui instruções de build dentro do ivy.xml.
mover as bibliotecas em conflito se torna bastante complicada. Estas instruções, conforme dissemos anteriormente, ficam em um
Ainda como ponto negativo, pelo fato do Maven se basear em arquivo à parte, chamado build.xml, e são rodadas pelo Ant.
XMLs para sua configuração, a configuração do processo de Para conseguirmos executar as tarefas de baixar as dependên-
build se torna limitada a instruções pré-definidas, não dando cias e construir nosso projeto localizadas nesse arquivo, temos
muito espaço para customização. Para conseguir realizar ma- que instalar mais alguns plug-ins no Eclipse. Isso pode ser feito
nipulações mais complexas dentro do processo de build, como escolhendo a opção Help > Install New Software na interface de sua
usar alguma lógica de programação, é necessária a adoção de IDE e, na próxima janela, buscar pelo plugin Apache Ivy Ant Tasks
outra ferramenta, como o Apache Ant, que já abre mais espaço dentro dos softwares disponíveis para download. Na Figura 3
para builds customizados. mostramos qual a biblioteca que deve ser baixada para conse-
Por fim, os próprios archetypes, implementados com o objetivo guirmos prosseguir com o nosso exemplo.
de servir como forma de criar esqueletos de projetos, também Uma vez instalado, basta adicionarmos o JAR desse plugin ao
não são passíveis de customização, deixando o desenvolvedor nosso processo de build do Ant. Isso pode ser feito nas preferên-
engessado nos padrões adotados pelo Maven. cias do Eclipse, escolhendo, nas opções da tela de preferências,

localizadas no menu lateral à esquerda, a opção Ant > Runtime. aplicações e seus arquivos pode, muitas vezes, ser um problema
Uma vez dentro desse menu de configuração de Runtime do maior que a solução trazida pela ferramenta.
Ant, basta clicar no botão Add External Jar e escolher, dentro Em segundo lugar, apesar do dinamismo e flexibilidade no proces-
do diretório de instalação do Eclipse, na pasta plugins, o JAR so de build do Apache Ant, esta ferramenta ainda nos deixa presos
do Ivy, que deve ter a nomenclatura semelhante a org.apache a instruções de build definidas na sua especificação, o que pode
.ivy_2.X.X.XXXXXXXXX.jar. ser visto como uma grande limitação à automatização dos builds.
Feito isso, basta construirmos um arquivo de build, o que é
alcançado definindo o arquivo build.xml, como pode ser visto na Listagem 6. Arquivo build.xml usando a integração do Ant com o Ivy.
Listagem 6. Este servirá como exemplo para adicionarmos o Ant
em nosso projeto Ivy e automatizarmos o processo de build de <project xmlns:ivy=”antlib:org.apache.ivy.ant” name=”JavaMagazineIvy”
default=”dist” basedir=”.”>
nosso projeto exemplo, que criaremos mais adiante.
<property name=”src” location=”src” />
Neste código podemos ver alguns comandos característicos do <property name=”build” location=”build” />
Ant. O primeiro deles é a divisão do processo de build por tar- <property name=”dist” location=”dist” />
gets, ou seja, sub-tarefas, responsáveis por executar um conjunto <taskdef resource=”org/apache/ivy/ant/antlib.xml” uri=”antlib:org.apache.ivy.ant” />
<target name=”init”>
de instruções. Dentro de cada uma dessas sub-tarefas, temos as <tstamp />
instruções do Ant, como criação de diretórios, através da tag <mkdir dir=”${build}” />
<mkdir>, e compilação e empacotamento de projetos, através das </target>
tags <javac> e <jar>.

<target name=”compile” depends=”init” description=”compile the source “>
Para incluirmos o Ivy no nosso processo de build do Ant, adicio- <ivy:retrieve/>
namos uma tag especial denominada <ivy:retrieve>, que serve <javac srcdir=”${src}” destdir=”${build}” />
para indicar, dentro do Ant, que desejamos que sejam baixadas </target>
todas as dependências do arquivo ivy.xml. Dessa forma, conse- <target name=”dist” depends=”compile” description=”generate the distribution”>
guimos unir o processo de build do Ant com o gerenciamento de <mkdir dir=”${dist}/lib” />
dependências do Ivy. <jar jarfile=”${dist}/lib/MyProject-${DSTAMP}.jar” basedir=”${build}” />
</target>
Por fim, para testarmos todas as nossas configurações, basta
criarmos um projeto Java simples em nossa IDE e adicionar, no <target name=”clean” description=”clean up”>
diretório raiz do projeto, os arquivos ivy.xml e build.xml apresen- <delete dir=”${build}” />
tados nas Listagens 5 e 6. Uma vez adicionados, podemos clicar <delete dir=”${dist}” />
</target>
com o botão direito em cima do arquivo build.xml e escolher a </project>
opção Run As > Ant Build para baixar as
dependências e construir nosso projeto.
Vantagens e desvantagens do Ivy

Como informado no início da discussão
sobre o Ivy, essa ferramenta foi criada com
o propósito de eliminar a dificuldade de
customizar o gerenciamento de dependên-
cias e processos de build, como acontece
no Maven, permitindo a criação de tarefas
complexas de construção de projetos de
maneira mais simples.
Esse propósito é parcialmente atendido
com o uso do Apache Ant, através da cus-
tomização disponível por essa aplicação,
porém o Ivy ainda traz algumas limitações.
A primeira delas, que podemos verificar
claramente, é a necessidade de termos duas
ferramentas distintas para conseguir alcan-
çar esse objetivo, uma vez que o Ivy sozinho
só realiza o gerenciamento de dependências
e não a construção de projetos. A comple-
xidade de configuração de um ambiente e
a necessidade de manutenção de ambas as Figura 3. Plugin necessário para rodar as tarefas do Ivy dentro do Ant

Apesar do leque de instruções ser bem maior que a oferecida Um exemplo de arquivo settings.gradle pode ser visto a seguir,
pelo Maven, tarefas fora do padrão podem se tornar extremamen- onde expomos a configuração de nosso multi-project exemplo:
te complexas de implementar devido à limitação mencionada,
ainda mais quando precisamos de algo em nossos processos que include “:java_mag1”,”:java_mag2”
exige lógicas extensas ou tarefas fora do padrão do Ant como,
por exemplo, o uso de lógica de programação para configurar Neste caso, especificamos que nosso multiprojeto será composto
nossos pacotes. por dois subprojetos: um chamado java_mag1 e outro chamado
de java_mag2.
Gradle Para testarmos o funcionamento do Gradle, vamos mover esse
Com a solução desses problemas em mente, foi desenvolvida a arquivo para uma pasta dentro do nosso diretório definido como
ferramenta para gerenciamento de dependências Gradle. Elimi- Workspace. No nosso caso, criamos uma pasta denominada
nando o uso de XMLs e aplicando, dentro do processo de compila- java_mag e adicionamos, dentro dela, o arquivo settings.gradle.
ção e empacotamento, o uso de uma linguagem de programação, o É válido observar que ainda não criamos nosso projeto na IDE.
Gradle disponibiliza uma ferramenta completa de gerenciamento Feito isso, vamos ao próximo passo: criar o build.gradle. Nesse
e automatização de builds. momento, vamos criar apenas um arquivo de texto em branco (com
Seu princípio fundamental é o uso da linguagem Groovy nos o nome build.gradle) no mesmo diretório de nosso settings.gradle.
scripts de build permitindo, assim, que qualquer tarefa seja pro- Além disso, também precisamos criar os diretórios java_mag1
gramável, utilizando recursos de linguagens de programação e java_mag2, na mesma pasta em que adicionamos os arquivos
como a criação de funções, loops e ifs. Ademais, o Gradle dis- build.gradle e settings.gradle, permitindo que o Eclipse possa criar
ponibiliza uma sintaxe simples para declarar as dependências, esses subprojetos em seu workspace assim que importamos o
semelhante ao modo de declaração do Maven e, ainda, possibilita projeto principal.
a invocação de scripts Ant. Com a estrutura de diretórios pronta, já é possível para o plugin
Portanto, podemos dizer que o Gradle é uma ferramenta ex- do Eclipse reconhecer a existência de um projeto Gradle e seus
tremamente poderosa, principalmente quando precisamos criar projetos filhos, através do arquivo settings.gradle (onde declara-
scripts de build um pouco mais complexos. Inclusive, diversos mos o nome dos subprojetos), e criar os mesmos dentro de nossa
projetos importantes, como o SDK do Android e o Hibernate, já IDE. Para isso, basta escolher a opção Import > Gradle Project na
utilizam o Gradle em seus desenvolvimentos, mostrando a con- IDE e, na tela que surgir, selecionar o diretório em que criamos
fiabilidade e qualidade desta solução. os arquivos e pastas e clicar no botão Build Model. Na Figura 4
apresentamos essa tela e como ela deve ficar após seguir os passos
Criando um projeto com o Gradle supracitados.
Iniciando nosso exemplo sobre o Gradle, o processo de cons- Como podemos verificar, no Eclipse o nosso projeto Gradle foi
trução de um projeto que utiliza essa ferramenta se baseia nas quebrado em três: o projeto principal, denominado java_mag e,
instruções declaradas no arquivo build.gradle. Assim como no logo em seguida, os dois subprojetos (java_mag1 e java_mag2),
Ivy ou no Maven, esse arquivo serve para explicitarmos nos- conforme declarado no settings.gradle. Para importá-los, basta
so processo de build e, também, para especificarmos nossas selecionar o checkbox à esquerda do nome do projeto e clicar
dependências. em Finish.
Como diferença, no Gradle esse arquivo não se baseia mais Outro ponto importante nessa configuração multi-project está
em um documento XML e, sim, na linguagem de programação relacionado à herança das dependências. No Gradle todos os
Groovy. Além desse arquivo, o Gradle também utiliza o arquivo subprojetos irão herdar todas as dependências do projeto pai
settings.gradle, responsável por definir algumas propriedades de automaticamente e podem, através de configurações no build
build do projeto e, principalmente, gerenciar a criação dos cha- .gralde, herdar dependências de outros subprojetos.
mados multi-projects. É importante ressaltar que, para cada projeto, o arquivo build.
Esse tipo de projeto (multi-projects) é bastante útil para desen- gradle localizado na sua raiz irá identificar quais são as suas
volvedores que pensam em melhorar a organização de seu código, dependências. Em casos de subprojetos, se o arquivo build.gradle
quebrando um sistema grande em subprojetos menores, cada um não existir (como no nosso exemplo), esses projetos irão assumir
com suas respectivas dependências. Uma abordagem como essa somente as dependências do projeto principal.
permite maior desacoplamento entre as partes do projeto e, no Portanto, se quisermos adicionar dependências no projeto
caso de alguma das partes precisar ser reutilizada, fica muito java_mag, basta alterar o arquivo de configuração em sua raiz
mais simples o uso somente do que é necessário. (build.gradle) e caso seja necessário incluir diferentes dependências
Outro grande atrativo do Gradle é a facilidade de criação e em java_mag1 ou java_mag2, basta adicionar as configurações
gerenciamento desse tipo de abordagem (multiprojetos). Assim, dentro de um arquivo build.gradle em cada um deles.
pretendemos, nesse tópico, apresentar como podemos aliar essa Deste modo, temos flexibilidade para configurar nossas depen-
funcionalidade ao gerenciamento de dependências. dências exatamente onde quisermos.

Como exemplo, demonstraremos a seguir como adicionar algu- Por fim, no trecho denominado dependencies, declaramos a
mas dependências no nosso projeto pai, o chamado java_mag. dependência que desejamos utilizar. É interessante notar que,
Para isso, basta abrir o arquivo build.gradle desse projeto e adicio- de modo semelhante ao Maven, cada dependência é composta
nar as linhas presentes na Listagem 7. por três partes, separadas pelo caractere “:” neste caso. Essas
Nessa listagem podemos ter uma ideia da sintaxe do arquivo partes são, respectivamente, o group, representando o projeto
de dependências do Gradle. Definimos, na primeira linha, que ou empresa do qual a biblioteca faz parte, o name, que indica o
estamos trabalhando com um projeto Java, através do plugin java nome da dependência em si e, por último, a versão da biblioteca
e, logo em seguida, explicitamos qual será nosso repositório; neste que queremos adotar.
caso, o Maven Central. Uma vez adicionadas as dependências ao nosso arquivo, basta
clicar com o botão direito em cima do projeto java_mag na IDE
Eclipse e escolher a opção Gradle > Refresh Dependencies. Assim, as
Listagem 7. Arquivo build.gradle – Definindo as dependências de nossos projetos.
dependências declaradas no arquivo serão baixadas e uma pasta
apply plugin: ‘java’ denominada Gradle Dependencies será adicionada ao projeto.
repositories { Plugins do Gradle e a construção de pacotes

mavenCentral() No último exemplo, o leitor mais atento deve ter verificado que
flatDir { utilizamos o plugin Java do Gradle. Neste tópico, explicaremos
dirs ‘libs’
o funcionamento desse plugin e, também, faremos uma breve
}
introdução sobre alguns dos principais plug-ins que podemos
}
adotar em nossos processos de build do Gradle e suas respectivas
dependencies {
formas de utilização.
compile ‘org.apache.commons:commons-lang3:3.3.2’ O primeiro deles, já introduzido no exemplo anterior, é o plugin
} responsável pela compilação das classes do nosso projeto. Para
executá-lo adicionamos a seguinte linha em nosso arquivo de
configuração: apply plugin: ‘java’. E além de compilar o código,
ele é responsável por empacotar o mesmo em um arquivo JAR.
Tarefas como a compilação e o empacotamento de classes em um
JAR podem ser disparadas em nosso processo de build através
da criação das chamadas tasks. Estas são definidas dentro do
arquivo build.gradle, onde podemos criar diversas tarefas, que
funcionam como funções.
Por padrão, os plugins do Gradle já trazem algumas tarefas
implementadas, consideradas essenciais para seu funcionamento.
O plugin do Java, por exemplo, já vem com uma tarefa denominada
jar que permite o empacotamento do projeto em um arquivo .jar.
Para testar essa tarefa, basta entrar no Eclipse, clicar com o botão
direito em nosso projeto e escolher a opção Task Quick Launcher.
Logo em seguida, na caixa de texto que será exibida na IDE, digite
a task que deseja executar. Ao pressionar o botão Enter, esta task
será executada. Portanto, para empacotarmos nosso projeto como
um JAR, basta digitar a palavra jar e deixarmos o build do Gradle
rodar automaticamente.
Uma vez empacotado, o arquivo gerado será colocado na pasta
build/libs da raiz do projeto. Caso seja necessário executar uma ins-
trução mais customizada, fora dos padrões, o Gradle permite ainda
que algumas definições de suas tasks sejam sobrescritas, como é
o caso do diretório em que são gerados os pacotes. Na Listagem 8
apresentamos o arquivo build.gradle sobrescrevendo algumas con-
figurações default da task de geração do arquivo JAR.
Com o exemplo podemos ver como é fácil, dentro do Gradle,
sobrescrever uma task. Neste caso, em vez de sobrescrever a
implementação de toda a função, apenas sobrescrevemos a pro-
Figura 4. Tela de configuração de nosso projeto Gradle priedade destinationDir.

Listagem 8. Sobrescrevendo a tarefa de geração do JAR no arquivo build.gradle. Deste modo, ao rodarmos a task jar, o arquivo será gerado na
pasta pacote, em vez de na pasta default.
apply plugin: ‘java’
Outro plugin para geração de pacotes é o plugin para criação de
repositories { arquivos do tipo WAR. Assim como a task de geração de arquivos
mavenCentral()
JAR, essa task gera o pacote automaticamente em um diretório
flatDir {
dirs ‘libs’ padrão, mas também abre espaço para customização de algumas
} propriedades.
}
Na Listagem 9 apresentamos um exemplo de uso do plugin war
jar { do Gradle para gerar um pacote desse tipo, também adotando
destinationDir= file(“pacote”)
algumas customizações.
}
dependencies { A sobrescrita dessa task, como podemos verificar, é muito seme-
compile ‘org.apache.commons:commons-lang3:3.3.2’ lhante à que fizemos com a task jar. A diferença é que, neste caso,
}
sobrescrevemos a localização do arquivo web.xml, indicando onde
Listagem 9. Utilizando e sobrescrevendo a tarefa de geração do war no arquivo desejamos que o Gradle o busque e o insira no pacote.
build.gradle.
Feito isso, para testar essa tarefa, precisamos criar um arquivo
apply plugin: ‘java’ com o nome web.xml e adicioná-lo na raiz de nosso projeto. Para
apply plugin: ‘war’ auxiliar o leitor, apresentamos na Listagem 10 um web.xml vazio,
repositories { que pode ser utilizado neste exemplo.
mavenCentral()
flatDir {
dirs ‘libs’
} Listagem 10. Arquivo web.xml exemplo para nosso projeto.
}
<?xml version=”1.0” encoding=”UTF-8”?>
war { <web-app xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
webXml = file(‘web.xml’) xmlns=”http://java.sun.com/xml/ns/javaee”
} xmlns:web=”http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
jar { xsi:schemaLocation=”http://java.sun.com/xml/ns/javaee
destinationDir= file(“pacote”) http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”
}
dependencies { id=”WebApp_ID” version=”2.5”>
compile ‘org.apache.commons:commons-lang3:3.3.2’
} </web-app>

Característica/Ferramenta Maven Ivy Gradle
Gerenciamento de dependências e inte- Gerenciamento de dependências e automatização
Gerenciamento de dependências e
Utilização gração com o Apache Ant para constru- no processo de build, com alta possibilidade de
templates de projetos (Archetypes).
ção de projetos. customização.
Linguagem principal XML XML Groovy
Um pouco menos popular, mas como tem
Opção relativamente nova e, apesar de ser conside-
Talvez o mais popular, sendo muito integração com o Apache Ant (bem co-
rada uma tendência para a automatização de builds
Popularidade fácil encontrar um desenvolvedor que nhecido no mercado), se torna mais sim-
e gerenciamento de dependências, ainda é pouco
saiba utilizar ples de ser adotado por desenvolvedores
utilizada.
já familiarizados com essa ferramenta.
Um dos principais problemas do
Como possui integração com o Apache Por utilizar uma linguagem de programação em vez
Maven está no fato de suas builds
Capacidade de Ant, a capacidade de customização é mais de simples configurações por XML, o Gradle traz uma
serem bastante engessadas. A partir
customização extensa, mas se limita às ferramentas facilidade bem maior para customizar e desenvolver
disso, qualquer customização se torna
disponibilizadas pelo Ant. processos de build mais complexos.
bastante complexa.
O Maven é bem fácil de ser utilizado e
Mais complicado, pois o próprio plugin
disponibiliza diversos plugins para as
muitas vezes não atende a todas as ne- Bastante simples, principalmente ao utilizar os plu-
Usabilidade e plugins mais diversas IDEs. Por ser a ferra-
cessidades do desenvolvedor, além de ser gins disponíveis no Eclipse.
menta mais adotada, é fácil encontrar
mais difícil de ser configurado.
informações e tutoriais a respeito.
O gerenciamento de multiprojetos e a capacidade
Os Maven Archetypes possibilitam a Sua integração com o Ant é algo de
de definir processos e dependências diferentes
Capacidades extras criação e utilização de templates, faci- grande utilidade para projetos que já se
para cada um é extremamente útil para projetos de
litando a criação de projetos novos. integram com essa ferramenta.
grande porte.
Tabela 1. Comparação entre as ferramentas apresentadas
Comparando cada uma das tecnologias

Concluída nossa introdução sobre cada uma das tecnologias Autor
disponíveis para gerenciamento de dependências, faremos agora
Brunno F. M. Attorre
uma comparação entre elas de forma a auxiliar na escolha do [email protected]
leitor em seus projetos. Trabalha com Java há quatro anos. Apaixonado por temas
Para isso, criamos a Tabela 1, onde apresentamos as principais como Inteligência Artificial, ferramentas open source, BI, Data
características destas ferramentas e que funciona como uma es- Analysis e Big Data, está sempre à procura de novidades tecnológicas na
pécie de resumo. Estas características foram divididas em tópicos, área. Possui as certificações OCJP, OCWCD e OCEEJBD.
que avaliamos como relevantes para o leitor e adicionamos, para
cada um, as vantagens e desvantagens de cada ferramenta.
É interessante observar que, apesar de todas as ferramentas Links:
servirem ao propósito do gerenciamento de dependências, cada
Página para download da IDE Eclipse.
uma tem uma característica ou funcionalidade distinta. Seja
https://www.eclipse.org/downloads/
pela simplicidade de uso ou pelo leque de funcionalidades que
disponibiliza, os três gerenciadores que analisamos são soluções Página do Maven Repository para encontrar dependências do Maven.
valiosas para o desenvolvedor. http://mvnrepository.com
Essa definição, dentro de um cenário real, é importantíssima uma Página com uma introdução sobre os Maven archetypes.
vez que tanto o problema a ser solucionado no projeto quanto o co- http://maven.apache.org/guides/introduction/introduction-to-archetypes.html
nhecimento da equipe podem ser fatores fundamentais na escolha do
gerenciador de dependências. Muitas vezes, a ferramenta com menos Repositório do Maven utilizado no Gradle
http://search.maven.org
opções pode ser suficiente para projetos mais simples, não exigindo
muito da equipe e permitindo uma maior facilidade de adaptação de
um time mais leigo a uma ferramenta não tão robusta. Você gostou deste artigo?
Deste modo, vale ressaltar que não existe a solução bala de
prata, que atende a todas as situações para o gerenciamento de
dependências e, sim, uma escolha mais adequada para cada tipo
de projeto e equipe com a qual se está trabalhando. Ainda assim, Ajude-nos a manter a qualidade da revista!
é válido ressaltar que em projetos Java, o Maven é a ferramenta
mais adotada.

Big Data: MapReduce
na prática
Como adotar o MapReduce em seu dia a dia
C
onjuntos de dados têm como solução ideal o Fique por dentro
uso de um modelo de processamento paralelo
e distribuído que se adapta a qualquer volume Este artigo aborda o uso do MapReduce na solução de um proble-
e grau de complexidade. Esse é o caso do MapReduce, ma complexo, que é melhor resolvido com a técnica de algoritmos
uma técnica que abstrai os detalhes de paralelização e genéticos (AG). Apesar da natureza iterativa dos AGs, com algumas
distribuição do processamento de dados, que pode ser adaptações é possível construir aplicações que necessitem de gran-
utilizada em aplicações que necessitem dessas carac- de poder de processamento e que podem ser executadas de forma
terísticas, como ocorre com algumas abordagens não paralela e distribuída no modelo MapReduce. Entre os softwares que
triviais, a exemplo do tratamento do “big data” e do podem ser beneficiados, há algoritmos de inteligência computacional,
processamento de algoritmos de alta complexidade e como AGs e redes neurais, e qualquer problema de otimização que
escalabilidade. necessite encontrar boas respostas em situações que normalmente são
Tais algoritmos podem ser empregados em diversas si- difíceis de serem resolvidas com aplicações tradicionais em uma única
tuações que envolvam resolver problemas de busca e oti- máquina. Por exemplo, sistemas para identificar padrões em biometria,
mização, normalmente presentes em sistemas de tomada formulação de regras em jogos de estratégia, na busca de melhores
de decisão e descoberta de conhecimento. Por exemplo, rotas (caminhos) a serem percorridas em um conjunto de cidades,
escolher qual a melhor empresa para investir o capital como é o caso do exemplo tratado neste artigo, entre outros.
(quantia) na bolsa de valores; solucionar problemas de
agendamento e planejamento de recursos; auxiliar na
organização e alocação de turmas a professores, presente resumido e agregado na saída, sendo cada função executada em
na definição de grades horárias de trabalho; e qualquer uma etapa distinta. Na primeira etapa, Map, uma função de ma-
situação que necessite uma boa solução (entre tantas), peamento distribui os dados em diversos nós de processamento e
considerando as regras específicas para o domínio do armazenamento. Na segunda etapa, Reduce, uma função agrega
problema a fim de alcançar o melhor resultado possível. e sumariza os resultados obtidos no mapeamento, para gerar um
Como podemos notar, são problemas complexos, muitas resultado final.
vezes de difícil solução e que envolvem significativas A técnica MapReduce pode ser aplicada em vários campos,
reduções de custos, melhorias dos tempos de processos como o agrupamento de dados, aprendizado de máquina e visão
e/ou melhor alocação dos recursos em atividade. computacional. Outro exemplo de campo que pode adotar essa
Como o MapReduce pode ajudar na solução desses técnica é o da Inteligência Computacional, em especial o dos Al-
problemas? Em essência, a resposta está na capacidade goritmos Genéticos, que devem tratar uma grande base de dados
do poder de processamento paralelo e distribuído da (a chamada população de indivíduos) para localizar valores para
técnica, fatores que permitem alta escalabilidade à uma tomada de decisão. Tais algoritmos exigem um alto custo de
solução. processamento para ser executado em uma única máquina, o que
O MapReduce é baseado no paradigma de programa- torna a técnica MapReduce ideal para ser adotada.
ção funcional, adotando duas funções que dão nome Com base nisso, este artigo demonstra o uso combinado da
ao modelo: a função map e a função reduce. Esse modelo abordagem AG com MapReduce para resolver um tipo especial
estabelece uma abstração que permite construir aplica- de problema complexo, chamado de “caixeiro viajante” (ou PCV).
ções com operações simples, escondendo os detalhes da Este problema busca identificar os melhores caminhos para se
paralelização. Em resumo, tais funções transformam um percorrer um conjunto de cidades, visitando pelo menos uma vez
grande volume de dados de entrada em um conjunto cada cidade em um determinado percurso. O PCV envolve um

número de combinações de caminhos de crescimento exponencial, O Algoritmo Genético é uma técnica de otimização inspirada
em função do número de cidades, fato que o torna complexo para no conceito da evolução natural das espécies. Essa técnica parte
ser resolvido com algoritmos tradicionais. Para validar a técnica da ideia da sobrevivência do indivíduo mais apto em uma popu-
proposta (AGs adaptados ao modelo MapReduce), um cenário de lação. Traduzindo para o contexto computacional, um indivíduo
teste foi aplicado para um conjunto de vinte cidades, o que de- pode ser a representação de uma informação em um conjunto de
monstrou um bom desempenho na geração de boas respostas. dados para um domínio particular, e o mais apto é o indivíduo
que está próximo da melhor informação que se tenta localizar no
Pré-requisitos espaço de busca (ou base de dados da solução). Dessa forma, um
Este tutorial foi projetado para ser executado em um computador AG é um procedimento de otimização para encontrar a melhor
com sistema operacional Linux, seja nativo ou rodando em uma (ou melhores) resposta(s), sem a necessidade de explorar todas as
máquina virtual (VMware ou VirtualBox, por exemplo), uma soluções possíveis nesse espaço de busca.
vez que o framework Hadoop (que implementa o MapReduce) Para criar uma população de possíveis respostas para um pro-
utiliza tal ambiente. Em ambos os casos (nativo ou virtualizado), blema, o AG usa um processo evolutivo. Em seguida, combina as
recomenda-se que a memória principal tenha no mínimo 1 Gi- melhores soluções para criar uma nova geração de soluções que
gabyte e espaço em disco suficiente para comportar a instalação deve ser melhor do que a geração anterior. Portanto, é um processo
do pacote Hadoop. Por se tratar de uma aplicação que simula a iterativo realizado em várias etapas (ou gerações) constituído das
maioria dos dados em memória, o espaço em disco exigido é no seguintes atividades:
mínimo de 2 Gigabytes. 1. Inicialização: É a criação da população inicial para o primeiro
Além do espaço da aplicação, ao final foram utilizados aproxi- ciclo do algoritmo. A criação envolve produzir um conjunto de
madamente dez gigabytes de espaço em disco para a distribuição dados pertinentes com o contexto real do problema, podendo ser
Linux (Ubuntu, versão 12), para a instalação do Apache Hadoop gerada aleatoriamente por meio de uma rotina automática;
(versão 1.2) e para a IDE Eclipse (versão Kepler 4.2). 2. Avaliação: Avalia-se a aptidão das soluções analisando a res-
posta de cada uma ao problema proposto;
Algoritmos Genéticos 3. Seleção: Os indivíduos são selecionados para combinação das
A otimização é o processo de encontrar a melhor solução (ou características (para a reprodução). A seleção é baseada na aptidão
solução ótima) de um conjunto de soluções para um problema. dos indivíduos;
Normalmente, tais problemas envolvem um procedimento para 4. Cruzamento: Características das soluções escolhidas são re-
escolha otimizada de recursos, que pode ser de natureza tem- combinadas, gerando novos indivíduos;
poral/cronológica, financeira/econômica, de espaço físico, de 5. Mutação: Características dos indivíduos resultantes do processo
priorização de tarefas, etc. Sendo assim, um processo de otimi- de reprodução são alteradas;
zação procura, geralmente, maximizar lucros, minimizar perdas, 6. Atualização: Os indivíduos criados na iteração da etapa cor-
realizar projetos econômicos e seguros, maximizar a capacidade rente são inseridos na população que será tratada na próxima
de transmissão de uma rede satisfazendo suas limitações, escolher iteração;
o melhor investimento, definir quando comprar e quando vender 7. Finalização: Verifica se as condições de encerramento da evo-
ações na bolsa de valores, traçar o roteiro de viagem e muitos lução foram atingidas.
outros exemplos. Em síntese, quando se fala em otimização, está
se pensando em maximizar ou minimizar uma função, chamada Em síntese, o processo inicia com a definição para o conceito
de função objetivo, sujeita a certas restrições. de “indivíduo”, que deve ser codificado em uma representação
As técnicas de otimização devem ser utilizadas quando não que possa estruturar os dados para a solução do problema.
existe uma solução simples e diretamente calculável para o pro- A população inicial de indivíduos é então preparada, geralmen-
blema. Isso geralmente ocorre quando a estrutura do problema é te de forma aleatória, seguindo critérios estabelecidos a partir
complexa ou existem muitas formas possíveis de resolver. Nesses de uma função objetivo, que define a aptidão de cada indivíduo
casos, é possível que não exista uma equação direta ou um pro- ao contexto do problema. Essa aptidão, um valor obtido a partir
cedimento matemático ou algorítmico para resolver o problema, do cálculo de uma função, é usada para encontrar os indivíduos
de forma que uma técnica de otimização seja a mais indicada para cruzamento com outros indivíduos, assim recombinados
para encontrar (ou se aproximar) da melhor resposta possível para criar novos indivíduos que são copiados para a nova
para o problema. geração. Além do cruzamento, alguns indivíduos podem ser
Para aplicar uma técnica de otimização, dois conceitos são escolhidos ao acaso para sofrer mutação, com o objetivo de
relevantes: o espaço de busca, “local” onde todas as possíveis melhorar a diversidade da população. Após esse processo,
soluções do problema se encontram; e a função objetivo, utiliza- uma nova geração é formada e o processo é repetido até que
da para avaliar as soluções produzidas, associando a cada uma algum critério de parada tenha sido atingido. Nesse ponto, o
delas um valor que denota uma nota ou peso a ser considerado indivíduo que está mais próximo do ideal é identificado e o
na avaliação. processo é concluído.

Big Data: MapReduce na prática
Problema do Caixeiro Viajante

O Problema do Caixeiro Viajante (PCV) consiste em encontrar o
menor caminho para um caixeiro viajante que, dado um conjun-
to de cidades, deve visitar todas elas precisamente uma vez até
retornar à cidade de origem.
Apesar da simplicidade em sua formulação, este é um problema
de difícil solução, tornando-se um dos problemas de otimização
mais estudados. A sua complexidade decorre do crescimento
exacerbado do espaço de busca que surge a partir dos diversos
caminhos a percorrer, uma vez que o tamanho aumenta exponen-
cialmente com o aumento do número de cidades.
Há muitas aplicações reais para o PCV nos campos da logística,
do transporte de pessoas e cargas, e na pesquisa operacional de
um modo geral. Por esse motivo, muitos algoritmos foram de-
senvolvidos tentando alcançar os melhores resultados esperados,
entre eles a abordagem dos Algoritmos Genéticos.
Representação do problema
No PCV, o conceito de indivíduo é aplicado à representação do
caminho a ser percorrido entre as cidades, e a função objetivo
Figura 1. Exemplo de mapa para dez cidades do PCVS
para calcular a aptidão do indivíduo é determinada pela distân-
cia obtida para esse caminho. Assim, uma forma de estruturar
a codificação do indivíduo é representar o caminho de cidades
usando um grafo não direcionado com pesos nas arestas, como
será explicado a seguir. Por se inspirar na matemática que lida
com a geometria dos planos, essa representação é chamada PCV
Simétrico Euclidiano (PCVS).
Considere, por exemplo, um conjunto de dez cidades posiciona-
das em um plano bidimensional, com dois eixos (x e y) iniciados
Figura 2. Equação para calcular a distância entre cidades
em zero, como visto na Figura 1. No PCVS para este caso (dez
cidades), os caminhos são identificados por uma sequência de Cidade X Y
caracteres, onde cada caractere representa uma cidade utilizan- A 1 2
do uma letra do alfabeto (A, B, ..., Z). No plano, cada letra é uma B 7 9
coordenada x,y. Para simplificar a demonstração da solução,
C 3 3
optou-se por empregar um conjunto de dez cidades, que segue a
D 1 5
sequência de “A” até “J”.
Inicialmente, para resolver o PCVS é necessário conhecer as E 4 3
distâncias entre todas as cidades. Considerando que uma cidade F 5 6
(C) está localizada em um ponto (x, y) do plano (mapa), como G 2 4
visto na Figura 1, o processo para calcular a distância total (D) H 8 3
entre uma cidade origem (C1) e a n-ésima (Cn) cidade (dentro de
I 9 2
um caminho válido para n cidades) é determinado pela soma
J 6 9
das distâncias (d) das coordenadas (x, y) das cidades que fazem
parte desse caminho, aplicando a fórmula vista na Figura 2. Em Tabela 1. Coordenadas relativas das cidades no plano euclidiano
outras palavras, o que estamos fazendo é calcular o perímetro
do polígono formado pela sequência de cidades pertencentes ao Dessa forma, aplicando a equação da Figura 2 calcula-se a
caminho válido. distância percorrida em um caminho. Por exemplo, no cálculo do
A título de exemplo, adotando-se as coordenadas relativas (x, y) caminho “ABCDEFGHIJ” chega-se ao valor aproximado de 53.3,
para cálculo das distâncias entre as cidades (como visto na Figura 1), conforme demonstra a Figura 3.
encontramos os valores disponíveis na Tabela 1. Para esse proble-
ma, como mencionado anteriormente, as cidades são identificadas Modelagem no MapReduce
por letras, e um caminho é representado pela sequência das letras A implementação de um Algoritmo Genético no paradigma do
destas cidades, como no caso “ABCDEFGHIJ”. MapReduce apresenta alguns desafios. O maior deles é adaptar

a natureza iterativa do AG, onde cada ite-
ração produz uma população ou geração
de indivíduos, ao modelo em duas etapas
do MapReduce. Embora encontremos
algumas propostas na literatura especia-
lizada da área, neste trabalho optou-se
pela chamada Dupla Geração, pois esta
se adequa bem e executa eficientemente o
AG do PCVS no MapReduce. Em síntese,
a Dupla Geração realiza o AG em dois
passos de gerações, denominadas de local
e global.
As gerações locais são criadas na etapa que
executa a função de mapeamento. Com
uma população inicial de indivíduos (os
dados de entrada), o AG cria novas gera-
Figura 3. Exemplo do cálculo da distância entre as cidades “ABCDEFGHIJ”
ções no processo de mapeamento, resul-
tando em uma população bem melhor (em
termos de indivíduos) do que a população
inicial. Isso ocorre devido aos operadores
genéticos aplicados (seleção, cruzamento e
mutação), acrescido do mecanismo chama-
do de elitismo, que acrescenta o indivíduo
que possui a melhor aptidão entre todos
os outros indivíduos da população inicial.
Tal resultado é então enviado para a fase
intermediária do framework MapReduce,
conhecida como Shuffle e Sort.
As gerações globais são criadas na etapa da
função de redução, a partir da população
gerada no mapeamento. Portanto, o AG
atua novamente agora na população que
vem do mapeamento, formando uma nova
população, uma evolução em relação à
inicial. O resultado da redução estabelece
uma pequena população com os melhores
Figura 4. Funcionamento do processamento MapReduce para o Algoritmo Genético
indivíduos, sendo que a melhor resposta
é aquele indivíduo que possui a melhor
aptidão (menor distância). recebe a população formada por indivíduos com boas aptidões
A Figura 4 apresenta um esquema resumido do funcionamen- (menores distâncias) em relação à população inicial, e depura
to do AG no MapReduce. A parte superior da figura mostra as ainda mais essa população identificando aquele indivíduo com
principais atividades envolvidas no processamento: a entrada, o a melhor aptidão.
mapeamento, a fase intermediária (shuffle & sort), a redução e a O poder do processamento paralelo permite dividir a população
saída. Na entrada, a população inicial é gerada randomicamente em várias tarefas map, que correspondem à execução paralela de
fora da tarefa MapReduce. Ao entrar no processamento de mape- vários processos de AG sobre uma subpopulação. Isso é possível
amento, essa população inicial é dividida e distribuída entre as graças a capacidade de executar em paralelo várias tarefas em má-
máquinas que executam a função map. Cada divisão forma uma quinas distintas, aumentando o desempenho de processamento
subpopulação local, que é processada pela função map através dos algoritmos genéticos.
do AG do PCVS. O resultado das fases de mapeamento e inter- Do ponto de vista do fluxo de dados, o funcionamento do AG
mediária produz uma coleção de dados, constituída por linhas na técnica MapReduce pode ser descrito em quatro momentos,
de chave/valor, onde a chave é a aptidão e o valor é um indivíduo, explicados da seguinte forma:
representado por uma estrutura combinada pelo caminho de 1) A entrada dos dados recebe um arquivo texto, em que
cidades e sua aptidão (a distância do caminho). A fase de redução cada linha é uma representação codificada de um indivíduo.

Para simplificar o exemplo, cada letra presente na cadeia de strin- Entrada | map |
gs do indivíduo possui uma correspondência com uma cidade ABCDEIGHFJ ( 0, ABCDEIGHFJ) ( 53, <ABCDEFGHIJ, 53.3475288096413>)
GIJABEFCDH ( 1, GIJABEFCDH) ( 51, <GHIJABEFCD, 50,6532924781218>)
no mapa, e as coordenadas (x, y) de cada cidade está registrada BEFGHIJACD ( 2, BEFGHIJACD) ( 53, <EBFHGIJACD, 52.8074130652778>)
EBGFHCDIJA ( 3, EBGFHCDIJA) ( 51, <EBHFCDIJGA, 51.4288322764095>)
na aplicação. A seguir temos um exemplo de quatro linhas de
indivíduos:
| shuffle
(51, [<GHIJABEFCD, 50,6532924781218>, <EBHFCDIJGA, 51.4288322764095>])
ABCDEIGHFJ (53, [<ABCDEFGHIJ, 53.3475288096413>, <EBFHGIJACD, 52.8074130652778>])
GIJABEFCDH
BEFGHIJACD reduce > Saída
EBGFHCDIJA (27.866056254812328, ACEHIBJFDG) 27.866056254812328, ACEHIBJFDG
(28.014106081769356, GFJBHIECAD) 28.014106081769356, GFJBHIECAD
2) Logo após, para atender as regras do MapReduce, os dados de

entrada são estruturados em dois campos: chave e valor. A chave Figura 5. Fluxo de dados do processo MapReduce para o AG
representa o número da linha e o valor é o conteúdo original da
linha, que contém o indivíduo, representando o caminho com a Na essência do processo, as funções map e reduce mantêm o
sequência das cidades (em forma de letras). A função map avalia controle dos melhores indivíduos, evidenciados no fluxo de dados
e armazena uma quantidade de linhas (indivíduos) em uma lista, da Figura 5. No término do processo, é realizada a gravação das
formando a população inicial para o processo AG gerar novos in- saídas da fase reduce em um arquivo no sistema de arquivos do
divíduos. Em seguida, esses indivíduos são tratados e codificados Hadoop (o HDFS).
na forma do par “aptidão/indivíduo” (chave/valor), sendo que a O HDFS (Hadoop Distributed File System) é um sistema de arqui-
chave é o arredondamento da aptidão para um número inteiro, vos distribuído projetado para armazenar dados em uma rede de
e o valor é um par <cromossomo/aptidão>. O resultado produz computadores de baixo custo. Ele faz parte da arquitetura Apache
um conjunto de dados em forma de linhas, como no exemplo a Hadoop e foi otimizado para aplicações nas quais é necessário ler
seguir: uma quantidade muito grande de dados.
( 53, <ABCDEFGHIJ, 53.3475288096413>) Implementação

( 51, <GHIJABEFCD, 50,6532924781218>) A aplicação MapReduce para resolver o problema do PCV é cons-
( 53, <EBFHGIJACD, 52.8074130652778>) truída com base no diagrama de classes da Figura 6. Os estereóti-
( 51, <EBHFCDIJGA, 51.4288322764095>) pos <<Mapper>> e <<Reducer>> denotam os papéis das funções
de mapeamento e redução, respectivamente. O estereótipo <<Dri-
3) Depois, a saída da função map é processada pela fase inter- ver>> é a aplicação principal que orquestra a execução das duas
mediária (Shuffle e Sort), agrupando os pares aptidão/indivíduo funções. A lógica do AG está toda concentrada em uma classe de
(chave/valor) pela aptidão, onde a chave é um número inteiro apoio, chamada OperacaoGenetica, enquanto a classe Individuo
calculado pelo arredondamento da aptidão (distância aproximada) (estereotipada com <<Writable>>) é utilizada para representar o
e o valor é uma lista de indivíduos que pertencem àquela chave conteúdo a ser processado pelo AG. O código-fonte destas classes
pela aptidão aproximada ao número inteiro da chave. Após a foi implementado em Java e será explicado a seguir.
fase intermediária, os dados são enviados para a fase reduce da Considerando que o ambiente de desenvolvimento está monta-
seguinte forma: do com o sistema operacional Linux, o IDE Eclipse e o framework
Apache Hadoop (versão 1.2), vamos iniciar o passo a passo
(51, [<GHIJABEFCD, 50,6532924781218>, <EBHFCDIJGA, 51.4288322764095>]) para a construção do projeto. Neste cenário, o Eclipse ainda
(53, [<ABCDEFGHIJ, 53.3475288096413>, <EBFHGIJACD, 52.8074130652778>]) deve estar configurado com um plugin para uso do framework
Hadoop, que está disponível para download em um arquivo
4) Note que para cada chave há uma lista de indivíduos que é JAR, denominado hadoop-eclipse-plugin-1.2.jar, preparado para
usada pela função reduce para gerar uma nova população através ser instalado na versão Kepler desta IDE (veja o endereço na
do processo AG. Seguindo a característica paralela/distribuída seção Links). Para isso, adicione o plugin copiando o arquivo
do MapReduce, cada tarefa reduce aplica sobre o “valor” (com a JAR para a pasta plug-ins do Eclipse. Para configurar o plugin,
lista de indivíduos) o AG para identificar os melhores indivíduos, execute a IDE, acesse o menu Window e escolha Preferences. No
produzindo registros de pares “aptidão/indivíduo”, como: item Hadoop Map/Reduce, informe o local onde o Hadoop foi
instalado e clique em Ok.
(27.866056254812328, ACEHIBJFDG) Com o plugin instalado e configurado, podemos criar o projeto
(28.014106081769356, GFJBHIECAD) MapReduce para a aplicação deste artigo. Sendo assim, com o
Eclipse aberto, escolha no menu File a opção New Project e em
Todo esse processo de fluxo de dados pode ser visto na Figura 4. seguida o item Map/Reduce Project, como mostra a Figura 7.

Figura 6. Diagrama de classe do PCV-AG para o MapReduce
No passo seguinte, informe o nome

do projeto, confirme e aguarde a
criação da estrutura do projeto con-
tendo a pasta de código (src) e todas
as bibliotecas do Hadoop importadas.
Agora estamos prontos para imple-
mentar as classes da aplicação.
Codificando o Indivíduo
A Listagem 1 apresenta o código
da classe Individuo, que instanciará
os objetos (dados) trabalhados nas
funções map e reduce. Como esses
objetos não seguem os tipos padrões
do MapReduce (que são Integer, Float,
Text, etc.), foi necessário implementar Figura 7. Criação de um projeto MapReduce
a interface Writable, que permite per-
Nota
sonalizar a estrutura de dados com dois atributos: o cromossomo do
indivíduo, representado por uma cadeia de caracteres (String), e sua O Hadoop disponibiliza ao programador a interface Writable, solução que permite criar objetos para
aptidão, que é um número real (double). O termo “cromossomo” foi o processamento distribuído do MapReduce. Para isso, basta criar uma classe que a implemente. Tal
usado porque no linguajar dos algoritmos genéticos cromossomo é a interface especifica dois métodos que devem ser construídos: o write(), para gravar os objetos na
própria representação do indivíduo; neste caso, a cadeia de caracteres saída (DataOutput), que normalmente é um arquivo texto; e readFields(), para a leitura dos objetos
que especifica o caminho das cidades percorridas. Já a aptidão é o obtidos no fluxo de entrada (DataInput), que normalmente são obtidos de um arquivo texto. No projeto
resultado do cálculo da distância total desse caminho. Em resumo, deste artigo, a classe Individuo implementa Writable, mas na maioria das vezes, customizar a interface
os objetos instanciados dessa classe são usados em todo o processa- Writable é desnecessário, pois o Hadoop disponibiliza estruturas de dados prontas para objetos em
mento do MapReduce. forma de arrays, mapas e todos os tipos primitivos da linguagem Java (com exceção ao char).

Listagem 1. Código da classe Individuo. Context context. Os dois primeiros são correspondentes ao par
chave/valor de entrada. Já o último parâmetro, o objeto Context,
// imports omitidos...
representa o objeto que permite que a aplicação se comunique e
public class Individuo implements Writable { envie dados para o framework Hadoop a serem processados na
fase reduce.
private String cromossomo;
private double aptidao;
Listagem 2. Código da função map – classe CaixeiroViajanteMapper.
@Override
public void write(DataOutput out) throws IOException { // imports omitidos...
out.writeUTF(cromossomo);
out.writeDouble(aptidao); public class CaixeiroViajanteMapper extends
} Mapper<Object, Text, IntWritable, Individuo> {
@Override private ArrayList<Individuo> populacao = new ArrayList<Individuo>();

public void readFields(DataInput in) throws IOException { private OperacaoGenetica operacaoGenetica = new OperacaoGenetica();
this.cromossomo = in.readUTF();
this.aptidao = in.readDouble(); @Override
} public void map(Object key, Text value, Context context)
throws IOException, InterruptedException {
// gets e sets ArrayList<Individuo> popula = new ArrayList<Individuo>();
} Individuo individuo = new Individuo();
individuo.setCromossomo(value.toString());
A classe de mapeamento CaixeiroViajanteMapper popula.add(individuo);

popula = operacaoGenetica.calcularAptidao(popula);
O papel de mapeamento é realizado pela classe Caixeiro- populacao.add(popula.get(0));
ViajanteMapper, cujo código é apresentado na Listagem 2. Por operacaoGenetica.setTaxaMutacao(0.05);
if (populacao.size() == 100) {
ser uma extensão da classe genérica Mapper, é necessário declarar geracaoLocal(context);
os tipos de dados que serão manipulados como chave e valor de }
entrada (neste caso, Object e Text) e os tipos (chave e valor) de }
saída (IntWritable e Individuo, respectivamente). public void geracaoLocal(Context context) throws IOException,
Para cumprir a função de mapeamento, CaixeiroViajante- InterruptedException {
Mapper possui os atributos populacao e operacaoGenetica que int CondicaoDeParada = 10;
int geracao = 0;
são, respectivamente, uma lista do tipo Individuo e o objeto que while (CondicaoDeParada != geracao) {
encapsula todas as operações do algoritmo genético (cruzamento, populacao = operacaoGenetica.selecao(populacao);
populacao = operacaoGenetica.cruzamento(populacao);
mutação, etc.). Portanto, tais campos (atributos) são usados nas ta-
populacao = operacaoGenetica.mutacao(populacao);
refas de criação dos grupos de indivíduos, no armazenamento do populacao = operacaoGenetica.calcularAptidao(populacao);
melhor indivíduo e para fornecer as operações ao processo AG. geracao++;
}
populacao.add(operacaoGenetica.getMelhorIndividuo());
Nota int Aptidao;
for (Individuo individuo : populacao) {
No Hadoop, a função map é representada por uma classe derivada da classe abstrata Mapper, um
Aptidao = (int) Math.round(individuo.getAptidao());
tipo genérico que permite tratar os dados definidos no par chave/valor. Mapper trabalha com context.write(new IntWritable(Aptidao), individuo);
quatro parâmetros que especificam a chave de entrada, o valor de entrada, a chave de saída e o }
populacao.clear();
valor de saída. Além disso, essa classe declara quatro métodos (setup(), map(), cleanup() e run())
}
que podem ser usados pela aplicação do usuário. Dentre eles, map() é o único método que é @Override
obrigatório implementar. Na ordem de chamadas, o primeiro método a ser executado é o setup(), protected void cleanup(Context context) throws IOException,
InterruptedException {
que realiza algum procedimento de inicialização da tarefa (job) de mapeamento. O método run()
geracaoLocal(context);
permite que o programador altere alguns dos parâmetros de configuração do job, que normalmente }
são especificados na classe principal da aplicação. O método map(), por sua vez, realiza a lógica de
}
processamento do mapeamento. Por fim, o método cleanup() pode ser implementado para executar
algum código no fim da tarefa de mapeamento, por exemplo, fechamento de conexões com o banco
de dados e reinicialização de variáveis. O método geracaoLocal() foi criado para modularizar o proces-
so AG, na função de mapeamento. Este método é chamado para
atuar em um conjunto de 100 indivíduos, onde são aplicadas as
A classe CaixeiroViajanteMapper ainda possui dois métodos operações genéticas de seleção, cruzamento e mutação sobre 5% da
herdados da classe Mapper: map() e cleanup(), e um método au- população. Essas operações são executadas 10 vezes (gerações), em
xiliar, denominado geracaoLocal(). O map() é o método principal um laço while cuja condição de parada ocorre quando a variável
da classe e trabalha com três parâmetros: Object key, Text value, CondicaoDeParada for igual a 10.

Após o laço, é acrescentada à população um indivíduo conside- pois cada tarefa reduce recebe indivíduos de aptidão muito próxi-
rado o melhor, na chamada operação de elitismo. No fim, o método mos, aumentando assim a possibilidade de indivíduos semelhantes.
geracaoLocal() utiliza o objeto passado no argumento Context Essa situação (de indivíduos com aptidões próximas) pode elevar o
para produzir a população de indivíduos para as fases seguintes risco de convergência prematura, um fenômeno presente na técnica
(intermediária e redução), via instrução context.write(...), selecio- dos algoritmos genéticos que produz uma solução precoce, distante
nados pelo critério de aptidão (menor caminho). da solução ótima para o problema. Esse problema pode ser resolvido
Concluindo, o método cleanup() foi implementado para ser aumentando a diversidade da população, aplicando-se o operador
chamado na finalização da tarefa de mapeamento. Neste caso, irá de mutação com uma taxa elevada.
executar mais uma etapa do AG, por meio da chamada ao método
geracaoLocal(), apenas para garantir que o AG atuará nos indi- Listagem 3. Código da função de redução – classe CaixeiroViajanteReducer.
víduos que não entraram no último conjunto de cem indivíduos.
Lembre-se que cada conjunto é selecionado para ser tratado pelos
operadores AG no método map(), na condição representada pelo public class CaixeiroViajanteReducer extends
comando if (populacao.size() == 100). Reducer<IntWritable, Individuo, DoubleWritable, Text> {
private ArrayList<Individuo> populacao = new ArrayList<Individuo>();

A classe de redução CaixeiroViajanteReducer private OperacaoGenetica operacaoGenetica;
A classe CaixeiroViajanteReducer, apresentada na Listagem 3,
@Override
representa a função de redução. Para isso, ela deve estender public void reduce(IntWritable key, Iterable<Individuo> values,
Reducer, uma classe genérica que exige a definição dos tipos Context context) throws IOException, InterruptedException {
(classes) para os dados de entrada e saída do processo de redu- operacaoGenetica = new OperacaoGenetica();
operacaoGenetica.setTaxaMutacao(0.9);
ção. Neste caso, os tipos de entrada para o par chave/valor são, for (Individuo val : values) {populacao.add(val); }
respectivamente, as classes IntWritable e Individuo, que formam if(populacao.size() == 1) {
a estrutura para os dados gerados no processo de mapeamento, operacaoGenetica.setMelhorIndividuo(populacao.get(0));
}
representando, respectivamente, a distância (em inteiro) e o in- int CondicaoDeParada = 10;
divíduo (que representa o caminho e aptidão). Para os tipos da int geracao = 0;
saída, as classes DoubleWritable e Text definem, respectivamente, while (geracao < CondicaoDeParada) {
populacao = operacaoGenetica.selecao(populacao);
para o par chave/valor, que a chave terá um formato decimal populacao = operacaoGenetica.cruzamento(populacao);
(Double) para representar a distância e o valor terá uma cadeia populacao = operacaoGenetica.mutacao(populacao);
populacao = operacaoGenetica.calcularAptidao(populacao);
de caracteres (Text) para identificar o caminho (de cidades) para
geracao++;
aquela distância. Outros detalhes da classe, como os atributos }
populacao e operacaoGenetica, seguem as mesmas explicações Individuo ind = operacaoGenetica.getMelhorIndividuo();
context.write(new DoubleWritable(ind.getAptidao()),
dadas na classe CaixeiroViajanteMapper.
new Text(ind.getCromossomo()));
populacao.clear();
Nota }
A função reduce é representada por uma classe derivada da classe abstrata Reducer, um tipo genérico }
semelhante ao Mapper. O Reducer possui quatro parâmetros que são usados para especificar os
tipos (classe) de objetos manipulados na função de redução. Em essência, eles definem dois pares de
objetos chave/valor, sendo um par para entrada e outro para saída. Da mesma forma que Mapper, Em resumo, a finalidade do método reduce() é recuperar a lista
a classe Reducer fornece quatro métodos (setup(), reduce(), cleanup() e run()) que podem ser de indivíduos de entrada e processar o AG nessa população.
implementados na classe de redução. Na prática, apenas a implementação do método reduce() é O AG é executado pelo atributo operacaoGenetica, que realiza
obrigatória, pois é ele quem realiza a função de redução. Para os outros métodos (setup(), cleanup() dez vezes (10 gerações) as operações genéticas de seleção, cruza-
e run()), o framework os trata da mesma maneira como na classe Mapper. mento e mutação, além de calcular a aptidão para cada indivíduo
da população. Ao final, acrescenta-se à população já processada
o melhor indivíduo, pela chamada ao método operacaoGenetica
O método reduce() trabalha com três parâmetros. Os dois pri- .getMelhorIndividuo(), tratamento esse chamado de elitismo.
meiros (key e values) são referentes ao par chave/valor de entrada, Finalizando, o método reduce() gera na saída a população conten-
que correspondem aos tipos de saída da fase de mapeamento (um do os melhores indivíduos, gravando os dados na pasta /Output
inteiro representando a aptidão e uma lista de indivíduos que (como veremos a seguir) pela chamada ao método write() do
pertencem àquela aptidão). O último parâmetro (o objeto context) objeto context.
é responsável pelo resultado final da tarefa de redução, gerando
os dados de saída. A classe da lógica AG: OperacaoGenetica
No trecho operacaoGenetica.setTaxaMutacao(0.9), a taxa de muta- Na classe OperacaoGenetica encontra-se toda a inteligência do
ção é definida em 90%, mais alta que no mapeamento (de apenas 5%), algoritmo genético. Esta disponibiliza todas as operações previstas

na técnica dos AGs, que são: seleção, cruzamento, mutação, cálculo quickSort() garante uma lista de indivíduos ordenada de forma
de aptidão e elitismo. Tais operações são traduzidas em métodos descendente, do que possui a maior aptidão para o de menor apti-
da classe e são explicados a seguir. dão. Com o objetivo de reduzir a quantidade de indivíduos menos
Na Listagem 4 vê-se a definição dos atributos da classe Operacao- aptos que podem estar presentes na população, uma quantidade
Genetica: melhorIndividuo, tamanhoIndividuo, taxaMutacao, dos melhores indivíduos é novamente adicionada à população.
alfabeto e distancias. O atributo melhorIndividuo tem o objetivo Isso é feito limpando a lista, via populacao.clear(), e adicionando
de guardar o melhor indivíduo encontrado durante o processo AG. a ela os 70% dos melhores indivíduos do ranking de classificação
O atributo tamanhoIndividuo, por sua vez, define o tamanho da e depois outros 30% também dos melhores indivíduos. Mesmo
cadeia de cidades (neste caso, 20). Já o atributo alfabeto representa duplicados, tais indivíduos sofrerão um processo de mutação na
as vinte cidades, onde cada cidade é representada por uma letra do etapa seguinte. Dessa forma garantimos o retorno de uma nova
alfabeto, enquanto distancias representa uma matriz contendo as população com os indivíduos de maior aptidão.
coordenadas de cada cidade (letra) no plano cartesiano. Por fim, Na operação genética de seleção é necessário utilizar algum
o atributo taxaMutacao define a taxa (5%) que será aplicada na método de ranqueamento para a escolha dos indivíduos mais
operação de mutação da população. aptos. Assim, foi implementado o método quickSort(), exposto na
Listagem 7 e que realiza a ordenação de uma lista de indivíduos
Listagem 4. Código resumido da classe auxiliar OperacaoGenetica. (população), para ser usado no método selecao().
Listagem 5. Código do método calcularAptidao().
public class OperacaoGenetica {
private Individuo melhorIndividuo = new Individuo(); public ArrayList<Individuo> calcularAptidao(ArrayList<Individuo> populacao)
private int tamanhoIndividuo = 20; throws IOException {
private double taxaMutacao = 0.05; ArrayList<Individuo> popula = new ArrayList<Individuo>();
private String alfabeto = “ABCDEFGHIJKLMNOPQRSTUVWXYZ”; double aptidao =0;
private int[][] distancias = { int x1, x2, y1, y2, pos;
{ 1, 8 }, { 1,10 }, { 2,13 }, { 3,15 }, { 5,16 }, String[] indString;
{ 8,17 }, { 10,17}, { 13,16}, { 15,15}, { 16,13}, for (Individuo indi : populacao) {
{ 17,10}, { 17,8 }, { 16,5 }, { 15,3 }, { 13,2 }, indString = new String[tamanhoIndividuo];
{ 10,1 }, { 8, 1 }, { 5, 2 }, { 3, 3 }, { 2, 5 } }; indString = indi.getIndArray();
for (int j = 0; j < tamanhoIndividuo; j++) {
public ArrayList<Individuo> calcularAptidao(ArrayList<Individuo> populacao) {...};
public ArrayList<Individuo> selecao(ArrayList<Individuo> populacao) {...}; pos = alfabeto.indexOf(indString[j]);
private Individuo[] quickSort(Individuo[] pop, int inicio, int fim) {...}; x1 = distancias[pos][0];
public ArrayList<Individuo> cruzamento(ArrayList<Individuo> populacaoA) {...}; y1 = distancias[pos][1];
pos = alfabeto.indexOf(indString[(j + 1)%tamanhoIndividuo]);
public ArrayList<Individuo> mutacao(ArrayList<Individuo> populacao) {...}; x2 = distancias[pos][0];
public Individuo getMelhorIndividuo() {...} y2 = distancias[pos][1];
public void setMelhorIndividuo(Individuo ind) {...} aptidao += Math.sqrt(Math.pow(x1 - x2, 2)
public double getTaxaMutacao(){...} + Math.pow(y1 - y2, 2));
public void setTaxaMutacao(double taxa) {...} }
} indi.setAptidao(aptidao);
setMelhorIndividuo(indi);
popula.add(indi);
aptidao = 0;
Como o próprio nome indica, o método calcularAptidao(), visto }
na Listagem 5, serve para calcular a aptidão da função objetivo do return popula;
}
problema em questão, que se resume em determinar a distância a
ser percorrida na roda de navegação entre as cidades especificadas Listagem 6. Código do método selecao().
em cada indivíduo. Para isso, o método localiza as coordenadas
public ArrayList<Individuo> selecao( ArrayList<Individuo> populacao) throws
das cidades (no atributo alfabeto) para determinar o valor do IOException {
atributo distancias. Em seguida, aplica o cálculo da distância int tamanhoPop = populacao.size();
euclidiana e acumula o valor na variável aptidao, registrando o Individuo[] popula = new Individuo[tamanhoPop];
popula = populacao.toArray(popula);
resultado no atributo correspondente daquele indivíduo (usando popula = quickSort(popula, 0, tamanhoPop - 1);
o método setAptidao()). Depois é chamado o método setMelhor- populacao.clear();
Individuo() para identificar o melhor individuo (com a menor
for(int i=0; i < (popula.length*(0.7)); i++){
distância), para ser utilizado na operação de elitismo. No fim, o populacao.add(popula[i]);
método calcularAptidao() retorna a lista (população) de indiví- }
duos e suas aptidões calculadas. for(int i=0; i < (popula.length*0.3); i++){
populacao.add(popula[i]);
Já o método selecao(), cujo código é apresentado na Listagem 6, }
realiza a operação de seleção dos indivíduos mais aptos. Para return populacao;
}
escolher os melhores, uma chamada ao método de classificação

Para efetuar essa ordenação, o método divide a lista em segmen- Ao fim do processamento, é retornada uma lista com os indivíduos
tos, seleciona um indivíduo de referência (variável pivo) e depois ordenados do mais apto ao menos apto.
o compara a todos os demais. Os mais aptos são deslocados para o A Listagem 8 mostra o método da operação genética de cruza-
segmento inicial da lista, os menos aptos para o fim e entre ambos mento. Este visa produzir novos indivíduos misturando caracte-
(no meio da lista) fica o segmento do pivo. De forma recursiva, rísticas de dois indivíduos “pais”. Para efetuar o cruzamento são
cada segmento realiza o mesmo procedimento chamando o mé- utilizados dois pontos de corte que atuam em posições fixas da
todo quickSort() até que não haja mais segmento para classificar. representação do indivíduo (variáveis pp e sp). Essas posições
são determinadas pelo valor do atributo tamanhoIndividuo, que
Listagem 7. Código do método quickSort(). estabelece o tamanho da seção de corte. Em seguida, um par de
indivíduos “pai” é selecionado a partir de dois indivíduos con-
private Individuo[] quickSort(Individuo[] pop, int inicio, int fim) {
int meio; secutivos na população (nas variáveis indPai1 e indPai2) e suas
if (inicio < fim) { seções de corte são utilizadas para compor os novos indivíduos

(variáveis indFilho1 e indFilho2). Feito isso, cada filho criado
int topo, indice;
preserva a seção central de seu indivíduo pai, mas todos os outros
Individuo pivo; dados são trocados entre os progenitores, gerando filhos com
pivo = pop[inicio];
características distintas. Essa explicação é apresentada de forma

topo = inicio; gráfica na Figura 8.
for (indice = inicio + 1; indice <= fim; indice++) { Dessa forma, os novos indivíduos gerados no processo de cru-
if (pop[indice].getAptidao() < pivo.getAptidao()) {
pop[topo] = pop[indice];
zamento formarão uma nova população, construída e evoluída a
pop[indice] = pop[topo + 1]; partir da população anterior.
topo++; O código exposto na Listagem 9 trata do método que realiza
}
} a operação genética de mutação, necessária para a introdução
pop[topo] = pivo; e manutenção da diversidade genética da população. Antes de
meio = topo; realizar essa operação é verificado se a população é de um único
quickSort(pop, inicio, meio);
quickSort(pop, meio + 1, fim); indivíduo, fato que estabelece a taxa de mutação em 100%. Caso
} contrário, essa taxa é previamente configurada no atributo taxa-
return pop;
Mutacao para cada função com seus valores default, que são de
}
5% no mapeamento e 90% na redução.
Listagem 8. Código do método cruzamento().
public ArrayList<Individuo> cruzamento(ArrayList<Individuo> populacaoA) throws presente |= indPai2[c2].equals(indFilho1[k]);

IOException { }
int tamanhoPop = populacaoA.size(); if (!presente) {
Individuo[] populacao = new Individuo[tamanhoPop]; indFilho1[j] = indPai2[c2];
populacao = populacaoA.toArray(populacao); }
populacaoA.clear(); c2 = (c2 + 1) % tamanhoIndividuo;
String[] indPai1,indPai2, indFilho1, indFilho2; } while (presente);
int pp = 3, sp = 7, k, c1, c2; do {
int tamanhoSecao = (int) tamanhoIndividuo/2; presente = false;
Random r = new Random(); for (k = pp; k <= sp; k++) {
boolean presente; presente |= indPai1[c1].equals(indFilho2[k]);
for (int i = 0; i < tamanhoPop; i += 2) { }
indFilho1 = new String[tamanhoIndividuo]; if (!presente) {
indFilho2 = new String[tamanhoIndividuo]; indFilho2[j] = indPai1[c1];
pp = r.nextInt(tamanhoSecao - 1);//ponto de corte c1 = (c1 + 1) % tamanhoIndividuo;
sp = pp+tamanhoSecao; //ponto de corte } while (presente);
if (i + 1 < tamanhoPop) { }
indPai1 = populacao[i].getIndArray(); Individuo indF1 = new Individuo();
indPai2 = populacao[i + 1].getIndArray(); Individuo indF2 = new Individuo();
for (int c = pp; c <= sp; c++) { indF1.setIndArray(indFilho1);
indFilho1[c] = indPai1[c]; indF2.setIndArray(indFilho2);
indFilho2[c] = indPai2[c]; populacaoA.add(indF1);
} populacaoA.add(indF2);
c1 = sp + 1; } else {
c2 = sp + 1; populacaoA.add(populacao[i]);
for (int j = sp + 1; j != pp; j = (j + 1) % tamanhoIndividuo) { }
do { }
presente = false; return populacaoA;
for (k = pp; k <= sp; k++) { }

a verificação do indivíduo mais apto,

lembrando que a melhor aptidão significa
um indivíduo com um valor de distância
menor para o caminho entre as cidades.
Portanto, para cada indivíduo submetido
para o método (pelo parâmetro ind), é
verificado se ele tem aptidão menor que a
aptidão do melhorIndividuo, atributo que
é definido no método calcularAptidao().
Caso verdadeiro, o melhor indivíduo (pre-
sente na variável melhorInd) passa a ser o
indivíduo presente no parâmetro ind.
Por fim, os métodos getTaxaMuta-
cao() e setTaxaMutacao(), mostrados na
Figura 8. Funcionamento do operador de cruzamento Listagem 11, são, por padrão, os métodos
de acesso ao atributo taxaMutacao.
Listagem 9. Código do método mutacao().
public ArrayList<Individuo> mutacao(ArrayList<Individuo> populacao) throws Listagem 10. Código dos métodos getMelhorIndividuo() e setMelhorIndividuo().
IOException {
public Individuo getMelhorIndividuo() {
int tamanhoPop = populacao.size();
return melhorIndividuo;
String cidade;
}
String[] indString;

Individuo indi;
public void setMelhorIndividuo(Individuo ind) {
Random indRandom = new Random();
if (getMelhorIndividuo().getAptidao() == 0
int ri, rc1, rc2;
|| getMelhorIndividuo().getAptidao() > ind.getAptidao()) {
if(tamanhoPop == 1){
Individuo melhorInd = new Individuo();
taxaMutacao = 1;
melhorInd.setCromossomo(ind.getCromossomo());
}
melhorInd.setAptidao(ind.getAptidao());

this.melhorIndividuo = melhorInd;
for (int i = 0; i < tamanhoPop * taxaMutacao; i++) {
}
}
ri = indRandom.nextInt(tamanhoPop);
indi = populacao.get(ri);
Listagem 11. Código dos métodos getTaxaMutacao() e setTaxaMutacao().
indString = indi.getIndArray();
rc1 = indRandom.nextInt(tamanhoIndividuo); public double getTaxaMutacao(){
rc2 = indRandom.nextInt(tamanhoIndividuo); return this.taxaMutacao;
cidade = indString[rc1]; }
indString[rc1] = indString[rc2];
indString[rc2] = cidade; public void setTaxaMutacao(double taxa){
indi.setIndArray(indString); this.taxaMutacao = taxa;
}
populacao.set(ri, indi);
}
return populacao;
} Classe principal da aplicação: CaixeiroViajante
A classe que é considerada a principal da aplicação chama-se
Em seguida, com um subconjunto da população (gerado a partir CaixeiroViajante e é apresentada na Listagem 12. Ela representa
da taxaMutacao), um indivíduo é escolhido aleatoriamente (vari- a aplicação propriamente dita, isto é, é a classe que tem o papel
ável indi, na posição ri da lista). Desse indivíduo são selecionadas de executar o MapReduce. Para isso, a partir do método estático
duas cidades, cujas posições na cadeia que formam o indivíduo main(), toda a configuração para o controle da execução das tare-
também são escolhidas de forma aleatória (e atribuídas nas variá- fas é declarada. Por exemplo, as definições das pastas dos dados
veis rc1 e rc2). Em seguida, estas cidades são permutadas entre si. de entrada e saída são informadas às classes FileInputFormat e
O resultado desse processo é a substituição do indivíduo original FileOutputFormat. Também são informadas quais classes execu-
da população pelo “mutante” (indi) via instrução populacao tarão as funções map e reduce, o que é feito via o objeto job e as
.set(ri, indi). Ao final de sua execução, o método mutacao() retorna chamadas aos métodos setMapperClass() e setReducerClass().
uma população com alguns indivíduos modificados. Além disso, são declarados os tipos de dados dos pares chave/
O método setMelhorIndividuo() cumpre o papel da operação valor de entrada e saída, obrigatórios nas classes que represen-
genética de elitismo. Seu código (visto na Listagem 10) realiza tam as funções map e reduce. No final do método main(), há

ainda o monitoramento do progresso de execução e finalização seguinte sequência de pontos: “ABCDEFGHIJKLMNOPQRST”,
da aplicação MapReduce, o que é realizado pelo método job que gera uma distância (melhor aptidão) próxima de 51,187 (ca-
.waitForCompletion(). minho ótimo, menor distância). Apesar desse caminho iniciar em
“A”, o resultado da melhor aptidão vale também para qualquer
Listagem 12. Código da classe CaixeiroViajante. outro ponto que respeite a sequência alfabética, por exemplo:
“BCDEFGHIJKLMNOPQRSTA”.
public class CaixeiroViajante {
public static void main(String[] args) throws Exception {

if (args.length != 2) {
args = new String[2];
args[0] = System.getProperty(“user.dir”) + “/Input”;
args[1] = System.getProperty(“user.dir”) + “/Output”;
}
Job job = new Job();
job.setJarByClass(CaixeiroViajante.class);
job.setJobName(“Problema do Caixeiro Viajante”);
FileInputFormat.addInputPath(job, new Path(args[0]));
FileOutputFormat.setOutputPath(job, new Path(args[1]));
job.setMapperClass(CaixeiroViajanteMapper.class);
job.setReducerClass(CaixeiroViajanteReducer.class);
job.setMapOutputKeyClass(IntWritable.class);
job.setMapOutputValueClass(Individuo.class);
job.setOutputKeyClass(DoubleWritable.class);
job.setOutputValueClass(Text.class); Figura 9. Coordenadas relativas das cidades aplicadas no teste e o mapa no plano euclidiano
System.exit(job.waitForCompletion(true) ? 0 : 1);
} Para realizar os testes, foram usadas cinco bases de dados de
}
entrada, representando cinco escalas de população: a primeira
contendo mil linhas de indivíduos e as outras com 10, 20, 30 e 40
mil indivíduos. A expectativa é demonstrar o efeito do número
Teste da aplicação MapReduce no Eclipse menor ou maior de indivíduos na população inicial (base de
Para testar a aplicação foi utilizada uma configuração com vinte entrada) nos resultados gerados pelo AG. Após executar a apli-
cidades, que combinadas geram um espaço de busca maior que 60 cação para cada conjunto de dados de entrada, algumas dezenas
quatrilhões de possibilidades de caminhos. Tal cenário permite de indivíduos foram gerados na saída, da qual apenas o melhor
validar a aplicação em uma situação de maior complexidade, exi- indivíduo, para cada cenário do conjunto de entrada, corresponde
gindo um número elevado de indivíduos na população inicial. à melhor resposta processada pelo AG, aproximando-se do valor
A aplicação foi executada em um só computador, no modo local da solução ótima.
(standalone mode) do Hadoop, que é o mais indicado para o desen- O resultado obtido com as cinco populações iniciais é apre-
volvimento de aplicações MapReduce, porém não fornece todo o sentado no gráfico da Figura 10. Percebe-se no gráfico que
poder de processamento paralelo presente no modo distribuído uma população inicial com uma quantidade maior de indiví-
em uma rede de computadores. Portanto, a avaliação da aplicação duos gera as melhores soluções, que no exemplo representa o
está focada apenas na capacidade de resolver o problema usando indivíduo com menor tamanho de caminho (cuja aptidão é a
a modelagem MapReduce, não considerando os aspectos de de- distância próxima de 51). Esta afirmação pode ser observada
sempenho em tempo de resposta ou no poder de processamento pela linha da média gerada e também pela tendência das linhas
paralelo, pois o ambiente em modo local do Hadoop simula o do melhor e pior indivíduo gerados. Se aumentássemos ainda
paralelismo em uma única máquina. mais o número de indivíduos da população de entrada (inicial),
As coordenadas cartesianas das vinte cidades formam grafi- a tendência seria a convergência para valores próximos do
camente uma imagem circular, como é apresentado na Figura 9. melhor caminho, uma característica inerente dos algoritmos
Esse arranjo circular para o caminho entre as cidades foi esco- genéticos.
lhido pelo fato de ser possível reconhecer visualmente o melhor Outra forma de observar o resultado do melhor e o pior indivíduo
caminho, permitindo assim uma análise mais simplificada sobre encontrados pode ser vista na Figura 11. O melhor indivíduo é
os indivíduos (caminhos e aptidões) encontrados pela aplicação. o caminho representado pela sequência “ONMKLJHIGFEDC-
As aptidões (distâncias) geradas pela aplicação podem então ser BATSRQP”, com aptidão aproximada de 59.2897, e o pior indiví-
comparadas com o resultado conhecido pelo caminho circular duo é o caminho “JIHSCFEDBARTQPONKLMG”, com aptidão
indicado na figura. Tal resultado é representado pela ordem da aproximada de 110.0509.

Autor
Cláudio Martins
[email protected]
Mestre em Computação pela Universidade Federal do Rio
Grande do Sul (UFRGS), professor do Instituto Federal do Pará
(IFPA) e analista de sistemas da Companhia de Informática de Belém
(Cinbesa). Trabalha há dez anos com a plataforma Java.
Autor
Figura 10. Resultados obtidos e comparação com o menor caminho (melhor aptidão)
Wesley Louzeiro Mota
Melhor Indivíduo Pior Indivíduo [email protected]
É graduado em Tecnologia em Análise e Desenvolvimento de
Sistemas pelo IFPA, em 2015. Possui experiência em progra-
mação Java desde 2012. Seu trabalho de conclusão de curso abordou
o uso combinado de MapReduce e algoritmo genético na solução do
Problema do Caixeiro Viajante.
Links:
Página oficial do projeto Apache Hadoop.

http://hadoop.apache.org/
Figura 11. Melhor e pior indivíduo encontrados Apostila “Algoritmos Genéticos: uma Introdução”, de Diogo C. Lucas e Luiz O.
Alvares, Inf/UFRGS, 2002.
Para que você possa reproduzir esses testes, as cinco bases de http://www.inf.ufrgs.br/~alvares/INF01048IA/ApostilaAlgoritmosGeneticos.pdf
dados estão disponíveis para download (veja a seção Links). Cada Link reduzido para download do plugin para uso do Hadoop no Eclipse.
base é um arquivo contendo um conjunto de linhas de texto, onde http://bit.ly/1dTezxt
cada linha representa um indivíduo, ou seja, uma sequência não
Link reduzido para download do projeto da aplicação (Eclipse) e os arquivos de
repetida de cidades (letras).
entrada com as populações iniciais.
Há muitos exemplos de casos reais do uso de AGs que podem ser http://bit.ly/1HiOJ4e
adaptados ao MapReduce. Entre eles, podemos citar os sistemas
de classificação de imagens de satélites, utilizados para identificar Livros
áreas florestais, queimadas, etc. Normalmente, aplicações dessa Hadoop: The Definitive Guide - 3rd Edition. Tom White. O’Reilly. 2012.
natureza trabalham com bancos de imagens que manipulam Livro que aborda o Hadoop de forma didática e atualizada em sua atual versão (2.x), apresen-
bilhões de dados em forma de pixels. tando estudos de caso usados para resolver problemas no modelo mapreduce.
Além desse estudo, que mostrou a viabilidade do uso de MapRe- Sistemas inteligentes: fundamentos e aplicações. Solange Oliveira Rezende.
duce no processamento de um algoritmo genético, muitas outras Manole Ltda. 2003.
aplicações podem se beneficiar dessa técnica. Em destaque, apli- Traz os avanços de metodologias e técnicas utilizadas no desenvolvimento de Sistemas
cações que envolvam carga e tratamento de um grande volume de Inteligentes, mostrando os princípios e aplicações práticas das técnicas.
dados, que manipulem fontes com formatos diversificados e não
estruturados, ou necessitem de eficiência de processamento em
larga escala, em situações que a solução tradicional não resolve.

Ajude-nos a manter a qualidade da revista!

Big Data:
PROCESSO MapReduce
SELETIVO 2015 | 2º SEMESTRE na prática
METODISTA
Estudando Sistemas de
Informação na Metodista
eu me sinto desafiado
a desenvolver minha
capacidade dentro
da sala de aula e no
mercado de trabalho.
Com os cursos da área de Exatas e Tecnologia da
Metodista, o Sérgio tem contato com laboratórios
e ferramentas de última geração. Além disso,
desenvolve seu lado profissional por meio de
Projetos de Ação Profissional, simulando na
prática a resolução de problemas reais.
Sérgio
Aluno de Sistemas de Informação
CONHEÇA OS CURSOS DA ÁREA DE EXATAS E TECNOLOGIA DA METODISTA:
• Análise e Desenvolvimento de • Engenharia Ambiental e Sanitária (Presencial) • Gestão da Tecnologia da Informação (Presencial)
Sistemas (Presencial e EAD) • Engenharia de Produção (Presencial) • Sistemas de Informação (Presencial)
• Automação Industrial (Presencial)
Transforme sua vida. Transforme a realidade.

CREDENCIADA
PELO
MEC
DESDE 2005
Portaria MEC
processoseletivo.metodista.br
244, 31/05/13
EDUCAÇÃO A
DISTÂNCIA
INOVAÇÃO DESDE 1938

QUALIDADE | INOVAÇÃO | DESENVOLVIMENTO REGIONAL | INTERNACIONALIZAÇÃO
76 Java Magazine
Grande • Edição
São Paulo: 140 5000 | Outras localidades: 0800 889 2222 | facebook.com/universidade.metodista | twitter.com/metodista
11 4366

Java-Magazine 140 Zoovzveb

Enviado por

Direitos autorais:

Formatos disponíveis

Java-Magazine 140 Zoovzveb

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Java-Magazine 140 Zoovzveb

Enviado por

Direitos autorais:

Formatos disponíveis

Assine agora e tenha acesso a

todo o conteúdo da DevMedia:

Edição 140 • 2015 • ISSN 1676-8361

Atendimento ao leitor Fale com o Editor!

06 – Criando uma aplicação corporativa em Java – Parte 4

16 – Dominando o Java Collections Framework e Generics

Conteúdo sobre Boas Práticas, Artigo no estilo Mentoring

26 – Refatoração utilizando padrões de projeto e boas práticas

Conteúdo sobre Boas Práticas

Conteúdo sobre Boas Práticas

Este artigo faz parte de um curso Fique por dentro

6 Java Magazine • Edição 140

Para que sejam listados todos os leitores, também usamos as

Listagem 2. Código do managed bean LeitorBean.

Figura 1. Conteúdo da página emprestimo.xhtml package br.com.javamagazine.mb;

Edição 140 • Java Magazine 7

API provê uma interface fluente que possibilita o encadeamento @Named

8 Java Magazine • Edição 140

Listagem 4. Código da página devolucao.xhtml.

<?xml version=”1.0” encoding=”ISO-8859-1” ?> <h:inputText id=”emprestadoPara” value=”#{devolucaoBean.emprestimo

Edição 140 • Java Magazine 9

10 Java Magazine • Edição 140

Edição 140 • Java Magazine 11

12 Java Magazine • Edição 140

Listagem 14. Código do PhaseListener Autorizador.

package br.com.javamagazine.listeners; if(“/funcionario_biblioteca.xhtml”.equals(context.getViewRoot().

Edição 140 • Java Magazine 13

A outra situação ocorre se o usuário ainda não estiver auten- Autor

Endereço para download do driver do MySQL.

14 Java Magazine • Edição 140

É Fique por dentro

16 Java Magazine • Edição 140

A interface Map 01 public static void testHashTable() {

é refletido nas suas operações de coleções, a saber: keySet(), que

Edição 140 • Java Magazine 17

Listagem 2. Exemplos para distinção entre as palavras sorted e ordered.

01 public static void testList() { 30 System.out.println();

18 Java Magazine • Edição 140

Edição 140 • Java Magazine 19

20 Java Magazine • Edição 140

Edição 140 • Java Magazine 21

Esta ordem criada na classe Student, através da implementação

22 Java Magazine • Edição 140

Este é um simples exemplo do problema que podemos evitar

inserimos primeiro um valor numérico e, em seguida, uma -- Erro:

Edição 140 • Java Magazine 23

24 Java Magazine • Edição 140

Edição 140 • Java Magazine 25

Este artigo é do tipo mentoring Cenário

26 Java Magazine • Edição 140

Edição 140 • Java Magazine 27

Métodos curtos Entendendo o problema

28 Java Magazine • Edição 140

Edição 140 • Java Magazine 29

Aplicando o padrão Strategy na refatoração

30 Java Magazine • Edição 140

Listagem 7. Classe que representa um carro de passeio.

Edição 140 • Java Magazine 31

Figura 3. Diagrama de classes utilizando Template Method na refatoração