Tag: Java

Throubleshooting MySql Case Sensitive Criteria Hibernate

 

Olá Pessoal,

Mais um thoubletshooting, e dessa vez é com o Mysql. É aquela velha frase “vivendo e aprendendo”. No dia a dia trabalho com outros bancos de dados, mas nos meus projetos house-made gosto do mysql.

Um dia desses estava desenvolvendo e um dos requisitos era considerar o case-sensitive. Dai vou lá feliz da vida usando o Criteria do Hibernate com o MySql:

criteria.add(Restrictions.eq(“email”, email));

criteria.add(Restrictions.eq(“password”, password));

E o que acontece?

Simplesmente se tiver:

camilo@camilolopes.com com o password: 123cam

e

camilo@camilolopes.com com o password: 123CAM

Teremos dois registros no retorno.

Daí fui ver na documentação o motivo e achei isso:

http://dev.mysql.com/doc/refman/5.0/en/case-sensitivity.html

Solução

Como podemos ver na documentação acima, o Mysql trata Varchar como case-insensitive. Daí ao criar a tabela devemos setar a flag Binary. Caso  a tabela já exista, basta dar um alter table

ALTER TABLE `user` MODIFY COLUMN `EMAIL` VARCHAR(255) BINARY CHARACTER SET latin1 COLLATE latin1_bin DEFAULT NULL;

Pronto. E resolvido.

Vou ficando por aqui.

See ya!!!

Throubleshooting Maven não fazendo checkout eclipse

Olá Pessoal,

E lá vamos nós com mais um troubleshoot. Hoje veremos um do maven com eclipse.

O problema

Se você ainda não passou, talvez vai passar por esse problema algum dia ao rodar o comando mvn eclipse:eclipse e ver que o checkout das dependências que você acabou de atualizar não está sendo feito. Iai o que fazer?

A solução

Basta forçarmos isso com o comando:

mvn eclipse:eclipse -DdownloadSources=true

E pronto. Será baixado e seu problema resolvido.

Bobo, né? Mas dá um trabalho até descobrir que só.

Abracos, see ya!

Throubleshooting:Hibernate Maven Javassist

Olá Pessoal,

Mais um post throubleshoot e novamente entre o hibernate e o maven.

Lets go...

O Problema

Ao adicionar o hibernate no pom.xml, se reparar não vem o javassist. Pelo menos até a versão 3.6 ele não veio no pom.xml. Daí, ao rodar a aplicação veremos algumas exceções do HibernateException.

Solução

Basta adicionarmos no pom.xml o javassist conforme abaixo e pronto.

<groupId>javassist</groupId>

                               <artifactId>javassist</artifactId>

                               <version>3.12.1.GA</version>

Em seguida, rode mvn clean e mvn eclipse:eclipse (caso vc use o eclipse)

Pronto, era isso apenas.

Abracos,  see ya!

Pré-Lançamento: Livro TDD na Prática

Olá pessoal,

É com muita felicidade que escrevo este post. Realmente só quem é “pai” sabe o que eu estou sentido. Como vocês já podem imaginar está vindo ai mais um filho para se juntar aos seus irmãos “Guia do exame SCJP” e “Guia Prático JEE”. É ele o “TDD na Prática”. O livro está previsto para ser publicado até o final de junho/2012. Ainda não recebi a versão final do livro, mas assim que receber estarei disponibilizando alguns capítulos. A seguir faço uma pequena apresentação sobre o meu filhão.

lets go…

Sumario Tdd na Prática

Sobre o livro

