Categoria: Java

Mock com Mockito

Olá Pessoal,

Hoje vou apresentar o Mockito que é uma API de Mock, que tem ganhando espaço a cada dia. No post, vou falar pra que serve aos Mocks, o que evitamos e farei “reutilização da informação” sobre o que são mocks.  E para deixar tudo claro nada melhor que um exemplo feijão com arroz,  para que você possa entender como usar.  No próximo post veremos na pratica a criação de Mocks com Mockito.

Lets go…

Pra que serve o mockito?

Mockito  é uma API desenvolvida pela Google, com o objetivo de simular um objeto real para uma classe especifica. Isso pode ajudar nos testes de unidade quando precisamos verificar  a comunicação entre os objetos.

Por que usar Mock?

Usamos Mock quando temos classes que possuem dependencias, porém queremos testar apenas se uma classe está  retornando o que estamos esperando.

E o que evitamos usando mock?

Evitamos de ter que criar objetos para todas as dependencias de uma classe. Ou seja, com o mockito vamos “enganar” a execução do programa, dizendo pra ele que o objeto a ser passado é de fato o objeto que ele espera.

Na pratica

Antes de apresentar os códigos, vamos precisar pegar o conceito do “negócio” e saber como os códigos trabalham.

O cenário é o seguinte:

  • Class Cliente : um cliente ele possui alguns atributos como id, nome.
  • Classe CarroAlugado: esta classe tem como objetivo de informar/representar qual carro está alugado e para quem está alugado (cliente).  Então aqui já podemos ver que essa classe depende de um objeto da classe Cliente. Pois, um objeto da classe cliente que terá essas informações.
  • Interface AlugarCarro: temos uma interface que aluga carro, como o procedimento de alugar carro é sempre o mesmo, de ter o nome de quem está alugando  + o carro que foi alugado. Então se um cliente quiser alugar um carro terá que assinar um contrato com essa interface e informar pra ela o nome dele e o carro que deseja alugar.

E onde Mocks entram nessa história?

Mocs vão  entrar no momento que vamos simular que um cliente  c “Zezinhi” alugou um carro “Ferrari” e vamos ver se de fato  a classe tem essa reserva feita.

Os códigos a seguir:

public interface AlugaCarro {

      public void setNomeCliente(String nomeCliente);

      public void setModeloCarro(String nomeCarro);

      public String getNomeCliente();

      public String getModeloCarro();

}

Classe Cliente implementando a Interface, pois um cliente está querendo alugar um carro.

public class Cliente implements AlugaCarro {

      private String nomeCliente;

      private String modeloCarro;

      @Override

      public void setNomeCliente(String nomeCliente) {

            this.nomeCliente = nomeCliente;

      }

      @Override

      public void setModeloCarro(String nomeCarro) {

            modeloCarro = nomeCarro;

      }

      @Override

      public String getNomeCliente() {

            // TODO Auto-generated method stub

            return nomeCliente;

      }

      @Override

      public String getModeloCarro() {

            // TODO Auto-generated method stub

            return modeloCarro;

      }

}

A classe CarroAlugado  quer receber um objeto que foi instanciado contendo nome do cliente e o nome do carro alugado, e retornar esse objeto. Que nada mais é o Cliente que alugou o carro. Lembre-se o Cliente implements AlugaCarro, então temos o relacionamento HAS-A.  

public class CarroAlugado {        

      private AlugaCarro alugaCarro;

     public CarroAlugado(AlugaCarro alugaCarro) {

            this.alugaCarro = alugaCarro;

      }

      public AlugaCarro getAlugaCarro() {

            return alugaCarro;      }

      public void setAlugaCarro(AlugaCarro alugaCarro) {

            this.alugaCarro = alugaCarro;

      }    

}

Na edição 49 da revista MundoJ tem um artigo que escrevi junto com o Alexandre Gazola sobre o assunto. E lá detalhamos mais, eu sou suspeito de recomendar essa edição :).
vou ficando por aqui, espero que tenham gostado do post.

