JQuery com Struts - Parte I

Java Magazine 91

Saiu a primeira parte do meu artigo, sobre jQuery com Struts, na Java Magazine 91.

Para conferir basta clicar no link abaixo:

http://www.devmedia.com.br/post-21128-jQuery-com-Struts-Parte-1.html

Configurando um pool de conexões no GlassFish

Um pool de conexões é uma espécie de cache de conexões com o banco de dados, que tem por objetivo, torná-las reutilizáveis. Assim, a comunicação com o banco torna-se mais eficiente.

Uma das grandes vantagens, quando se está trabalhando em um ambiente JAVA EE, é o fato de podermos contar com pools de conexões gerenciados pelo próprio container.

Esta característica, permite que aplicações se conectem ao banco de dados, sem que o desenvolvedor precise se preocupar com o ciclo de vida das conexões realizadas. Pois em um ambiente JAVA EE, esta tarefa é responsabilidade do container.

Contudo, para que o desenvolvedor possa contar com essa facilidade, é preciso configurar um pool de conexões. Sendo assim, vou mostrar como isto pode ser feito, utilizando o servidor de aplicações GlassFish e o banco de dados PostgreSQL.

1. Copie o driver do PostgreSQL para a pasta [GLASSFISH_HOME]/glassfish/domains/domain1/lib/ (domain default). Para isso, basta baixar o driver jdbc4, correspondente à sua versão do PostgreSQL, em http://jdbc.postgresql.org. Desta forma, não será mais preciso utilizar o driver diretamente no classpath (pasta 'lib') de suas aplicações.
2. Reinicie o servidor para que ele passe a utilizar o driver.
3. Após a reinicialização, vá ao console de administração (normalmente porta 4848 - ex.: http://localhost:4848/) e selecione a opção Resources/JDBC/Connection Pools, no menu à esquerda.
4. Clique no botão 'New...'. Defina o nome que achar melhor para o pool de conexões (ex.: meuBancoPool). Selecione a opção  javax.sql.ConnectionPoolDataSource na combo 'Resource Type' e selecione PostgreSQL em 'Database Vendor'. Clique no botão 'Next'.
5. Selecione o 'Datasource Classname' org.portgresql.ds.PGConnectionPoolDataSource, na combo. Em seguida, vá ao final da página e informe os seguintes dados: DatabaseName=[nome-do-banco], Password=[senha-do-banco], PortNumber=5432 (porta default), ServerName=[nome-do-servidor ou ip], User=[usuario-do-banco].
6. Clique em 'Finish' para salvar o pool.
7. Agora que o pool de conexões foi criado, é hora testá-lo. Para isso, selecione o pool recém criado e clique em 'Ping'. A mensagem "Ping Succeeded", indica que tudo está funcionando corretamente.
8. Com o pool criado e testado, falta apenas permitir que suas aplicações o utilizem. Sendo assim,  é preciso criar um nome JNDI para ele. Vá ao menu Resources/JDBC/JDBC Resources, especifique o nome no formato jdbc/[nome-do-banco], selecione o pool de conexões criado nos passos anteriores e clique em 'OK', para finalizar. Este nome deverá ser utilizado nas aplicações, para permitir a comunicação com o banco de dados através do pool de conexões.

TDD na prática

Java Magazine 89

Escrevi um artigo sobre TDD, para a Java Magazine deste mês.

Nele, eu mostro o desenvolvimento de uma aplicação utilizando a técnica de Test-Driven Development (TDD).

Para conferir, basta acessar:

http://www.devmedia.com.br/post-20154-TDD-na-pratica.html

Java e Domain-Driven Design com JSF, EJB e JPA

Java Magazine 87

Saiu um artigo meu, na capa da Java Magazine deste mês. Nele eu mostro a criação de uma aplicação baseada na metodologia de Domain-Driven Design, utilizando os frameworks JSF, EJB e JPA.

Vale a pena conferir!

Link para o artigo:

http://www.devmedia.com.br/post-19019-Java-e-Domain-Driven-Design-na-pratica.html

Link para a revista:

http://www.devmedia.com.br/post-19022-Revista-Java-Magazine-87.html

Mais polimorfismo, menos estruturas de controle...

Programadores OO estão acostumados com polimorfismo, porém, programadores da escola procedural ou programadores que estão iniciando no mundo OO, não conhecem ou não enxergam a utilidade prática deste recurso.

A definição do Deitel para polimorfismo é:

"O polimorfismo, permite 'programar no geral' em vez de 'programar no específico'. Em particular, o polimorfismo permite escrever programas que processam objetos que compartilham a mesma superclasse em uma hierarquia de classes como se todas fossem objetos da superclasse."

Mas como isso funciona na prática?

Mesmo com uma linguagem orientada a objetos como o JAVA, é possível escrever programas procedurais. Orientação a objetos está muito mais ligada à decisões de design de software, do que simplesmente à utilização de uma linguagem orientada a objetos.

Por exemplo, usando JAVA, poderíamos escrever o seguinte código:

public class TestAnimais {
 
     enum TipoAnimal{CACHORRO, GATO, GALINHA};
 
     public static void main(String[] args) {
  
          TipoAnimal tipo = TipoAnimal.CACHORRO;
          Animal a = new Animal(tipo);
  
          switch (a.getTipo()) {
               case CACHORRO:
                    System.out.println("ROOF");
                    break;
               case GATO:
                    System.out.println("MEOW");
                    break;
               case GALINHA:
                    System.out.println("CÓ-CÓ-CÓ");
                    break; 
               default:
                    break;
          }
    }
}

Este trecho de código é tipicamente procedural. Programas desenvolvidos utilizando este paradigma, costumam ter muitas instruções de controle do tipo if e switch, para tomada de decisões em tempo de execução.

Podemos refatorar o código acima utilizando uma abordagem polimórfica, orientada a objetos, para reduzir o uso de estruturas de controle (menos 'código espaguete') e tornar o design mais extensível.

Primeiro, criamos uma classe abstrata Animal:

public abstract class Animal { 
     public abstract void emitirSom();
}

Em seguida, criamos uma classe concreta Cachorro, que estende Animal.

public class Cachorro extends Animal {

     public void emitirSom() {
          System.out.println("ROOF");
     }
}

Com este design, nossa 'classe cliente' poderia ficar assim:

public class TestAnimais {
 
     public static void main(String[] args) {
          Animal a = new Cachorro();
          new TestAnimais().digaAlgo(a);
     }
 
     // método ilustrativo
     public void digaAlgo(Animal animal){
          // método polimórfico (Qual animal?)
          animal.emitirSom();
     }
}

O polimorfismo se manifesta no momento em que fazemos uma variável de referência da superclasse (Animal), apontar para um objeto da subclasse (Cachorro) na heap. Desta forma, quando ordenamos que um animal emita som, o método emitirSom() utilizado, é resolvido em tempo de execução baseado no tipo do objeto na heap, sem a necessidade de testes condicionais.

Muitos argumentam que programar orientado a objetos é mais lento. De fato, a curto prazo, esta afirmação muitas vezes se mostra verdadeira.

Os grandes benefícios do paradigma aparecem a médio e longo prazo, principalmente na fase de manutenção do projeto (onde se gasta aproximadamente 80% do tempo).

Por exemplo, se quisermos adicionar um novo animal ao projeto, basta criar um classe concreta (ex.: Gato) que estenda Animal, pois não há risco de comprometer a integridade do que já funciona (design extensível), além do fato de que qualquer método que receba ou retorne um objeto do tipo Animal (ex.: public void digaAlgo(Animal animal)), pode trabalhar normalmente com a nova classe concreta, sem a necessidade de adição de código extra, graças ao polimorfismo.