O livro vem com um objetivo simples: “Descomplicar o que parece ser complicado”, em outras palavras O objetivo é ensinar como praticar TDD usando a linguagem de programação Java. Para muitos iniciantes em TDD, no primeiro momento parece que estamos fazendo tudo errado e que escrever os testes antes do código funcional não é nada legal. E que para superar os primeiros obstáculos, só o conhecimento técnico não é suficiente. Quando comecei com TDD passei por vários obstáculos e um deles foi encontrar livros práticos, ou seja, aqueles que eu pudesse colocar a mão na massa de verdade, ter problemas para resolver usando a técnica, etc. Os disponíveis eram bastante teórico, deixando a parte prática sobre minha responsabilidade que, como iniciante, era difícil saber por onde começar. Esses livros foram importantes para entendimento e formação da minha base teórica sobre o assunto, mas eu percebi que uma coisa era eu ter lido e outra era praticar e me ver com o Eclipse aberto e sem saber o que fazer de verdade, ou pior, me perguntar: ‘como resolver um problema usando TDD e não cair na tentação de escrever os testes por último?’. Quem não tem cão caça com gato. Tive que criar meu próprio caminho prático, onde comecei a desenvolver novas aplicações usando a técnica (venci pela persistência), em seguida surgiu  a oportunidade de ir para um projeto novo na empresa que trabalhava e lá tive o espaço para desenvolver usando TDD por quase 2 anos, e nesse meio surgiu a ideia desse livro: “por que não criar um livro prático sobre TDD com base na minha experiência?”. E foi assim que comecei a escrever o livro no final de 2010, tendo como referência o Kent Beck.  

O que você vai encontrar no livro:

  • Desenvolver aplicações Java usando a técnica de TDD;
  • Exercícios Práticos;
  • O uso de objetos mocks com Mockito;
  • Praticar algumas técnicas de Refactoring ;
  • Entender os valores do mundo Agile;
  • Por que TDD?
  • Junit;

E como sempre, dei preferência em usar uma linguagem informal e fazendo o uso bastante da primeira pessoa. O motivo é que durante seus estudos quero que tenha a sensação de estar batendo um papo comigo ao invés de estar lendo algo mais formal.

Meu desafio

Quando eu decidi escrever esse projeto foi porque me sentir desafiado (assim como os outros já publicados). É isso mesmo. Ao olhar o que tinha em mãos (anotações) mais a experiência e sofrimento com o “mundo TDD” e decepções que passei eu disse: “preciso escrever um livro sobre o assunto”. Daí reparei que escrever um livro com um assunto abstrato não seria uma tarefa fácil, uma vez que TDD, refactoring são técnicas que não se aplicam somente à linguagem Java. E daí eu comecei a entender melhor o livro do Kent Beck (TDD by example) e Martin Fowler (o de Refactoring) o quanto eles são “chatos” e sem sabor para quem é bem iniciante. E eu disse: “preciso fazer algo que empolgue o iniciante, ou seja, algo com sabor, mas que eu não venha perder o eixo principal da técnica”. E daí passei dias pensando, escrevendo, apagando, anotando, dormindo sem respostas e fui vendo como vencer esse desafio de ensinar TDD sem ferir os conceitos da técnica. Isso era o que me tirava o sossego todos os dias e não sei se consegui atingir. Acredito que sim, mas só terei a certeza quando você me escrever dizendo o que achou J. (aguardem até o lançamento…)

Quem pode ler?

O publico alvo são estudantes da tecnologia Java que querem aprender usar TDD desde o principio e tem simpatia com o mundo Agile.Se você ainda está dando os primeiros passos com Java e gosta de ser desafiado, este livro é para você. Indiretamente o livro acaba revisando alguns conceitos básicos do Java nada fora do normal, porém agora o desafio é você fazer as coisas mais simples escrevendo seu teste primeiro. Como eu já passei por isso, sei o quanto difícil é escrever os testes primeiro antes do código funcional e quando eu falo mais simples, não necessariamente é mais fácil.  Se você está bem no inicio do Java, ainda dando “Hello World”, eu diria que o livro não vai ajudar muito nos seus estudos com Java, talvez atrapalhe. A minha sugestão é: aprenda primeiro os fundamentos da linguagem e Orientação à Objetos e depois retorne à todo vapor para ler o livro. Enquanto isso coloque na prateleira e não compre o exemplar.