abracos, see ya!!

Lançamento Oficial do Livro JEE com Frameworks

Comprar

ae Pessoal,

Hoje é mais um dia feliz na minha vida, e primeiramente quero agradecer à todos vocês, pela força, atenção, feedbacks que venho recebendo nesses 3 anos de blog e sem eles, acho que não estaria aqui hj fazendo este post e publicando mais este projeto. Pois, meu segundo filhão nasceu, huhuhu \o/. Lindo igual ao pai, por consequencia do destino hehe. Uma das novidades é que além do formato impresso, temos a versão e-book. A seguir fiz um overview,há um post detalhado de  pré-lançamento aqui.

Lets go…

Note: Infelizmente, tivemos um problema na linha de produção da gráfica e atrasou a publicação que estava prevista para meados de julho/2011.

Agradecimento

Antes de tudo, preciso agradecer ao melhor amigo o Edson Gonçalves. Amigo este de longas datas, o qual eu tenho grande admiração e respeito. É um dos profissionais mais completos de TI que já pude conhecer, o cara tem um conhecimento cross que é uma coisa de louco(não se limita só a parte técnica). Fora amizade que temos, onde às vezes pego o caminho errado, o verdadeiro amigo aparece e ti fala:”Falei que poderia contar comigo, o caminho  é aquele vai em frente”. Esse é o Edson um amigo de verdade.

Outra pessoa que não posso deixar de agradecer é o Daniel de Oliveria (leader-DFJUG) de uma das maiores e respeitável comunidade de Java que temos no Brasil, estou falando do DFJUG. E não poderia deixar de dar minha contribuição (para quem não sabe eu vim da comunidade Java, foi onde tudo começou e hoje retribuir o que recebi é o minimo que posso fazer), adicionado a marca  na capa do livro. Obrigado Daniel pelo seu apoio e da comunidade :).

Overview

O livro tem como objetivo de ajudar aqueles profissionais que desejam aprender Java com Frameworks. É comum ao sairmos do “ABC do JEE” (normalmente é JSP/Servlet) sem saber qual framework estudar (Hibernate, JSF, Spring, “Struts”, VRaptor etc). Porém, há um problema que todo iniciante encontra: como aprender os frameworks e saber integrá-los em uma aplicação real? É isso que vamos ver no livro, aprender a usar os frameworks de forma prática e ver um pouco da teoria(se não gosta de teoria não se preocupe, pois veremos o suficiente para poder programar de maneira confortável). Os exemplos são variados, desde Java Application até JEE, a evolução de aprendizado no livro está no formato “baby-step” ajudando assim o leitor leigo no assunto. Uma novidade que alguns vão gostar e outros não, são os exercícios chamados de “Trabalho do dia” que tem como objetivo fazer o leitor desenvolver uma solução, porém há momentos que o leitor vai precisar fazer uma pesquisa na documentação da API, Google ou consultar outros capítulos.Porém, não avisamos isso no livro, então  o leitor terá que ter essa percepção. O motivo de ter adotado isso aos exercícios, transmitir um pouco do que vai encontrar no dia-dia como desenvolvedor in company, pois nem sempre teremos um colega do lado para dar o help que precisamos.

Público-Alvo

Programadores Java que tem como objetivo aprender de forma pratica o uso dos frameworks JEE mais requisitado no mercado.

Qual o diferencial?

Meus livros são diferentes, primeiramente pela escrita. Eu gosto muito da informalidade, de ser direto e tentar transmitir a informação da melhor maneira possível, como se eu tivesse ao lado do leitor. Nesse livro há vários diferenciais, um deles é o nosso laboratório on-line onde o leitor poderá fazer download do source, assistir uns vídeos de como colocar aplicação em um servidor de produção JEE(apoio da www.integrator.com.br), exercícios práticos etc.

Quando ler?

Assim, que terminar seus estudos, com Servlet & JSP, vc pode ler, do contrário, não faça o investimento agora e aguarde mais um pouquinho( coloque o livro na prateleira ou remova do seu carrinho de compras : ) ).

Requisitos

É preciso já ter uma certa experiência com Java, Banco de dados, saber como as aplicações JEE funcionam etc. Como o livro é focado em ensinar a usar de forma pratica os frameworks, não podemos perder tempo com toda teoria de JEE, então vamos direto ao assunto.Particularmente não gosto de livros grandes, eles ficam mais caros e o que eu quero é um preço acessível para todos, enfim até os que recebem mesada podem comprar (pelo menos a minha na época que tinha, os livros eram caros demais rs).

Desconto

Se quiser comprar o exemplar com 30% de desconto no site da Editora, basta usar o código a seguir durante a compra: V00014 e se cadastrar como associado.

Concorra Sorteio será 21/08/2011

Faça um RT da mensagem abaixo e sua inscrição, assim terá a chance de receber um exemplar na sua casa autografado(se preferir). Para sorteio usaremos o random.org e o número sorteado será o ganhador e a verificação do RT  Lembrando que para aqueles que fizeram mais de um cadastro com o mesmo e-mail, não estará concorrendo ao exemplar.

Lançamento do Livro Guia JEE c/ frameworks @RT: @camilolope #JEE #frameworks.Confira:

Lançamento Oficial do Livro JEE com Frameworks

Após, o resultado entrarei em contato pelo e-mail cadastrado e o ganhador tem até 48 hrs para responder, após o envio  do e-mail.Do contrário um novo sorteio será realizado, e o ganhador anterior acabou de perder a chance de receber o livro. : )

Fazer inscrição

Você pode deixar de ganhar se não fizer isso:

  • cadastrar e não fazer o RT;

  • fazer o RT e não se cadastrar;

A qtde de RT fica por sua conta, se quiser fazer mais de RT, ficarei feliz :).

Versão do Livro

  • Paper – R$ 47,20
  • E-book  – R$ 35,40

Eu quero comprar o meu

Onde comprar?

  • Site da Editora
  • Saraiva
  • Cultura
  • Fnac
  • Americanas.com
  • Submarino
  • e outras que eu não lembro rs

Download

Conseguir com a editora amostra de algumas páginas do livro, confiram aqui

Vou ficando por aqui e espero que tenham gostado do post.

Abracos see ya!!

Cobertura Unit Test com Eclemma

olá Pessoal,

Neste post vou falar de um plugin que temos para o Eclipse que permite saber quantos % de nossos testes de fato estão cobertos. É comum pensarmos que 100% dos nossos testes unitarios estao 100% cobertos apenas pq todos os testes passam. Quem aqui quando começou com test units não pensou nisso (eu confesso que achava isso). E neste post eu pretendo apresentar uma ferramenta que permite descobrir e dar um resultado no formato de relatório o quanto o seu code está coberto.

Lets go…

Iniciando

O plugin que vamos usar é chamado de Eclemma, ele pode ser baixado ou instalado via update no Eclipse. No site do fabricante há todas informações sobre o plugin, alguns tutoriais básicos e com imagens ilustrativas. Enfim, não tem erro para começar a usar.

Após, a instalação do plugin e o restart do Eclipse a única diferença que vc vai perceber na sua IDE é que teremos um novo botão para rodar os testes com Coverage, ou seja, “execute o testes com o plugin para eu ter relatorio da cobertura” seria algo mais ou menos assim que o botão abaixo faz.

 

Algumas Características:

  • permite exportar em html os relatorios;
  • suporte Junit 4
  • suporte ao ant, ou seja, vc pode gerar os relatórios a partir do ant
  • Baixa curva de aprendizado.

 

Antes de ir para o tópico a seguir certifique-se que já o plugin está instalado.

Praticando