Pensei em escrever este livro quando, ao iniciar meus estudos com Java, não encontrei um material do qual pudesse desde “pequeno” ir sendo educado com boas práticas, e fui aprendendo no dia-dia, além dos sofrimentos que tive até adquirir uma nova cultura. Se você é aquele iniciante que está a fim de colocar em prática toda essência do Java e ao mesmo tempo ir entendendo o que só ouve falar de TDD, Refactoring, JUnit, este livro é para você.

Eu particularmente diria que este é um tipo de livro que gostaria de ler depois de ter lido Head First Java da Kathy Sierra.

Agradecimentos

Fazer essa parte aqui nunca é fácil, pois são várias pessoas que contribuem para uma obra como essa: amigos, colegas de trabalho, familiares, “amigo virtual” etc. E lembrar todos não é uma tarefa fácil. Sendo assim, estarei destacando aqueles que vieram em memória no momento que escrevo este trecho. Aqueles que contribuíram e acabei esquecendo, peço que perdoem.

Não poderia esquecer o meu colega de trabalho Gustavo Knuppe, apesar dele não saber que estava escrevendo este livro, foi responsável em muitas mudanças que fiz na forma de abordar o assunto de TDD.Principalmente em um artigo sobre TDD, o qual Knuppe foi o revisor, e nesse processo, sugiram várias e boas sugestões no artigo produzido e aproveitei para utilizar neste projeto. Um amigo que não poderia deixar de fora é o Alberto Leal. Eu diria que meu contato com mundo Agile começou devido a uma apresentação sobre refactoring que o Leal fez em alguns minutos via MSN e depois desse dia fui me envolvendo mais e mais com a técnica e quando conheci TDD e liguei o passado com o presente vi que ter conhecido refactoring com o Alberto fez uma diferença e grande. Obrigado meu amigo!

Outra pessoa é meu amigo Edson Gonçalves, sempre digo que se me tornei um escritor é porque fui “batizado” por esse grande escritor e amigo, o qual já temos um laço de amizade verdadeira por mais de quatro anos. Dedicar este livro para um grande amigo como você é o mínimo que posso fazer. Nos momentos mais difíceis você sempre estava ali comigo me dando força. Abraços e tudo de bom para você meu grande amigo.

Formatos

  • Será vendido no formato impresso e e-book.

Enfim, pessoal essa foi a pequena apresentação do meu próximo livro. Espero que vocês gostem e curtam. Quem quiser divulgar nas comunidades eu não me importo 🙂

Abraços, qualquer dúvida só mandar.

See ya!!!

Série DesignPattern: Adapter

Olá Pessoal,
Mais um post da série “Design Pattern não é receita de bolo”. Hoje vamos conhecer o padrão Adapter. Pelo nome já temos ideia do que seria o padrão. Mas como seria à nível de código Java? Boa pergunta. Vamos ver isso no nosso post de hoje. Ah, o Adapter faz parte da família ‘Padrões Estruturais’.

Lets go…

Adapter

Substitui um objeto por outro que realiza a mesma tarefa, mas por uma interface diferente (não estamos  falando de interface Java aqui).

Exemplo:
As novas tomadas brasileiras realizam a mesma tarefa que as antigas, mas por uma interface diferente (com três pinos). Esse novo pino é uma nova funcionalidade.