Não irei abordar todos os recurso do plugin até pq nao tem tanta coisa assim, só ficar brincando um pouco com a ferramenta que alguns minutos dar para saber tudo que ela faz. Porém, para o post reservei um exemplo muito simples, onde o objetivo é mostrar como de fato a ferramenta trabalha e vai ti ajudar no aumento de cobertura dos seus testes unitarios. Criei um projeto que calcula a “Multa Mora” para alguma coisa.Isso pouco importa a questão é que essa classe recebe valores e através de um calculo financeiro terá que retorna um valor da multa a ser paga. O objetivo aqui não é ser um post para area de finanças, então deixaremos isso de lado, mas para vc saber criar bons testes precisa entender do negócio e calcular um juros simples é algo que bem do dia-dia. A seguir temos a nosso Java Project e o código da classe com seu devido calculo.

Classe MultaMora

publicclass MultaMora {

private BigDecimal taxaDia = new BigDecimal(0.33);

private BigDecimal taxaMaxima = new BigDecimal(20.00);

public MultaMora() {

// TODO Auto-generated constructor stub

}

public BigDecimal verificaAtraso(String dataVencimento, String dataPagamento,

BigDecimal valor) throws ParseException {

DateFormat df = new SimpleDateFormat(“dd/MM/yyy”);

Date dateVenc = df.parse(dataVencimento);

Date datePagto = df.parse(dataPagamento);

Calendar calendarVenci = Calendar.getInstance();

calendarVenci.setTime(dateVenc);

Calendar calendarPagto = Calendar.getInstance();

calendarPagto.setTime(datePagto);

long diferencaData = calendarPagto.getTimeInMillis()- calendarVenci.getTimeInMillis();

int umDia = 1000 * 60 * 60 * 24;

long diasDiferenca = diferencaData / umDia;

BigDecimal novoValor = calculaMulta(diasDiferenca,valor);

return novoValor;

// return diasDiferenca;

}

public BigDecimal calculaMulta(long diasAtrasado, BigDecimal valor) {

BigDecimal totalTaxa = taxaDia.multiply(new BigDecimal(diasAtrasado));

BigDecimal divisor = new BigDecimal(100);

double ttaxa = totalTaxa.doubleValue();

double ttaxamax = taxaMaxima.doubleValue();

if (ttaxa<=ttaxamax) {

return valor;

} else {

BigDecimal valorMulti= valor.multiply(taxaMaxima);

valorMulti = valorMulti.divide(divisor);

valor = valorMulti.add(valor);

return valor;

}}}

Vamos ao que interessa que é criar a classe que fará os testes e em seguida veremos quantos % de nossa classe é coberta, para isso criamos os seguites testes, o qual vai está passando.

publicclass MultaMoraTeste {

@Test

publicvoid testPeriodoValidoMes() throws ParseException {

assertEquals(new BigDecimal(120), new MultaMora().verificaAtraso(

“10/11/2010″, “20/01/2011″, new BigDecimal(100)));}

@Test

publicvoid testCalculaValor(){

//TODO

}}

Testes Passando

Vimos que os testes estão passando tranquilamente. Nada de errado, pois esperamos que eles uma hora ficasse verde. Não vamos discutir aqui o ciclo de TDD.

Agora veremos quantos % nossa aplicação está coberta pelos testes. Então precisamos rodar os testes agora usando o plugin Eclemma e para isso temos que rodar conforme a imagem a seguir:

Ao executar observe os tests units foram executados e logo em seguida temos o relatorio de cobertura.Veja que 98% não é 100% , isso é evidente, mas tem que ficar claro na sua mente que não temos 100% dos testes, e vamos navegar na arvore e ver quem não está coberto segundo a ferramenta. Mas, antes disso observe que temos quatro colunas, sendo de fácil interpretação. A primeira fala o % coberto, a segunda as instruções cobertas, a proxima instruções não cobertas e a ultima o total de instruções.Podemos ver que o método calculaMulta não está 100, mas onde não está 100%? o que está faltando? Para ver isso basta dar dois cliques em cima do método na aba Coverage, que veremos o resultado a seguir:

Observe que temos no nosso code, linhas verdes e uma vermelha, a verde significa que aquela linha está coberta pelo teste, a vermelha como sempre é um problema que precisamos resolver, ou seja, linha não está cobert. Em outras palavras não temos nenhum teste que valide aquele valor. Então vamos resolver o problema. Para isso, vamos adicionar o seguinte teste na classe de Test que criamos.

@Test

publicvoid testCalculaValor(){

BigDecimal testValor = new MultaMora().calculaMulta(1, new BigDecimal(3));

assertEquals(new BigDecimal(3),testValor);

}

Observe que agora estamos verificando aquela valor que é return ele de fato nao tinha sido testado, então criamos esse teste somente para verificar aquela parte e saber se ele vai retornar de fato o que esperamos. Rode os testes com cobertura novamente e veja agora o resultado.

Agora temos 100% de cobertura em nosso código, observe que coisa mais linda de ser vista. Porém, isso aqui foi com um exemplo muito simples com o objetivo de mostrar a vc leitor como saber quantos % de seu code está coberto. Para praticar vc pode pegar projetos antigos seus e tentar cobrir alguns cenários. Não posso deixar de falar que 100% de cobertura não significa que seu code é o melhor do mundo, o mais interessante são os testes que vc possui, sempre que for escrever seus unit tests pense, o quanto esses são eficientes. O percentual de cobertura vira consequência qto mais eficiente for seu teste.

Enfim, espero que tenham gostado do post!!
abracos,

see ya! Next post.

Configurando Log4J em seus projetos Java

olá Pessoal,

Quem aqui nunca teve vontade de adicionar o LOG4J ao seu projeto Java e teve dificuldades na primeira vez ?( levanta a mão o/) Apesar de ser um frameworks bem simples, para controle de log, é comum, para quem estava acostumado usar o System.out.println() ficar um pouco perdido, o objetivo deste post é apresentar como configurar o LOG4J e explicar dentro do code, como as coisas acontecem.

Lets go..

Introdução

O uso de uma API de LOG, é extremamente importante tanto durante o desenvolvimento, quanto já temos aplicação em produção. Pois, mais cedo ou mais tarde vamos precisar analisar o LOG por algum motivo. Situações comum que precisamos de um LOG:

  • sua aplicação conecta à banco de dados e este está down, com certeza verá communication link failure como exceção e uma connection refused. Para que tudo isso não apareça na tela do usuário, mandamos para um arquivo de log e lá vamos investigar quando e que dia aquilo aconteceu;
  • Sua aplicação vai ler um arquivo que é criado a partir de outra aplicação, se não encontrar o tal do arquivo teremos uma exceção e mandaremos ela para o arquivo de log. E daí vamos saber o dia, o horário que a outra aplicação parou de gerar aquele tal arquivo e daí iniciar uma investigação;

Claro que há vários contextos do uso de LOG, os citados acima, foi apenas uma das situações mais tradicionais.

Entendendo o Log4J

Para entender o framework, é preciso saber apenas três aspectos: Logger, Appender,Layout.

Logger: é o cara que recebe as solicitações de log. Podemos criar um logger para cada classe da aplicação, porém o framework já fornece uma padrão caso não seja informado nenhum.Appender: os Loggers eles precisam saber para quem enviar as informações que recebeu, e ai os Appenders faz o trabalho dele, dizendo : “Logger, passe as informações que você recebeu para mim, que eu saberei o que fazer com elas”.

Com o appender podemos decidir, salvar as informações de Logger em um arquivo, imprimir no console, enviar via e-mail etc.

Layout: precisamos definir o formato que estas informações serão armazenadas para isso precisamos de layout. Podemos, organizar em um formato HTML, Simple text etc. Com o layout podemos definir data e hora, linha onde o log foi gerado etc.

Níveis de Logger

Todo logger possui um dos 5 niveis disponíveis, DEBUG,INFO,WARN,ERROR e FATAL. Por default  DEBUG é configurado por padrão pelo framework, caso você não defina nenhum.