Motivação
A motivação é querer adicionar uma nova funcionalidade ao sistema sem perder o comportamento e com custo baixo.No caso da tomada, o custo da mudança é comprar apenas um adaptador (adapter). Já pensou se além do adaptador tivéssemos que trocar o tipo do fio (somente para seguir o novo padrão)? Isso seria inviável e o custo muito alto. Um adaptador não pode gerar um custo alto para o novo modelo. Em aplicação, podemos pensar da seguinte forma: “adicionar aquele novo componente ao legado não pode custar caro demais e sim ter o custo considerável, como colocar mais memoria no servidor ou HD, mas não pode exigir um novo tipo de servidor de 1 milhão de dólares, por exemplo”. Quando estiver com dúvida com o Adapter, pergunte-se por que você tem adaptadores em sua casa? O motivo é que você não vai trocar toda sua instalação elétrica para o novo modelo.

Prática
A seguir temos uma prova de conceito da implementação do Adapter. Usei as novas tomadas brasileiras como exemplo. Novamente procure entender o uso do Adapter e como implementar. O código não tem nenhuma funcionalidade legal de ver, apenas um println com uma mensagem. O foco é conhecer o Design Pattern Adapter. A seguir uma modelagem bem didática, para facilitar o entendimento:

Passo 1
Como sempre, o nosso projeto:

Agora criamos a classe Tomada (ela possui a implementação antiga).

package br.com.camilolopes.classes;
/*
* tomada antiga
* ela não tem controle de energia como as novas
*/
public class Tomada {

public void on(){
System.out.println(“tomada conectada”);
}
public void off(){
System.out.println(“tomada desconectada”);
}
}

Passo 2
Obviamente que adapters são criados em classes já existentes. Então o primeiro ponto é ver onde precisa de um adaptador. No caso acima, precisamos de um adaptador nas tomadas. Para isso vamos extend a classe ‘Tomada’ já existente, assim fazemos tudo que ela já fez e não quebramos nada:

package br.com.camilolopes.adapters;

import br.com.camilolopes.classes.Tomada;
import br.com.camilolopes.newmodel.TomadaNova;
/*
* criando o adaptador
* ele que tem a responsabilidade de chamar o método novo
*/
public class TomadaAdapter extends Tomada {
private TomadaNova tomadaNova;

public TomadaAdapter() {
tomadaNova = new TomadaNova();
}

@Override
public void on() {
tomadaNova.on(true);
}

@Override
public void off() {
tomadaNova.off(false);
}

}

Acabamos de criar nosso Adapter.

E agora vamos criar a classe que tem a implementação das novas Tomadas.

TomadaNova.java

package br.com.camilolopes.newmodel;
/*
* aqui é a implementação do novo modelo de tomada
*/
public class TomadaNova {
public void on(boolean status){
System.out.println(“Novas tomadas Brs”);
checkEnergia(status);
}

private void checkEnergia(boolean status) {
if (status) {
System.out.println(“controle de segurança de energia está ” + status);
}else{
System.out.println(“controle de segurança de energia está ” + status);
}

}

public void off(boolean status) {
checkEnergia(status);

}
}

A classe Adapter é responsável por estar conectada à antiga tomada e com a nova. O usuário vai conectar ao Adapter e ele terá que chamar a nova implementação de tomada que, no nosso caso, eu disse que nas novas tomadas, há um sistema de controle de energia, por medida de segurança.

Criaremos a classe com o método main que será o ponto de entrada para receber a tomada e conectar ao adapter. Veja:

package br.com.camilolopes.main;

import br.com.camilolopes.adapters.TomadaAdapter;
import br.com.camilolopes.classes.Tomada;

public class TesteNovaTomada {

/**
* @param args
*/
public static void main(String[] args) {
/*
* conectando a tomada ao adaptador – adapter
*/
Tomada tomada = new TomadaAdapter();
//ligando a tomada
tomada.on();
//desligando a tomada
tomada.off();

}

}

O Resultado
Pronto! Veja que nosso Adapter já usa a versão da tomada.

 

Git Hub 

Os projetos encontram-se no Github:

https://camilolopes@github.com/camilolopes/workspacedesignpattern.git 

Bom, é isso ai pessoal. Vou ficando por aqui. Espero que vocês estejam curtindo a série.
Abraços, see ya!!