Os níveis vão ajudar para saber que tipo de informação deseja gravar no seu LOG, por exemplo: você define que apenas os erros igual ou maior que WARN serão salvo no seu arquivo LOG. Isso é importante, pois às vezes não importa ter DEBUG,INFO em seu arquivo de LOG quando está em produção. Para o team de QA apenas interessa a partir de INFO, por exemplo. Mas, você pode criar dois arquivos de LOG, um para DEV e lá você põe todas as info desde DEBUG e para o log que vai junto com aplicação a partir de INFO. O framework permite esta flexibilidade de mandarmos diferentes níveis para arquivos diferentes.

A ordem: DEBUG < INFO < WARN < ERROR < FATAL.

Leitura simples: se você configura para WARN, somente será enviado mensagem igual ou acima de WARN. Quem é maior que WARN? (ERROR)

Step 1

Fazer download do JAR log4j.jar

http://logging.apache.org/log4j/1.2/download.html

Step 2

Adicionar ao projeto Java (ou crie um projeto Java)

O nosso projeto Java, vai salvar um dado no banco via Hibernate. Pois, iremos simular um erro e ver se este dado consta no arquivo de log.

Step 3 – configuração

A configuração de um arquivo do LOG4J pode ser feita de forma programaticamente ou através de um arquivo de properties. Vamos mostrar aqui ambos, primeiro veremos a configuração do arquivo de properties, onde os comentários já possuem as devidas explicações:

#### Usando 2 appenders, 1 para logar no console, outro para um arquivo

log4j.rootCategory=WARN,stdout,fileOut

# Imprime somente mensagens com ‘priority’ WARN ou mais alto para o logger

#lembrando a ordem: DEBUG – INFO – WARN – ERROR – FATAL

log4j.category.lopes=INFO

#### O primeiro appender escreve no console

log4j.appender.stdout=org.apache.log4j.ConsoleAppender

log4j.appender.stdout.layout=org.apache.log4j.PatternLayout

### Pattern que mostra o nome do arquivo e numero da linha, porem sem data e hora

log4j.appender.stdout.layout.ConversionPattern=%5p [%t] (%F:%L) – %m%n

#### O segundo appender escreve em um arquivo e faz um bkp ao atingir o max

log4j.appender.fileOut =org.apache.log4j.RollingFileAppender

log4j.appender.fileOut.File=camilolog.log

### Controla o tamanho maximo do arquivo

log4j.appender.fileOut.MaxFileSize=100KB

### Faz backup dos arquivos de log (apenas 1)

log4j.appender.fileOut.MaxBackupIndex=1

log4j.appender.fileOut.layout=org.apache.log4j.PatternLayout

#####este formato esta em ingles: 2011-04-24 e imprime o nro da linha L

log4j.appender.fileOut.layout.ConversionPattern=%d [%t] %5p %c:%L – %m%n

####imprime no formato dia/mes/ano

#log4j.appender.fileOut.layout.ConversionPattern=%-2d{dd/MM/yy HH:mm} [%t] %5p %c:%L – %m%n

O interessante nesta configuração é a linha :log4j.category.lopes=INFO

Onde criei meu LOGGER e disse que ele teria o nível INFO, mas agora preciso dizer em que classe este logger será utilizado. Vamos usar a classe que tem o main.

public static void main(String[] args) {

Logger logger = Logger.getLogger(“lopes”);

logger.info(“iniciando aplicação”);

logger.debug(“debug here”);

Usuario usuario = new Usuario();

usuario.setNome(“camilo”);

usuario.setEmail(“log4j”);

UsuarioDao usuarioDao = new UsuarioDao();

usuarioDao.save(usuario);

logger.info(“usuario salvo no banco com sucesso”);

Observe o nome que passei para o método getLogger(), o mesmo que definimos no arquivo properties, assim ele vai saber o nível a ser configurado, nesse caso foi INFO, então nada de debug é gravado no arquivo.

Note: habilitei o Hibernate para imprimir a instrução SQL, via Log4j

#configurando o hibernate no log4j

log4j.category.org.hibernate.SQL=DEBUG

Detalhes: http://docs.jboss.org/hibernate/core/3.6/reference/en-US/html/session-configuration.html#configuration-logging

Na imagem abaixo temos o resultado do console:


Aqui temos o console e o que foi gravado no arquivo de log (camilolog.log)


Vamos provocar uma exceção, e deixar o banco de dados (no meu caso MySQL) down. Para isso bastar dar um stop, em seu banco.


E dai conseguimos ver o erro de conexão no arquivo de LOG.

Claro que não vamos fazer isso para 100 classes que tivemos em um projeto, apenas para aquelas que precisam receber um tratamento diferenciado, que é preciso ir para o LOG, as demais ficam com o nível default definido no rootCategory.

Nomeação do logger

Não sei perceberam, mas há uma desvantagem em criarmos qualquer nome para o logger, como “lopes”, pois o resultado é:

2011-04-24 21:45:17,578 [main] INFO lopes:16 – iniciando aplicação

quem é lopes? O melhor é colocar o path da classe, assim:

log4j.category.br.com.camilolopes.dao=INFO

E precisamos mudar nossa variavel logger, passando apenas a classe:

Logger logger = Logger.getLogger(DAO.class);

Ao executar temos o seguinte resultado:


Observe que agora salvamos de onde vem INFO, pois temos a classe e a linha, para isso alteramos o ConvertionPattern, que grava no arquivo:

log4j.appender.fileOut.layout.ConversionPattern=%d [%t] %5p %F:%L – %m%n

Trocamos o %c por %F. Dar uma olhada na documentação tem muita coisa bacana:

http://logging.apache.org/log4j/1.2/apidocs/org/apache/log4j/PatternLayout.html

O resultado:


Não esqueça de dar um refresh, em seu projeto, para que o arquivo de LOG apareça, um atalho é selecionar o projeto e apertar F5.

Vou ficando por aqui e espero que tenham gostado do post.

abraços, see ya!!

Criando JAR com MySQL,Hibernate e Quartz

olá pessoal,

O post de hoje é algo bem iniciante, mas ainda muito usado quando estamos trabalhando com protipo de algo e precisamos apenas validar se uma solução vai funcionar de fato. Ou seja, quando estamos na ponta do iceberg. Então hoje, vou mostrar como criar um arquivo JAR pelo Eclipse, mas não será um arquivo JAR qualquer com um “Hello World” apenas, este terá que connectar à um banco de dados MySQL e ainda o Quartz. Então somente neste contexto temo três APIs externas no aplicativo, pois o Hibernate fará o terceiro.

Lets go…

Alguns requisitos:

  • ter o hibernate configurado, dúvidas consulte outros posts do Hibernate aqui.
  • ter todas as libs no projeto
  • antes de criar o JAR, certifique-se que tudo funciona no modo de DEV(hibernate, conexão com banco etc. Rode e check os resultados inúmeras vezes;
  • tenha o MySQL 5/superior instalado;

Starting…

Vamos dizer que você precise mostrar a funcionalidade de algo da maneira mais simples possível, e quem for ver está mais preocupado na funcionalidade do que em layout, performance (por enquanto). Como trabalho com pesquisa e desenvolvimento tenho passado por isso com bastante frequência, uma vez que no inicio de algo estamos no prototipo para uma possível nova feature, solução, seja o que for, mas não é legal no inicio gastar muita energia, com performance, layout, ou qualquer caracteristica que não agrega valor na funcionalidade. Caso a ideia não seja válida, o resultado será que gastei menos energia e tempo. E já foi possível descartar.

Situação

Um dia desses tive que apresentar uma solução para uma feature do projeto que, nem sabiamos se ia dar certo e como seria os impactos. Daí começamos com as investigações e pesquisa necessária, e quando fomos apresentar para os arquitetos, o team de Q.A etc. Foi algo bem produtivo porque geramos um JAR com o banco HSQLDB, distribuimos esse JAR e eles só executaram e viram o resultado desejado (não posso dar maiores detalhes). Já pensou se fosse necessário ter que montar todo o ambiente de DEV na maquina de quem fosse validar a solução? Exemplo: de ter que instalar um banco real, configurar os acessos etc. Bem, nada produtivo né?

HSQLDB: é um banco em Java que não passa de JAR e que por sinal é bem completinho, porém com suas limitações e não queira comparar ele com MySQL, SQL Server, Oracle etc . Basta adicionar o .jar ao seu projeto e terá o HSQLDB disponível para receber os dados. Claro que terá que informar ao hibernate.cfg.xml sobre isso. Qualquer dúvida, basta dar uma “googlada” que encontrará vários posts a respeito de como usar o HSQLDB. A documentação também ajuda: http://hsqldb.org/ http://pt.wikipedia.org/wiki/HSQLDB

 

Note

Aqui vamos usar o MySQL 5 então vou levar em conta que você já tem ele instalado na sua maquina. Também, acredito que já tem o projeto do ultimo post rodando. Mas, caso não tenha use qualquer outro projeto pessoal que tenha acesso à um banco de dados, que use o hibernate, para ficar bem próximo do nosso.

Development

Eu poderia ter ido direto ao ponto e ter feito o post com 3,4,5 linhas, mas sempre gosto de fazer um contexto, para quem está lendo possa ter uma ideia da utilização, principalmente se está vendo o assunto pela primeira vez, é mais importante ainda, pois saber o porque das coisas é tão importante quando saber fazer. Não saia fazendo, por fazer. Sempre se pergunte o por que fazer isso?

  • uma vez com o projeto criado no eclipse, clique com o botão direito e escolha build path → configure build path.
  • agora precisamos informar as libs que serão exportadas

observe que marquei as bibliotecas que preciso. No caso do nosso exemplo são: hibernate, quartz e mysql.

  1. Clique em ok
  2. agora clique com o botão direito no projeto e escolha export
  3. procure pela pasta Java
  4. e escolha Runnable JAR e clique em next

  1. agora precisamos informar o projeto, que no caso será QuartzDBHibernate

  1. indique o local que deseja salvar seu arquivo JAR.
  2. Clique em finish e aguarde terminar (talvez apareça um warning, se quiser clique em details leia e prossiga. Não é nada critico)

Uma vez com JAR gerado, vamos testar a execução. No caso do windows abra o promt de comando e navegue até onde salvou o seu JAR. E digite: java -jar quartzdbHibernate.jar (eu usei o mesmo nome do projeto, você deve informar o nome que deu ao arquivo JAR caso tenha sido diferente).

 

Agora vamos ver o resultado, ahh não esqueça de dar um START no seu MySql do contrário verá exceções na tela.

Observe que foi adicionado o usuario, o sql é printed  pelo hibernate uma vez que configurei no hibernate.cfg.xml para ser impresso. Agora vamos  ao  banco.

Na imagem acima temos o banco atual e veja que o ultimo ID é 60. na imagem a seguir temos o banco atualizado e o ultimo ID é 61:

 

Alguns profissionais “Senior”  crucificaria o Camilo por fazer um post deste tipo, tão ABC.  Mas, como sempre falei : “todo sênior hoje um dia deu hello world, e passou pelas mesmas dificuldades que alguem que está chegando hoje no mundo java está passando, e com certeza  esse senior precisou de ajuda, e pq ignorar de dar essa ajuda hj ?”. O que tenho aprendido nesses 3 anos como blogueiro  foi o seguinte: o mais prazeroso  não é escrever um post “avançadao ou basicao” para querer mostrar que “sabe” algo. E sim saber, o que foi escrito teve um impacto positivo na vida do leitor  independente do nível do post. Até hoje  lembro das noites em claro que passei, para instalar e configurar o Java corretamente no windows, e a dificuldade que tive em fazer isso de forma automatica, sem precisar “googlar” fazer aquele javac funcionar era osso. E quando conseguir, virou meu primeiro post do blog, e foi onde tudo começou. E até tenhoo leitores comentando que o post tem salvado o dia deles.

Vou ficando por aqui e espero que tenham gostado do post.

abracos see you next post!!!