Caso você ainda não leu os posts anteriores, por favor dê um pulinho bem rápido neles:

• Spring Framework Parte 1 -> Dependency Injection
• Spring Framework Parte 2 -> Aspect Oriented Programming

Vamos ao nosso próximo assunto então: JDBC e como o Spring facilita esse cara pra gente!

Tirando essa imagem do livro Spring in Action 2 (Manning, 2008) nós já conseguimos ver bem por cima como que o Spring pretende acessar de maneira padronizada a base de dados (Hitting the database) através de um objeto de acesso aos dados (DAO), um template (provido pelo próprio Spring) e caso nós quiséssemos, o Spring também oferece suporte padrão para alguns frameworks de persistência (será um dos próximos artigos desta série).

Tudo muito legal, muito bonito! Vamos tentar seguir este modelinho porque ele é bem bonitinho e vai nos ajudar um pouco. Apenas avisando que o jeito que descreverei neste tutorial não é o único jeito de acessar os dados através do seu driver JDBC, porém é um jeito que eu achei bem interessante e que vale a pena todos sabermos um pouquinho… =]

Existem apenas 2 conceitos básicos que o Spring nos sugere para o acesso rápido e fácil aos dados através de drivers JDBC: DataSource (DAO fornecido pelo Spring) e JdbcTemplate (template para acesso a dados através de um driver JDBC fornecido pelo Spring):

DataSource é uma classe provida pelo nosso querido Spring Framework e que se preocupa com toda a conexão e conversação com o driver JDBC que iremos utilizar (neste exemplo iremos utilizar o driver JDBC para o banco de dados MySQL). Em palavras um pouco mais técnicas, esta classe irá se resonsabilizar por nos entregar um objeto java.sql.Connection, java.sql.Statement, entre esses objetos que utilizamos quando o assunto é conexão de dados JDBC.

JdbcTemplate é uma outra classe muito útil provida pelo nosso adorado Spring! Este template provê métodos padronizados para acessarmos os dados (selecioná-los e manipulá-los), ou seja, fazer tudo o que podemos fazer com eles de um jeito bem fácil de acessar (como você irá descobrir logo a frente).

Muito bem, com esses dois conceitos já pintados na sua cabeça, por favor responda corretamente a próxima pergunta: “Já que estas classes são providas pelo nosso amigo Spring, quem instancia elas?”. Exato!! O próprio Spring cria os beans para estas classes, tudo o que temos que fazer é declarar estes beans no arquivo de configuração do Spring. Vamos a ele então:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost/spring_jdbc" />
        <property name="username" value="root" />
        <property name="password" value="123" />
    </bean>
 
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>
 
</beans>

Tão simples quanto encher um copo com água! Eu sinto até orgulho de mostrar como é fácil conectar com uma fonte de dados JDBC através do Spring!

O nosso primeiro bean é o dataSource. Como eu já disse ali em cima, esse é o cara responsável por conversar com o driver JDBC. Então nada mais justo que a gente ensinar ele a se comunicar com o driver passando os parâmetros corretos não é… Os parâmetros (injetados através da DI) passados para o dataSource foram: dataClassName (qual driver JDBC será usado), url (caminho do JDBC para se conectar até o banco de dados desejado), username (login do banco de dados) e password (senha do banco de dados).

No caso desse nosso exemplo, o driver JDBC é do MySQL, nunca esqueça que o driver deve estar no classpath em!!! Segue uma foto te ensinando como adicionar o driver JDBC do MySQL no NetBeans:

E o segundo bean do arquivo de configuração é o jdbcTemplate que é o template provido pelo Spring para facilitar a manipulação dos dados. A unica dependência que este bean tem é o próprio dataSource, ou seja, ele precisa de uma referência para um dataSource para saber em qual banco ele vai executar os comandos que quisermos. Sendo assim, de um jeito muito fácil (injeção de dependência), nós passamos uma referência do nosso dataSource já criado para ele. ^^

Só fazendo uma pequena pausa no Spring agora, vamos falar um pouquinho do banco de dados: criei uma tabela de Pessoas para fazermos nossos teste aqui. Dê uma olhada no script de criação:

CREATE TABLE  `Pessoas` (
    `pes_cod` INT NOT NULL ,
    `pes_nome` VARCHAR( 100 ) CHARACTER SET utf8 COLLATE utf8_unicode_ci NOT NULL ,
    `pes_idade` INT NOT NULL ,
    PRIMARY KEY (  `pes_cod` )
) ENGINE = INNODB CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Muuuito bem! A esta altura nós já temos os arquivos base para a conexão com o banco de dados E o banco de dados! Vamos continuar a codificar mais algumas classes e veremos o quão fácil o Spring tornou o acesso aos dados através do JDBC para nós.

Já que temos a tabela pronta no banco de dados, precisamos desenvolver uma classe Java que irá representar cada registro dessa tabela (para manipulação em memória né…):

Pessoa.java

public class Pessoa {
 
    private int cod;
    private String nome;
    private int idade;
 
    public Pessoa() {
        this.cod = -1;
        this.nome = "Não Encontrado";
        this.idade = -1;
    }
 
    public int getCod() {
        return cod;
    }
 
    public void setCod(int cod) {
        this.cod = cod;
    }
 
    public int getIdade() {
        return idade;
    }
 
    public void setIdade(int idade) {
        this.idade = idade;
    }
 
    public String getNome() {
        return nome;
    }
 
    public void setNome(String nome) {
        this.nome = nome;
    }
 
    @Override
    public String toString() {
        return "Codigo: " + String.valueOf(this.cod)
                + " | Nome: " + this.nome
                + " | Idade: " + String.valueOf(this.idade);
    }
}

Pronto, com a classe Pessoa agora fica bem mais fácil nós termos uma “Pessoa” em memória! Vamos daqui pra frente tentar unir a classe Pessoa que acabamos de escrever com o banco de dados, ou seja, inserir um objeto da classe Pessoa no banco de dados, recuperar um objeto Pessoa do banco, e por ai vai…

Caso você acompanha este blog regularmente, já deve ter percebido que eu virei fã de utilizar as interfaces no desenvolvimento (os motivos são muitos! então apenas acredite: compensa!). Já que eu sou um cara que gosta de seguir padrões e tudo mais, vamos codificar uma interface que será muito útil para o nosso acesso ao banco de dados:

IBanco.java

public interface IBanco {
 
    public void InserirPessoa(Pessoa pessoa);
 
    public void AtualizarPessoa(Pessoa pessoa);
 
    public void ApagarPessoa(Pessoa pessoa);
 
    public Pessoa SelecionarPessoa(Pessoa pessoa);
}

Esta interface obriga a classe que implementá-la a dar suporte para as operações CRUD referêntes aos objetos Pessoa juntamente com a tabela do banco de dados Pessoa (ficou meio confusa essa frase? hehehe).

Como o código sempre resolve tudo, vamos a ele que você irá entender do que eu estou falando:

BancoDados.java

public class BancoDados implements IBanco {
 
    private JdbcTemplate jdbcTemplate;
 
    public BancoDados() {
    }
 
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }
 
    public void InserirPessoa(Pessoa pessoa) {
        String sql = "INSERT INTO Pessoas(pes_cod,pes_nome,pes_idade) VALUES(?,?,?)";
        jdbcTemplate.update(sql, new Object[]{pessoa.getCod(), pessoa.getNome(), pessoa.getIdade()});
    }
 
    public void AtualizarPessoa(Pessoa pessoa) {
        String sql = "UPDATE Pessoas SET pes_nome = ?, pes_idade= ? WHERE pes_cod = ?";
        jdbcTemplate.update(sql, new Object[]{pessoa.getNome(), pessoa.getIdade(), pessoa.getCod()});
    }
 
    public void ApagarPessoa(Pessoa pessoa) {
        String sql = "DELETE FROM Pessoas WHERE pes_cod = ?";
        jdbcTemplate.update(sql, new Object[]{pessoa.getCod()});
    }
 
    public Pessoa SelecionarPessoa(Pessoa pessoa) {
        String sql = "SELECT * FROM Pessoas WHERE pes_cod = ?";
 
        List resultados = jdbcTemplate.query(sql, new Object[]{pessoa.getCod()},
                new RowMapper() {
 
                    public Object mapRow(ResultSet rs, int i) throws SQLException {
                        Pessoa p = new Pessoa();
                        p.setCod(rs.getInt("pes_cod"));
                        p.setNome(rs.getString("pes_nome"));
                        p.setIdade(rs.getInt("pes_idade"));
                        return p;
                    }
                });
 
        Pessoa pes = new Pessoa();
        if (resultados.size() > 0) {
            pes = (Pessoa) resultados.get(0);
        } else {
            pes.setCod(pessoa.getCod());
        }
 
        return pes;
    }
}

Muito bem, vamos com calma…

A primeira coisa que devemos notar é que temos uma variável de instância chamada jdbcTemplate. Como eu imagino que você leitor é um cara que associa tudo muito rápido e já viu que um pouco mais pra baixo dessa variável tem o setter dela, eu imagino que você já entendeu que essa variável vai ser injetada através do container do Spring né… =]

Como nós já pedimos pro Spring criar um bean do tipo JdbcTemplate no arquivo de configuração, daqui a pouco nós voltaremos nele e pediremos pra ele enviar uma referência do JdbcTemplate aqui pra essa nossa classe poder usar. Tudo muito prático!

Depois disso o que nós podemos entender é que a classe reescreveu os métodos que a interface obriga e os implementou de fato! Vamos entender eles rapidinho…

Para as operações de inserção, alteração e exclusão os métodos são absolutamente iguais: primeiro foi definido o SQL referente a operação e depois foi chamado o método update da nossa classe super amigável: jdbcTemplate.

Existem dois detalhes para chamar a atenção na execução destas operações:

1 – O SQL que foi montado não possui os valores finais. Ao invés deles estão presentes pontos de interrogação ( ? ) representando parâmetros.

2 – Os parâmetros informados no SQL são enviados como o segundo parâmetro do método update do jdbcTemplate. Para a padronização na chamada do método é necessário que todos os parâmetros definidos no SQL sejam passados dentro de um vetor de Object (mesmo que seja só um parâmetro, ele também deve estar dentro do vetor). Outra coisa que vale ser lembrada é que o primeiro item do vetor irá ser incluído no lugar do primeiro parâmetro do SQL (primeiro ponto de interrogação) então tome cuidado para passar os parâmetros na ordem correta para o vetor de Object.

Só mais um comentário para a operação de seleção: também foi utilizado um SQL com parâmetro e um vetor de Object referenciando os parâmetros porém o método do jdbcTemplate utilizado não foi o update, e sim o query!

O funcionamento deste método é bem interessante: ao invés de apenas 2 parâmetros (como no método update), depois do vetor de Object é passado um objeto org.springframework.jdbc.core.RowMapper que é responsável por mapear cada registro retornado por um ResultSet interno ao jdbcTemplate em um objeto correspondente ao registro e após o mapeamento o objeto customizado é adicionado a um java.util.List que é o retorno final do método query.

Exemplo do nosso caso: caso sejam retornadas 3 pessoas pelo SQL utilizado, o método mapRow do objeto RowMapper será invocado 3 vezes (uma para cada registro). Cada vez que ele for invocado será configurado um novo objeto Pessoa com os dados de cada registro retornado do banco de dados e cada vez que o método retornar um novo objeto Pessoa ele será guardado na lista que será retornada pelo método query.

Logo depois deste método eu apenas retorno o primeiro objeto que está na lista ou então retorno um objeto com o mesmo código da busca caso não foi encontrado nenhum registro.

Sempre muito simples esses códigos… adoro isso… ehheheh

Vamos adicionar um bean ao arquivo de configuração do Spring para o container também instanciar a nossa classe responsável pelo banco de dados e é claro, vamos também já injetar o JdbcTemplate no nosso novo bean:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.mysql.jdbc.Driver" />
        <property name="url" value="jdbc:mysql://localhost/spring_jdbc" />
        <property name="username" value="root" />
        <property name="password" value="123" />
    </bean>
 
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource" />
    </bean>
 
    <bean id="banco_dados" class="spring_jdbc.BancoDados">
        <property name="jdbcTemplate" ref="jdbcTemplate" />
    </bean>
 
</beans>

E isso é tudo!!
Nossas classes base para o acesso e manipulação da entidade Pessoa no banco de dados e no nosso próprio software já estão codificadas e bem funcionais. Tudo que precisamos agora é de um programinha exemplo para testarmos estas classes e ver como iriam ser realmente usadas.

Segue a classe que contém o método main desta aplicação:

public class Principal {
 
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("/conf/spring_jdbc.xml");
 
        BancoDados banco = (BancoDados) ctx.getBean("banco_dados");
 
        //cria os objetos Pessoa
        Pessoa p1 = criar_pessoa(1, "Felipe", 18);
        Pessoa p2 = criar_pessoa(1, "Felipe Saab", 21);
        Pessoa felipe = null;
 
        //insere no banco
        try {
            banco.InserirPessoa(p1);
            System.out.println("1 - Pessoa Inserida");
        } catch (Exception e) {
            System.out.println("Não foi possível inserir o registro: " + e);
        }
 
        //recupera
        try {
            felipe = banco.SelecionarPessoa(p1);
            System.out.println("2 - Pessoa recuperada: " + felipe);
        } catch (Exception e) {
            System.out.println("Não foi possível recuperar o registro: " + e);
        }
 
        //altera
        try {
            banco.AtualizarPessoa(p2);
            System.out.println("3 - Pessoa Atualizada");
        } catch (Exception e) {
            System.out.println("Não foi possível atualizar o registro: " + e);
        }
 
        //recupera novamente
        try {
            felipe = banco.SelecionarPessoa(p2);
            System.out.println("4 - Pessoa recuperada: " + felipe);
        } catch (Exception e) {
            System.out.println("Não foi possível recuperar o registro: " + e);
        }
 
        //apaga
        try {
            banco.ApagarPessoa(p2);
            System.out.println("5 - Pessoa Apagada");
        } catch (Exception e) {
            System.out.println("Não foi possível apagar o registro: " + e);
        }
 
        //procura pela ultima vez
        try {
            felipe = banco.SelecionarPessoa(p2);
            System.out.println("6 - Pessoa recuperada: " + felipe);
        } catch (Exception e) {
            System.out.println("Não foi possível recuperar o registro: " + e);
        }
    }
 
    public static Pessoa criar_pessoa(int cod, String nome, int idade) {
        Pessoa p = new Pessoa();
        p.setCod(cod);
        p.setNome(nome);
        p.setIdade(idade);
        return p;
    }
}

Concordo que o exemplo é meio grandinho mas é bem fácil de entender não é?
Primeiro foram criados 3 objetos Pessoa (p1 – “Felipe”, p2 – “Felipe Saab” e felipe que irá receber o resultado da busca no banco), depois foi inserido um dos objetos, procurado por ele no banco, depois ele foi alterado com as informações do outro objeto e foi recuperado novamente, e por fim a Pessoa foi apagada do banco e só para garantir foi feita uma última busca.

Este exemplo foi só para testar todas as operações que nós implementamos. Caso você use algo parecido no seu software do dia a dia irá ver que tudo funciona perfeitamente bem (cada operação no teu lugar certo).

É isso ai leitor! Você chegou ao fim deste post grandão!!
Espero que tenha gostado da leitura e da função que foi descrita aqui.

Caso queira fazer o download do projeto que eu desenvolvi como exemplo pode fazer o download aqui (OBS: o projeto está com bibliotecas do NetBeans 6.8 (Spring 2.5 e MySQL JDBC) então ele só vai rodar 100% certo caso você abra ele no NetBeans 6.8 ou superior, caso contrario, apenas aproveite os códigos fonte =] ).

[]s e até a próxima,
Saab.

Beleza, daqui pra frente vou assumir que você já sabe como linkar os beans no Spring utilizando o arquivo de configuração (pelo menos o básico, como visto na Parte 1 desta série).

Vamos ao nosso post então: AOP: Aspect Oriented Programming (POA: Programação Orientada a Aspectos). E como sempre, pra fugir um pouco dos termos técnicos, vamos a uma história:

Imagine que você está desenvolvendo um e-commerce, atualmente está desenvolvendo o checkout do teu sistema, ou seja, o cliente já escolheu tudo o que ele queria, e agora vai fazer a transferência eletrônica do pagamento (vamos imaginar que você está desenvolvendo tudo isso). Olhando com um nível de abstração muito alto o seu código poderia ser algo assim:

public class CheckoutService {
    //...
    public void efetuarPagamento(Carrinho carrinho){
        LOGGER.log(new Date().toString() + " - Executando efetuarPagamento(Carrinho carrinho)");
        if (carrinho.getCliente().temPermissao()){
             DAO.iniciarTransacao();
             try {
                 carrinho.getCliente().debitar(carrinho.getValorTotal());
                 carrinho.finalizarCompra();
                 DAO.commit();
                 LOGGER.log(new Date().toString() + " - Pagamento efetuado!");
             } catch (Exception e) {
                 DAO.rollback();
                 LOGGER.log(new Date().toString() + " - " + e.toString());                 
             }
        } else {
            LOGGER.log(new Date().toString() + "Cliente não está autenticado");
        }
    }
    //...
}

Dê uma boa olhada no código… O que tem a ver mesmo com o checkout são apenas as linhas:

carrinho.getCliente().debitar(carrinho.getValorTotal());
carrinho.finalizarCompra();

O resto é código responsável por logging, controle de transação, permissão de acessos, coisas que são necessárias porém que ocupam muito espaço, “sujam” o código. A idéia da orientação a objetos é encapsular em um objeto todas as coisas referentes a ele, os serviços que ele vai prestar, e não ficar poluindo ele com outros códigos que não tem nada a ver com o seu propósito.

Mas esses códigos são necessários para a aplicação funcionar corretamente! O que fazer então? Orientação a Aspectos!!!

A Orientação a Aspectos surgiu exatamente para eliminar os cross-cutting concerns (código que é necessário, porém foge das preocupações principais do objeto, como no caso acima, o checkout tem que se preocupar com o logging, transação e permissão).

OBS: Existem vários termos técnicos, sem graça, e difíceis de entender envolvidos nesse “paradigma” de programação. Nós vamos discutindo-os conforme o tutorial for andando.

Então como eu faço para separar esse código chato dos meus objetos? A Orientação a Aspectos funciona assim:

-> Primeiro a gente separa o código que não tem nada a ver com o nosso objeto (logging, transação, permissão e tals) em um lugar separado. Esse lugar separado se chama advice (é o o que).

-> Ainda dentro do advice, é definido onde o programa tem que dar uma “paradinha” para que o código que foi separado possa ser executado. Todo lugar que o programa pode dar essa “paradinha” é chamado de join point. Um join point pode ser por exemplo: uma chamada de método, a execução de um método, instanciação de objetos, execução de construtores, e mais alugns (é o quando).

-> Uma vez que nós já sabemos o que vai ser feito (advice) e quando vai ser feito (join point), falta definir onde vai ser feito. Para isso servem os pointcuts. Geralmente são definidos utilizando os nomes das classes e métodos que queremos interceptar, mas também podem ser definidos através de expressões regulares (logo mais veremos um exemplo na prática).

-> Por fim, o conjunto de tudo isso (o que vai ser feito, quando vai ser feito e onde vai ser feito) é chamado de aspect (aspecto).

Em muito poucas palavras isso é a base da orientação a aspectos. Vamos ver como a gente pode utilizar isso no Spring.

O Spring oferece diversos tipos de suporte a Orientação a Aspectos (eles foram evoluindo através das versões), dentre eles o suporte para a orientação a aspectos declarativa (no XML de configuração) e anotativa (utilizando annotations (se não sabe o que são annotations clique aqui)).

Eu estudei as duas e devo dizer que me identifiquei muito mais com a orientação a aspectos utilizando annotations, portanto é ela que eu irei mostrar aqui (caso queira aprender sobre o outro tipo eu aconselho fortemente o livro Spring in Action 2 (Manning, 2008), capítulo 4).

OBS: Eu irei reaproveitar o código da Parte 1, então caso você não tenha feito o tutorial anterior eu aconselho a pelo menos pegar os código de lá. Tudo o que eu fiz foi renomear o projeto para “OrientacaoAspectos”, o pacote principal para “orientacaoaspectos” e todas as definições dos beans no arquivo de configuração para bater com o novo nome do pacote.
Como o suporte de orientação a aspectos do Spring consegue usar a poderosa linguagem do AspectJ (para definir pointcuts) nós vamos usá-la aqui, para tanto é necessário o download da biblioteca do AspectJ e a inclusão dela no classpath. O arquivo pode ser baixado no site do projeto.
Só mais um detalhe: o arquivo que vc baixa do site eh um .jar chamado: aspectj-x.x.x.jar, dentro dele é que estão as bibliotecas que o Spring precisa, então abra este arquivo com o WinRAR (ou outro do gênero) navegue até a pasta /lib, extraia os .jar que estão lá e os adicione ao classpath.

Voltando ao escopo da nossa aplicação: o show de talentos Ídolos Spring, vamos adicionar um requisito muito importante para qualquer programa de entrenimento: a platéia!

Sem utilizar a orientação a aspectos nós teríamos os seguintes códigos:

public class Plateia {
 
    public Plateia() { }
 
    public void sentar(){
        System.out.println("A platéia está sentando");
    }
 
    public void desligarCelulares(){
        System.out.println("A platéia está desligando os celulares");
    }
 
    public void aplaudir(){
        System.out.println("CLAP CLAP CLAP UHULL CLAP CLAP");
    }
 
    public void vaiar(){
        System.out.println("UUUUUU!! E FORA! E FORA! UUUUU!! ");
    }
}

public class Cantor implements Competidor {
 
    private Musica musica;
    private Plateia plateia;
 
    public Cantor() {
    }
 
    public void setMusica(Musica musica) {
        this.musica = musica;
    }
 
    public void setPlateia(Plateia plateia) {
        this.plateia = plateia;
    }
 
    public void apresentar() {
        plateia.sentar();
        plateia.desligarCelulares();
 
        try {
            musica.cantar();
            plateia.aplaudir();
        } catch (Exception e) {
            plateia.vaiar();
        }
    }
}

OBS: A platéia estaria sendo injetada na classe Cantor pelo container assim como está acontecendo com a musica.

Sem a orientação a aspectos, toda classe que implemente a interface Competidor tem que ficar se preocupando com a platéia. Não é certo o competidor ficar mostrando os assentos para a platéia, pedir para elas desligarem os celulares, se apresentar e por fim pedir para eles aplaudirem ou vaiarem. Isso é coisa que a platéia tem que fazer sozinha!

Vamos utilizar todo o poder da orientação a aspectos para que a platéia consiga fazer isso sozinha. A classe Cantor volta a ser o que era antes, se preocupando somente em cantar a sua musica:

public class Cantor implements Competidor {
 
    private Musica musica;
 
    public Cantor() {
    }
 
    public void setMusica(Musica musica) {
        this.musica = musica;
    }
 
    public void apresentar() {
        musica.cantar();
    }
}

E a classe Plateia vai ser “anotada” para utilizar as funcionalidades da orientação a aspectos:

@Aspect
public class Plateia {
 
    public Plateia() { }
 
    @Pointcut("execution(* *.apresentar(..))")
    public void apresentacao() {}
 
    @Before("apresentacao()")
    public void sentar(){
        System.out.println("A platéia está sentando");
    }
 
    @Before("apresentacao()")
    public void desligarCelulares(){
        System.out.println("A platéia está desligando os celulares");
    }
 
    @AfterReturning("apresentacao()")
    public void aplaudir(){
        System.out.println("CLAP CLAP CLAP UHULL CLAP CLAP");
    }
 
    @AfterThrowing("apresentacao()")
    public void vaiar(){
        System.out.println("UUUUUU!! E FORA! E FORA! UUUUU!! ");
    }
}

Aconteceram algumas coisas aqui:

-> Primeiro de tudo, a classe foi anotada com a anotação @Aspect indicando o óbvio: esta classe será um aspecto;

-> Depois foi criado um método que não faz absolutamente nada chamado apresentacao() cujo único propósito deste método é ser anotado para se “tornar” um pointcut (“tornar” entre aspas porque apresentar() continua sendo um método que não faz nada, apenas contém uma anotação que é um pointcut).
O parâmetro passado para a anotação @Pointcut é uma frase na linguagem de descrição de pointcuts do AspectJ. Segue uma pequena explicação dela (que eu acabei de fazer no Paint!! hehehe):

-> Depois que o pointcut está definido, basta anotar os métodos desejados especificando quando e onde eles devem ser executados. Para especificar onde os métodos serão executados é utilizado o nome do método que está anotado com o pointcut (no nosso exemplo é a string “apresentacao()”) e para especificar quando existem algumas outras anotações. Creio que as mais utilizadas são: @Before, @AfterReturning e @AfterThrowing (caso queira saber quais são as outras, fique a vontade para fuçar na documentação).

E voilá, nosso aspecto está pronto! Para ele funcionar só falta mais uma coisinha, que não é tão pequena assim (pelo menos na teoria, na prática é sim! ).

Para a orientação a aspectos funcionar devem ser criadas cópias dos objetos que queremos interceptar. Tais cópias contém os advices (códigos das cross-cut concerns) e esse objeto é que recebe as requisições, executa os advices e depois passa a requisição para o método do objeto original. Essas cópias de objetos que contém os advices são chamados de Proxy (no plural: Proxies).

E até algumas versões atrás os proxies tinham que ser criados na mão!!! Imagine que trabalho que dava… Porém o Spring provê um mecanismo automático para a criação dos proxies (ufa!).

Segue o arquivo de configuração para podermos fazer nosso exemplo funcionar:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans" 
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
 
       <!-- competidores -->
       <bean id="atireiopau" class="orientacaoaspectos.AtireiOPauNoGato" />
       <bean id="jose" class="orientacaoaspectos.Cantor">
           <property name="musica" ref="atireiopau" />
       </bean>
 
       <bean id="ciranda" class="orientacaoaspectos.CirandaCirandinha" />
       <bean id="gaita" class="orientacaoaspectos.Gaita" />
 
       <bean id="piano" class="orientacaoaspectos.Piano" />
       <bean id="carlos" class="orientacaoaspectos.CantorTocador">
           <property name="musica" ref="atireiopau" />
           <property name="instrumento" ref="piano" />
       </bean>
 
       <!-- platéia -->
       <bean class="orientacaoaspectos.Plateia" />
       <aop:aspectj-autoproxy />
</beans>

Três coisas novas apareceram no arquivo de configuração:

1 – Na root tag () foi definido mais um namespace (xmlns:aop) e na localização dos esquemas estão os seus respectivos links. Isso é necessário para o arquivo de configuração saber quais tags podem e quais não podem quando o assunto é AOP;

2 – Foi declarado o bean correspondente à platéia. Ele não tem o atributo id definido porque provavelmente nós nunca precisaremos de uma referência à platéia, eles fazem tudo sozinhos! Não tem porque darmos um id para a platéia sendo que nunca iremos utilizá-la;

3 – A simples tag “< aop:aspectj-autoproxy />” já diz para o Spring fazer todo o trabalho duro de ficar criando os proxies para nós.

E é isso caro leitor(a) (será que mulher le isso? to brincando!! hehehe), agora é só compilar (in the java-way of course), pedir pra tia VM executar e ver a platéia trabalhando sozinha, que povo educado!

Saindo da historinha e voltando ao mundo real, é extremamente fácil prover um mecanismo de log simples e que pode sofrer modificações facilmente utilizando a programação orientada a aspectos. Suponha que sua aplicação utilize o mecanismo padrão de log do Java e queira mudar para o Log4J: simples! Basta ir no seu aspecto responsável pelo log, e alterar os códigos. Você só tem trabalho uma vez (e nem é tanto trabalho assim)!

Nos próximos posts veremos os mecanismos que o Spring provê para banco de dados, transações, segurança, e mais alguns. Tão fácil quanto um System.out.println(“Hello World”).

Quem quiser o código do projeto, está aqui.

[]s e até a próxima,
Saab.

Durante esta série de tutoriais eu vou demonstrar o que é, pra que server e como vc pode utilizar o Spring para facilitar seus projetos.

Primeiramente, o que é esse tal de Spring afinal de contas? Spring é um framework que propicia um container para sua aplicação, ou seja, sua aplicação roda em cima do container do Spring. Tal container provê principalmente a Injeção de Dependência (ou Inversão de Controle, como era conhecido anteriormente) e a Programação Orientada a Aspectos.

Nesta primeira parte eu vou falar sobre o padrão Injeção de Dependência e os benefícios que ele provê. Vamos lá então:

O padrão de projeto Injeção de Dependência diz que uma classe não deve criar as suas dependências, em outras palavras, uma classe não deve instanciar seus atributos. Ao invés disso, eles devem ser injetados na classe através de um mecanismo externo, ou através de quem criou o objeto desta classe.

Ainda não está claro né… Vamos a um exemplo (baseado em um dos exemplos do livro Spring in Action 2, 2008) para facilitar as coisas.

Vamos imaginar que fomos contratados para desenvolver o software do Ídolos Spring?, uma competição de talentos musicais onde as pessoas cantam e/ou tocam. Primeiro de tudo vamos desenvolver uma interface genérica o suficiente para todos os nossos competidores:

public interface Competidor
    public void apresentar();
}

Pronto, agora todo mundo que for competir no Ídolos Spring vai ter que implementar essa interface para poder participar (é quase como se fosse a inscrição da competição… hahahahah péssima analogia.. ).

Vamos então aos competidores, vamos começar com um cantor. Um cantor não toca nenhum instrumento musical, ele apenas canta uma música. Vamos então à interface que descreve uma música:

public interface Musica
    public void cantar();
}

Baseado na interface, já podemos criar uma música:

public class AtireiOPauNoGato implements Musica {
 
    private static String[] letra = {
        "Atirei o páu no gato tô tô",
        "Mas o gato tô tô",
        "Não morreu reu reu",
        "Dona Chica cá",
        "Admirou-se se",
        "Do berro, do berro que o gato deu",
        "Miau !!!!!!"};
 
    public void cantar() {
        for (int i = 0; i < letra.length; i++) {
            System.out.println(letra[i]);
        }
    }
}

Legal, alguém vai cantar a famosa cantiga Atirei o pau no gato. Vamos codificar o cantor que irá fazer isso então:

public class Cantor implements Competidor {
 
    private Musica musica;
 
    public Cantor() {
        this.musica = new AtireiOPauNoGato();
    }
 
    public void apresentar() {
        musica.cantar();
    }
 
}

Prontinho. Agora toda vez que um cantor for se apresentar ele irá cantar Atirei o Pau no Gato. Mas pera ai, tem alguma coisa que não faz muito sentido aqui não tem?

Será que TODO cantor da nossa competição vai cantar a mesma música? Acho que não né… E do jeito que esta classe está implementada, nós temos que mudar a classe para ele cantar uma outra musica. Isso não é lá muito viável…

O que a Injeção de Dependência prega é que ao invés de o cantor se preocupar em ficar preparando a música que ele vai cantar, ele apenas vai receber a música impressa um pouco antes da competição e pronto.

Pensando nisso, o cantor ficaria assim:

public class Cantor implements Competidor {
 
    private Musica musica;
 
    public Cantor() {
    }
 
    public void setMusica(Musica musica) {
        this.musica = musica;
    }
 
    public void apresentar() {
        musica.cantar();
    }
}

Pronto, o cantor já não está mais preparando a sua música, pouco antes da apresentação ele vai receber a música (através do setter) e vai cantá-la (porque quem é bom faz ao vivo! hehehe).

Ok ok, até aqui não teve absolutamente NADA do tal do Spring, e vc provavelmente ainda não entendeu o porque desse monte de interfaces que parecem bobas não é mesmo?…

Vamos lá, advinhem quem vai dar a musica para o cantor? EXATO!! O container do Spring é quem vai ser responsável por entregar a música para o nosso cantor, ou em termos mais técnicos, o container é quem faz toda a linkagem dos beans (cada objeto manipulado pelo container é um bean, ex: uma musica, um cantor, um objeto que acessa o banco de dados, etc).

Para nós vermos como isso tudo funciona (pq ngm gosta de bla bla bla), vou abrir o NetBeans 6.8, criar uma nova Aplicação Java e criar as interfaces e classes descritas até aqui.

O NetBeans já traz as bibliotecas do Spring Framework junto com a IDE, o que te economiza um tempinho baixando-as. Clique com o botão direito na pasta Bibliotecas e cliquem “Adicionar bliblioteca…” e adicione a biblioteca “Spring Framework 2.5″

Uma vez que o Spring já está no classpath nós já podemos criar um arquivo de configuração para descrever os beans da nossa aplicação. Toda a configuração do container é feita através de arquivos XML.

Sendo assim eu criei mais um pacote (conf) e criei o arquivo idolos.xml dentro dele, este será o arquivo que o Spring irá utilizar para o container da nossa aplicação.

A tag root dos arquivos de configuração do Spring é a tag <beans> que define os namespaces e os DTDs necessários. De começo deixe o arquivo assim:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
</beans>

Essa é a estrutura básica de um arquivo de configuração (não se assuste com o tamanho dessa tag, vc não precisa decorar essas coisas).

Já que nossas classes estão prontas, vamos para o nosso primeiro competidor: José. O José vai cantar Atirei o Pau no Gato. Para declará-lo e dar a música pra ele vai ficar assim:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
       <bean id="atireiopau" class="injecaodependencia.AtireiOPauNoGato" />
 
       <bean id="jose" class="injecaodependencia.Cantor">
           <property name="musica" ref="atireiopau" />
       </bean>
 
</beans>

Aqui é que o Spring começa a trabalhar, cada tag no arquivo de configuração representa um objeto que o container irá gerenciar. No nosso exemplo, temos o bean “atireiopau” que é um objeto da classe AtireiOPauNoGato e o bean “jose” que eh um Cantor e vai cantar a música referenciada pelo bean “atireiopau”.

Em termos de código, seria como se o container fizesse o seguinte:

injecaodependencia.AtireiOPauNoGato atireiopau = new injecaodependencia.AtireiOPauNoGato();
injecaodependencia.Cantor jose = new injecaodependencia.Cantor();
jose.setMusica(atireiopau);

Essa é a mágica da Injeção de Dependência, o José teve a música “injetada” nele, se a gente quiser que ele cante outra música não precisamos reescrever a classe Cantor, apenas injetar uma música diferente nele.

Isso torna a aplicação muito mais desacoplada, muito mais fácil de testar e de reusar os módulos!!!

Mas e para usar isso agora? Como que a gente põe isso pra funcionar? Eu quero ver o José cantar!!!! hehehe

Vamos lá então, vamos ao código da classe principal do nosso exemplo:

public class Main {
 
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/idolos.xml");
 
        Competidor competidor = (Competidor) ctx.getBean("jose");
 
        competidor.apresentar();
    }
 
}

A interface ApplicationContext é justamente o container (um dos existentes) do Spring Framework. Existe também a BeanFactory mas essa é bem mais simples e eu não irei comentá-la.

O que acontece nesse código então é o seguinte: é criado o container passando o arquivo de configuração que ele irá utilizar, depois é recuperado o bean “jose” do container (nesse momento o container instancia o bean e todas as suas dependências) e por fim, nós pedimos pro José se apresentar.

Você deverá ver ele cantando incrivelmente bem o clássico Atirei o Pau no Gato.

Porém o próximo competidor promete! Ele irá cantar E tocar Ciranda Cirandinha com uma gaita!! Essa eu quero ver!!

Vamos às classes necessárias para o próximo competidor:

public class CirandaCirandinha implements Musica {
 
    private static String[] letra = {
        "Ciranda , cirandinha,",
        "Vamos todos cirandar,",
        "Vamos dar a meia volta,",
        "Volta e meia vamos dar",
        "",
        "O anel que tu me destes,",
        "Era vidro",
        "E se quebrou.",
        "O amor que tu me tinhas",
        "Era pouco e se acabou.",
        "",
        "Ciranda , cirandinha,",
        "Vamos todos cirandar,",
        "Vamos dar a meia volta,",
        "Volta e meia vamos dar"};
 
    public void cantar() {
        for (int i = 0; i < letra.length; i++) {
            System.out.println(letra[i]);
        }
    }
}

public interface Instrumento {
    public void tocar();
}

public class Gaita implements Instrumento {
    public void tocar() {
        System.out.println("FUU FUU FII FII");
    }
}

public class CantorTocador extends Cantor {
 
    private Instrumento instrumento;
 
    public CantorTocador() {
        super();
    }
 
    public void setInstrumento(Instrumento instrumento) {
        this.instrumento = instrumento;
    }
 
    public void apresentar() {
        instrumento.tocar();
        super.apresentar();
        instrumento.tocar();
    }
 
}

Pronto, agora nosso próximo competidor está pronto para se apresentar. Sras e Srs dêem as boas vindas para Carlos:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
       <bean id="atireiopau" class="injecaodependencia.AtireiOPauNoGato" />
       <bean id="jose" class="injecaodependencia.Cantor">
           <property name="musica" ref="atireiopau" />
       </bean>
 
       <bean id="ciranda" class="injecaodependencia.CirandaCirandinha" />
       <bean id="gaita" class="injecaodependencia.Gaita" />
       <bean id="carlos" class="injecaodependencia.CantorTocador">
           <property name="musica" ref="ciranda" />
           <property name="instrumento" ref="gaita" />
       </bean>
 
</beans>

Agora basta chamar o Carlos para se apresentar ao invés do José:

public class Main {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("conf/idolos.xml");
 
        Competidor competidor = (Competidor) ctx.getBean("carlos");
 
        competidor.apresentar();
    }
}

E se a gente quisesse que o Carlos tocasse piano cantando Atirei o Pau no Gato? Simples:

public class Piano implements Instrumento {
    public void tocar() {
        System.out.println("PLIN PLIN PLIN");
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-2.0.xsd">
 
       <bean id="atireiopau" class="injecaodependencia.AtireiOPauNoGato" />
       <bean id="jose" class="injecaodependencia.Cantor">
           <property name="musica" ref="atireiopau" />
       </bean>
 
       <bean id="ciranda" class="injecaodependencia.CirandaCirandinha" />
       <bean id="gaita" class="injecaodependencia.Gaita" />
 
       <bean id="piano" class="injecaodependencia.Piano" />
       <bean id="carlos" class="injecaodependencia.CantorTocador">
           <property name="musica" ref="atireiopau" />
           <property name="instrumento" ref="piano" />
       </bean>
 
</beans>

Basta “injetar” os beans desejados nas dependências e boa! Tudo segue seu fluxo natural.

Esta foi uma pequena (eu diria mínima) introdução à Injeção de Dependências no Spring Framework. O container ApplicationContext possui muuuuuito mais funções para gerenciar os seus beans, porém isso iria extender demais este assunto.

Acho que se você leu o post até aqui, vc conseguiu pegar o que eu quis passar: programar utilizando interfaces torna o seu código muito mais limpo, fácil de entender, fácil de dar manutenção, fácil de reutilizar, fácil de extender, ou seja, melhora tudo!!

Adicionando isso com a técnica de Injeção de Dependência torna a aplicação altamente desacoplada em termos de componentes (você pode utilizar a classe Cantor em qualquer outra aplicação, só precisa passar uma classe que implemente a interface Musica pra ele e tudo vai funcionar perfeitamente).

Os códigos fontes utilizados neste tutorial estão aqui.

[]s e até a próxima,
Saab.

Dito isso, vamos  ao assunto de hoje: ‘DefaultTableModel e o porque de não utilizá-la’.

Quem já programou utilizando a API Swing e nunca utilizou a JTable que atire a primeira pedra.

Agora, quem já usou JTable e nunca utilizou a DefaultTableModel pode atirar pedras a vontade!

Aqui no blog mesmo… Eu já utilizei DefaultTabelModel em alguns posts. Mas pois bem, vamos abolir essa má prática. Seguem alguns motivos do porque não devemos utilizar a DefaultTableModel:

1. É mais difícil que escrever seu próprio TableModel;
2. É mais lento (usa classes sincronizadas);
3. Ocupa mais espaço em memória (duplica seus dados);
4. Deixa o código mais confuso e difícil de manter;
5. Usa casts inseguros;
6. Força que você tenha que exibir informações desnecessárias (como o ID) na tabela, ou controlar o ID numa lista separada;
7. Faz a sua mulher te deixar, o leite da sua geladeira azedar, e pessoas apontarem o dedo para você na rua.

Motivos muito bem explicados pelo ViniGodoy neste post do GUJ.

Mas se a DefaultTableModel é tão ruim assim, o que devemos fazer? Tudo se resume a uma classe: AbstractTableModel.

Tudo o que temos que fazer é criar uma nova classe que extenda AbstractTableModel e customizá-la para exibir os dados que queremos. Concordo que em um primeiro momento vai parecer meio desnecessário escrever uma classe para cada tabela do seu sistema (ou uma genérica), mas isso compensa muito na hora de utilizá-la, e compensa mais ainda na hora de reutilizá-la (o famoso reuso da orientação a objetos).

Mas chega de conversa, vamos a prática pois é o melhor jeito de fixar as coisas…

Nosso escopo será o seguinte: uma loja qualquer quer controlar seu estoque. Em algum lugar dentro do software que realizará esta tarefa vai ter uma tela de consulta dos produtos e suas respectivas quantidades disponíveis em estoque.

É nessa tela que nosso tutorial irá decorrer. Uma tela de consulta de produtos com alguns botões só para demonstrar o funcionamento do nosso modelo.

Abra o NetBeans, crie um novo projeto para área de trabalho, apague tudo que ele cria, crie um novo pacote, crie um novo JFrame dentro dele e deixe parecido com este:

O JFrame contém os seguintes componentes:

• 1 JTable (que já vem dentro do seu JScrollPane)
• 5 JButtons

Os textos dos botões já explicam qual será a função de cada um deles certo?

Agora vamos a nossa classe base (da camada de modelo) que vai representar os produtos do nosso controle de estoque. Segue a classe Produto.java:

public class Produto {
 
    private int cod;
    private String nome;
    private int quant;
 
    public Produto() {
    }
 
    public Produto(int cod, String nome, int quant) {
        this.cod = cod;
        this.nome = nome;
        this.quant = quant;
    }
 
    public int getCod() {
        return cod;
    }
 
    public void setCod(int cod) {
        this.cod = cod;
    }
 
    public String getNome() {
        return nome;
    }
 
    public void setNome(String nome) {
        this.nome = nome;
    }
 
    public int getQuant() {
        return quant;
    }
 
    public void setQuant(int quant) {
        this.quant = quant;
    }
}

Uma simples classe para representar um produto. Coloquei o código também porque geralmente sempre precisamos controlar o código dos registros que estão sendo apresentados na tabela. Utilizando DefaultTableModel nós deveríamos ter uma lista separada para poder controlar esses códigos. Mais a frente veremos como seria com nosso novo modelo para a tabela.

Vamos agora para a parte que importa: criar uma classe que herde de AbstractTableModel. A classe AbstractTableModel define alguns métodos que nós podemos reescrever para criar um modelo bem mais fácil de trabalhar. Seguem os métodos, que iremos utilizar neste exemplo, e suas respectivas funções:

• int getRowCount() -> retorna o número de linhas que a tabela tem;
• int getColumnCount() -> retorna o número de colunas que a tabela tem;
• String getColumnName(int column)-> retorna o nome que será exibido na coluna (o índice da primeira coluna é 0);
• Class<?> getColumnClass(int columnIndex) -> retorna a classe que representa cada coluna. String irá mostrar o texto alinhado à esquerda, Integer irá mostrar o número alinhado à direita, Boolean irá mostrar um checkbox… ;
• Object getValueAt(int rowIndex, int columnIndex) -> método utilizado pela JTable para escrever os valores nas células. Internamente a JTable passa em todas as celulas chamando este método para poder setar os valores;
• ??void setValueAt(Object aValue, int rowIndex, int columnIndex) -> método que a JTable chama quando uma célula é editada;
• boolean isCellEditable(int rowIndex, int columnIndex) -> método para saber se a célula é ou não editável;
• void fireTableDataChanged() -> método que avisa todos os listeners da tabela que houve uma mudança nos dados, um deles é o responsável por desenhar a tabela e ao ser notificado irá redesenhá-la.

Ok, agora que já conhecemos alguns dos métodos que a AbstractTableModel fornece, vamos reescrevê-los. Segue o código do arquivo ProdutoTableModel.java:

public class ProdutoTableModel extends AbstractTableModel {
 
    //constantes que vão representar as colunas
    //(só para facilitar o entendimento do código)
    private final int COL_NOME = 0;
    private final int COL_QUANT = 1;
 
    //lista dos produtos que serão exibidos
    private List produtos;
 
    public ProdutoTableModel() {
        produtos = new ArrayList();
    }
 
    public ProdutoTableModel(List lista) {
        this();
        produtos.addAll(lista);
    }
 
    public int getRowCount() {
        //cada produto na lista será uma linha
        return produtos.size();
    }
 
    public int getColumnCount() {
        //vamos exibir só Nome e Quantidade, então são 2 colunas
        return 2;
    }
 
    @Override
    public String getColumnName(int column) {
        //qual o nome da coluna
        if (column == COL_NOME) {
            return "Nome";
        } else if (column == COL_QUANT) {
            return "Quant. Disp";
        }
        return "";
    }
 
    @Override
    public Class getColumnClass(int columnIndex) {
        //retorna a classe que representa a coluna
        if (columnIndex == COL_NOME) {
            return String.class;
        } else if (columnIndex == COL_QUANT) {
            return Integer.class;
        }
        return String.class;
    }
 
    public Object getValueAt(int rowIndex, int columnIndex) {
        //pega o produto da linha
        Produto p = produtos.get(rowIndex);
 
        //verifica qual valor deve ser retornado
        if (columnIndex == COL_NOME) {
            return p.getNome();
        } else if (columnIndex == COL_QUANT) {
            return p.getQuant();
        }
        return "";
    }
 
    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        //pega o produto da linha
        Produto p = produtos.get(rowIndex);
 
        //verifica qual valor vai ser alterado
        if (columnIndex == COL_NOME) {
            p.setNome(aValue.toString());
        } else if (columnIndex == COL_QUANT) {
            p.setQuant(Integer.parseInt(aValue.toString()));
        }
 
        //avisa que os dados mudaram
        fireTableDataChanged();
    }
 
    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        //no nosso caso todas vão ser editáveis, entao retorna true pra todas
        return true;
    }

Até agora eu só reescrevi os métodos que foram citados anteriormente. Agora nós vamos à parte produtiva da coisa: vamos escrever os métodos para inserir um novo produto, para remover produtos, para ordená-los e para embaralhá-los, ou seja, vamos dar vida aos nossos botões e o melhor: ver como isso é muito fácil!

Mais alguns métodos para a nossa classe ProdutoTableModel.java:

    public void inserir(Produto p) {
        produtos.add(p);
 
        fireTableDataChanged();
    }
 
    public void excluir(int pos) {
        produtos.remove(pos);
 
        fireTableDataChanged();
    }
 
    public void excluir(Produto p) {
        produtos.remove(p);
 
        fireTableDataChanged();
    }
 
    public void ordenarPorNome() {
        //ordena pelo nome
        Collections.sort(produtos, new Comparator() {
 
            public int compare(Produto o1, Produto o2) {
                return o1.getNome().compareTo(o2.getNome());
            }
        });
 
        //avisa que a tabela foi alterada
        fireTableDataChanged();
    }
 
    public void ordenarPorQuantidade() {
        //ordena pelo nome
        Collections.sort(produtos, new Comparator() {
 
            public int compare(Produto o1, Produto o2) {
                return o1.getQuant() - o2.getQuant();
            }
        });
 
        //avisa que a tabela foi alterada
        fireTableDataChanged();
    }
 
    public void misturar() {
        //mistura a lista
        Collections.shuffle(produtos);
 
        //avisa que a tabela foi alterada
        fireTableDataChanged();
    }
 
    public Produto getCliente(int pos) {
        if (pos < 0 || pos >= produtos.size()) {
            return null;
        }
 
        return produtos.get(pos);
    }

Pronto! Veja como é fácil manipular os dados da tabela agora. Basta manipular uma lista!

Acho que os únicos métodos que merecem alguma explicação são os de ordenação, onde, em cada um deles é criado um objeto Comparator que ordena de acordo com a necessidade: se é por ordem alfabética dos nomes, compara os nomes, se é pela quantidade em estoque, compara as quantidades.

OBS: Lembre sempre de chamar o método fireTableDataChanged() para avisar que os dados mudaram e a tabela ser redesenahda.

Voltando para aquela ideia de que esta tela seria uma tela de busca… possívelmente ela poderia ser chamada de uma outra tela (a de entrada de produtos por exemplo) para facilitar a busca de um produto. Como seria a recuperação do código do produto selecionado na tabela? Mais ou menos assim:

public class BuscaProdutos extends JDialog {
 
    //....
 
    public Produto retornaProdutoSelecionado() {
        ProdutoTableModel model = (ProdutoTableModel) jT_TabelaProdutos.getModel();
        return model.getCliente(jT_TabelaProdutos.getSelectedRow());
    }
 
    //...
}
 
public class EntradaProdutos extends JDialog {
 
    //...
 
    public void buscaProduto() {
        //cria a tela de busca como modal
        BuscaProdutos tela_busca = new BuscaProdutos(null, true);
 
        //exibe
        tela_busca.setVisible(true);
 
        //recupera os dados
        Produto p = tela_busca.retornaProdutoSelecionado();
 
        if (p != null) {
            jTF_Codigo.setText(String.valueOf(p.getCod()));
            jTF_Nome.setText(p.getNome());
            jTF_Quantidade.setText(String.valueOf(p.getQuant()));
        }
    }
    //...
}

A tabela ficaria na tela de busca. Tal tela seria chamada como modal (só ela poderia ter o foco enquanto estivesse visível) e quando se tornasse invisível, o produto selecionado seria recuperado e usado como necessário.

Quanto trabalho não seria necessário para fazer isso utilizando a DefaultTableModel?

Voltando à nossa aplicação inicial, ainda temos que linkar os botões com as funções do modelo. Vamos ao código da classe Principal.java (JFrame da foto lá em cima):

public class Principal extends JFrame {
 
    private ProdutoTableModel model;
 
    //variável só para controlar os códigos dos produtos
    private int ultimoCod;
 
    public Principal() {
        initComponents();
        ultimoCod = 1;
 
        //cria a lista com os produtos
        ArrayList<Produto> lista = new ArrayList<Produto>();
        lista.add(new Produto(ultimoCod++,"Lapiseira 0.7",30));
        lista.add(new Produto(ultimoCod++,"Caneta preta",100));
        lista.add(new Produto(ultimoCod++,"Caneta azul",70));
        lista.add(new Produto(ultimoCod++,"Caneta vermelha",100));
 
        //cria o modelo de Produto
        model = new ProdutoTableModel(lista);
 
        //atribui o modelo à tabela
        jTable1.setModel(model);
    }
 
    //Ação do botão Inserir
    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        Random r = new Random();
        Produto p = new Produto(ultimoCod++, "Produto "+String.valueOf(r.nextInt(100)), r.nextInt(1000));
        model.inserir(p);
    }
 
    //Ação do botão Excluir
    private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        int selecionados[] = jTable1.getSelectedRows();
        if (selecionados.length > 0){
            ArrayList<Produto> seraoExcluidos = new ArrayList<Produto>();
 
            for (int i=0; i<selecionados.length; i++)
                seraoExcluidos.add(model.getCliente(selecionados[i]));
 
            for (Produto p : seraoExcluidos)
                model.excluir(p);            
        }else{
            JOptionPane.showMessageDialog(this, "Selecione alguém neh...");
        }
    }                                        
 
    //Ação do botão Ordenar por Quantidade
    private void jButton5ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        model.ordenarPorQuantidade();
    }                  
 
    //Ação do botão Ordenar por Nome
    private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        model.ordenarPorNome();
    }                                        
 
    //Ação do botão Misturar
    private void jButton4ActionPerformed(java.awt.event.ActionEvent evt) {                                         
        model.misturar();
    }
 
    /...
}

No construtor é criada uma lista com alguns produtos fictícios e também é instanciado o nosso TableModel.

O botão inserir insere um produto com o nome “Produto i” e quantidade Q, onde ‘i’ e ‘Q’ são números randômicos.

O botão excluir trata a exclusão de vários ítens selecionados ao mesmo tempo. Primeiro todos são guardados em uma lista auxiliar e depois eles vão sendo excluídos um a um (Você sabe por que eu fiz assim? Pense um pouco… qualquer coisa a área de comentários está logo abaixo).

Os botões Ordenar por Nome, Ordenar por Quantidade e Misturar são auto explicativos e fazem exatamente o que o seu nome quer dizer.

Bom, chegamos ao fim de mais um artigo aqui do Java Simples. E fica meu conselho: pare de usar DefaultTableModel e começe agora mesmo a escrever suas próprias TableModels.

O código fonte do projeto está disponível aqui! E se achou interessante compartilhe este artigo utilizando a barra social logo abaixo. =]

[]s e até a próxima,
Saab.

Em um resumo bem grosso, isso é um web service. Um programa que executa um método e devolve a resposta pra outro programa que pediu.

Por que eles são tão famosos? Uma das vantagens é a independência de linguagem, ou seja, um web service implementado em Java pode muito bem ser consumido (termo comum quando se fala em web services, equivalente a “usar”) por um outro software implementado em C# ou Python ou qualquer outra linguagem, pois o XML é adotado para garantir a comunicação padronizada.

Existem alguns tipos diferentes de web services onde, dentre eles, os que utilizam SOAP/ WSDL e os baseados no modelo arquitetural REST são os mais conhecidos. Neste post eu irei explicar como criar e consumir web services que utilizam SOAP e WSDL, e irei assumir que você já tenha pelo menos uma ideia do que estas siglas significam.

Eu poderia escrever uns dois ou três posts só sobre a teoria e aplicações, mas ficaria meio chato… Como o legal é a prática, vamos imaginar uma situação problema e criar um web service para resolver esse problema.

Vamos imaginar o seguinte cenário: um jornal quer disponibilizar um serviço para distribuir notícias pela internet. Sendo assim as pessoas podem colocar informações confiáveis no seu site, e toda vez que o pessoal da redação adicionar uma nova notícia, ela aparece em todos os sites que consomem o serviço.

Com esse cenário em mente, vamos ao Java. Estou utilizando o NetBeans 6.8 que tem uns assistentes bem legais para usar web services.

Vamos criar um novo projeto Web que será o nosso web service. Eu dei o nome de WSNoticias e como container escolhi o Tomcat 6.0.20.

Agora vamos criar o Web Service propriamente dito. Botão direito no projeto, Novo, Outro. Selecione a categoria Serviços Web e depois selecione Serviço Web.

Dei o nome de ‘ServicoNoticias’ para o serviço e para o pacote dei o nome ‘ws’.

O NetBeans já cria a classe que será nosso serviço web. Vamos agora pensar em quais métodos estarão disponíveis para as pessoas utilizarem.

No nosso caso (jornal, notícias, …), o web service terá apenas um método chamado “recuperaNoticias()” que retorna uma lista de objetos “Noticia”. A partir dai a aplicação que recuperar essa lista irá exibí-la da maneira que achar melhor.

Vamos então ao código da classe Noticia (dentro do pacote ‘modelo’):

public class Noticia {
 
    private String titulo;
    private String texto;
 
    public Noticia() {
    }
 
    public Noticia(String titulo, String texto) {
        this.titulo = titulo;
        this.texto = texto;
    }
 
    public String getTexto() {
        return texto;
    }
 
    public void setTexto(String texto) {
        this.texto = texto;
    }
 
    public String getTitulo() {
        return titulo;
    }
 
    public void setTitulo(String titulo) {
        this.titulo = titulo;
    }
}

Apenas uma simples classe que vai representar as notícias, nada de mais.

Agora vamos para a classe do web service de novo e vamos adicionar uma nova operaçao. Abra a classe do web service. Na parte de cima do editor de texto do NetBeans vai ter duas opções: “Código Fonte” e “Projeto”. Selecione Projeto e clique em “Adicionar operação…”.

Como a nossa operação é bem simples, vai apenas retornar as notícias, só precisamos definir o nome e o tipo de retorno. Aqui o tipo deve ser sempre totalmente qualificado, ou seja, o nome do pacote que ele está e o nome da classe.

Voltado pra exibição do código fonte, o NetBeans já criou o método. Vamos ao código dele:

@WebMethod(operationName = "recuperaNoticias")
    public java.util.ArrayList recuperaNoticias() {
        ArrayList lista = new ArrayList();
 
        lista.add(new Noticia("Noticia1","Descrição da notícia 1"));
        lista.add(new Noticia("Noticia2","Descrição da notícia 2"));
        lista.add(new Noticia("Noticia3","Descrição da notícia 3"));
        lista.add(new Noticia("Noticia4","Descrição da notícia 4"));
 
        return lista;
    }

Para não estender muito o post, não vou utilizar banco de dados, vamos apenas simular que o método retorne algumas notícias, mas o correto seria realizar a conexão e recuperar os dados de algum outro lugar.

Pronto! Esse é o nosso web service! Execute a aplicação e o NetBeans irá iniciar o Tomcat, irá fazer o deploy da aplicação e irá abrir o browser no caminho do Web Service.

Apareceu esse Heelo World! porque a página index.html não foi alterada, mas tudo bem, a interface gráfica não interessa, o que interessa é que o web service já está rodando no container, já está esperando por requisições. Tudo o que temos que fazer é criar um software que consuma esse web service.

A URL do WSDL do web service é: http://localhost:8084/WSNoticias/ServicoNoticias?wsdl

A URL do WSDL é sempre composta da seguinte maneira: http://<servidor>:<porta>/<nome_aplicacao>/<nome_web_service>?wsdl
Lembre-se do caminho do WSDL pois eh a partir dele que o cliente vai conseguir consumir o serviço.

Vamos criar agora um novo site que exiba as notícias então: crie uma nova Aplicação Web (eu chamei de WSNoticias_Cliente) e vamos criar as classes necessárias para consumir o serviço (quando eu digo nós, eu quero dizer: o NetBeans): botão direito no projeto e clique em Novo, Outro. Na categoria selecione “Serviços Web” e então “Cliente para serviço Web”.

Na próxima tela existem 3 opções para criar um cliente:

Projeto -> caso o projeto do NetBeans do web service esteja no mesmo computador, você pode importar as configurações dele apenas especificando qual é o projeto;

Arquivo Local -> caso você tenha o arquivo WSDL salvo localmente, basta apontá-lo;

WSDL URL -> para web services que você só sabe a URL do arquivo WSDL, basta informar a URL que o NetBeans vai buscar o arquivo.

No nosso caso, poderíamos utilizar a primeira opção, porém eu prefiro passar a URL do WSDL, fica a critério de cada um. E não esqueçam de por o nome de um pacote para os arquivos que serão gerados.

Se tudo der certo o NetBeans vai gerar alguns arquivos que vão possibilitar o nosso site consumir aquele web service.

Uma nova pasta será criada no projeto: “Códigos-fonte gerados (jax-ws)” e dentro dela está o pacote que contém os arquivos. Você pode fuçar a vontade para ver como as coisas acontecem, mas para este post só algumas classes são relevantes:

Noticia -> repare que todas as classes customizadas que o web service retorna ou recebe como parâmetro ou até mesmo classes de exceção são criadas para que possa haver uma comunicação correta;

ServicoNoticiasService -> essa classe é a responsável por criar a comunicação com o web service.

ServicoNoticias -> esta interface é que define quais são os métodos disponíveis pelo web service.

Eu vou fazer algo MUITO errado agora, que é utilizar scriptlets no JSP para controlar toda a lógica da minha aplicação, mas como é só para efeitos de demonstração, então tudo bem.

Segue o código da página index.html do projeto WSNoticias_Cliente:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
   "http://www.w3.org/TR/html4/loose.dtd">
<%@page import="ws.cliente.*" %>
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
        <title>Notícias</title>
    </head>
    <body>
        <%
            //cria a comunicação com o Web Service
            ServicoNoticiasService ws = new ServicoNoticiasService();
 
            //recupera uma classe que implemente a interface do nosso Web Service
            ServicoNoticias noticias = ws.getServicoNoticiasPort();
 
            //agora basta utilizar os métodos disponíveis pelo web service
            java.util.List<Noticia> lista = noticias.recuperaNoticias();
 
            //exibindo na pagina
            for (Noticia n : lista){
                out.print(n.getTitulo()+"<br>");
                out.print(n.getTexto()+"<hr>");
            }
        %>
    </body>
</html>

Os comentários no código explicam tudo o que está acontecendo: primeiro é feita a conexão com o web service, depois é recuperada uma classe que consegue executar os métodos do web service e dai pra frente basta chamar os métodos e utilizá-los.

O resultado foi este:

Bom, é isso ai.

Eu pessoalmente achei muito produtivo o NetBeans para a criação e consumação de Web Services, um jeito realmente muito simples.

Quem quiser pegar os projetos, estão aqui.

[]s e até a próxima,
Saab.

Afinal, o que é a serialização?

Serialização é a técnica que permite transformar objetos em bytes, e uma vez que eles são bytes, eles podem ser salvos em disco ou enviados através de um stream (via HTTP, via socket, entre outros).

Vou exemplificar apenas como salvar e recuperar os objetos no disco, uma vez que eu não estou muito acostumado com os sockets e enviar requisições HTTP iria extender muito o tópico.

No exemplo iremos utilizar a classe Tenis (não sei de onde eu tirei isso…).

Tenis.java

public class Tenis implements java.io.Serializable {
 
    private int tamanho;
    private String marca;
    private String modelo;
 
    public Tenis() {
    }
 
    public Tenis(int tamanho, String marca, String modelo) {
        this.tamanho = tamanho;
        this.marca = marca;
        this.modelo = modelo;
    }
 
    public String getMarca() {
        return marca;
    }
 
    public void setMarca(String marca) {
        this.marca = marca;
    }
 
    public String getModelo() {
        return modelo;
    }
 
    public void setModelo(String modelo) {
        this.modelo = modelo;
    }
 
    public int getTamanho() {
        return tamanho;
    }
 
    public void setTamanho(int tamanho) {
        this.tamanho = tamanho;
    }
 
    public String toString(){
        return this.marca + " " + this.modelo + " - Tamanho: " + String.valueOf(this.tamanho);
    }
}

OBS: todo objeto que você quer serializar deve OBRIGATORIAMENTE implementar a interface java.io.Serializable. Essa interface não possui nenhum método, é apenas uma indicação para a JVM saber que este objeto pode ser serializado.

Segue o código do programa principal do nosso exemplo:

public static void main(String[] args) {
 
	ArrayList<Tenis> listaTenis = new ArrayList<Tenis>();
	listaTenis.add(new Tenis(44, "Nike", "Shoks TL 2"));
	listaTenis.add(new Tenis(42, "Adidas", "Microbounce"));
 
	serializaListaTenis(listaTenis, "D:\\serializados.dat");
 
	ArrayList<Tenis> listaRecuperada = deserializaListaTenis("D:\\serializados.dat");
 
	for (Tenis t : listaRecuperada) {
		System.out.println(t);
	}
}

Uma lista de Tenis foi criada e foram adicionados dois objetos. Depois foi chamado um método serializaListaTenis que vai ser responsável por serializar a lista e salvá-la no arquivo informado no segundo parâmetro.
Logo depois é criada uma nova lista que recebe o retorno do método deserializaListaTenis cuja função é recuperar a lista do arquivo passado por parâmetro.
Por fim a lista que foi recuperada é percorrida e os objetos são exibidos no console.

Vamos ao método que serializa a lista então:

private static void serializaListaTenis(ArrayList<Tenis> listaTenis, String arquivo) {
	FileOutputStream arq = null;
	ObjectOutputStream out = null;
	try {
		//arquivo no qual os dados vao ser gravados
		arq = new FileOutputStream(arquivo);
 
		//objeto que vai escrever os dados
		out = new ObjectOutputStream(arq);
 
		//escreve todos os dados
		out.writeObject(listaTenis);
	} catch (IOException ex) {
		ex.printStackTrace();
	} finally {
		try {
			arq.close();
			out.close();
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}
}

Os comentários estão bem claros e o código é bem simples de entender. É definido um objeto que representa o arquivo no qual os dados vão ser gravados e um outro objeto que irá escrever os dados no arquivo. Por fim a lista é “escrita” no arquivo através do método writeObject do objeto ObjectOutputStream.

Não sei se você percebeu mas o que nós gravamos foi um objeto ArrayList que contém alguns objetos Tenis. Lembrando que para um objeto ser serializado ele deve implementar a interface Serializable, ou seja, a classe ArrayList deve implementar essa interface para poder ser gravada em disco também (e todos os objetos que a lista contém). Olhando na documentação da classe nós iremos encontrar:

A classe ArrayList já implementa a interface Serializable, por isso nós podemos guardar objetos ArrayList no disco (desde que todos os objetos que estejam na lista também implementem esta interface).

Vamos então ao método que recupera a lista do arquivo:

private static ArrayList<Tenis> deserializaListaTenis(String arquivo) {
	FileInputStream arqLeitura = null;
	ObjectInputStream in = null;
	ArrayList<Tenis> lista = null;
	try {
		//arquivo onde estao os dados serializados
		arqLeitura = new FileInputStream(arquivo);
 
		//objeto que vai ler os dados do arquivo
		in = new ObjectInputStream(arqLeitura);
 
		//recupera os dados
		lista = (ArrayList<Tenis>) in.readObject();
	} catch (ClassNotFoundException ex) {
		ex.printStackTrace();
	} catch (IOException ex) {
		ex.printStackTrace();
	} finally {
		try {
			arqLeitura.close();
			in.close();
		} catch (IOException ex) {
			ex.printStackTrace();
		}
	}
 
	return lista;
}

Assim como no método que serializa a lista, este também tem um objeto que representa o arquivo que vai ser lido e um objeto que lê os dados (deserializa). O código é completamente o inverso do outro: referencia o arquivo, cria um objeto que vai ler do arquivo, e recupera os dados.

Então é isso, serializar um objeto pode ser bem útil quando se precisa fazer algo rápido, algo que não compense o esforço de utilizar um banco de dados.

O projeto está disponível aqui. Sintam-se a vontade para baixar e testar.

[]s e até a próxima,
Saab.

Sempre tive a curiosidade de saber como funcionavam, então fui perguntar pro Google.
Pretendo demonstrar aqui o que eu aprendi nas minhas pesquisas.

Annotations são… advinhem… anotações! É um jeito que você tem de fazer alguma marcação em um atributo, método, classe, entre outros.

Elas sempre devem ser digitadas antes do objeto que você queira anotar (método, atributo…) e o nome das anotações são sempre precedidos de @ (arroba). Ex:

@MinhaAnotacao
class MinhaClasse{
}

Até ai tudo bem, mas você deve estar se perguntando: “Pra que diabos eu vou usar isso? Pra que ficar enfeitando meu código?”. Calma. Tudo tem seu propósito.

Para poder trabalhar com as anotações, iremos utilizar a reflexão computacional, portanto sugiro que você leitor, leia meus posts antigos sobre Reflexão Computacional:

Java e seus Espelhos: Reflexão Computacional e

Reflexão Computacional: Exemplo Prático

Daqui pra frente vou supor que você entende e sabe utilizar a reflexão computacional…

Exemplo 1: Testando seus métodos

Então vamos lá: imagine que você é um bom programador com uma ótima noção de engenharia de software (o que realmente deve ser verdade neh… ). Você sabe que uma fase importante no desenvolvimento de um software é a fase de testes. Porém você não gosta dos frameworks existentes para teste unitário (ou qualquer outro tipo), então você decide criar o seu próprio!

Para não ficar muito chato de utilizar, você decide que durante o desenvolvimento, todo método que possuir a anotação “@Testar” será testado pelo seu framework.

OK, com essa idéia na cabeça vamos criar a nossa anotação @Testar:

Testar.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface Testar { }

Reparem que a nossa anotação deve ser anotada com meta-anotações.

A anotação @Retention(RetentionPolicy.RUNTIME) diz que a VM deve manter essas anotações em tempo de execução para podermos ler elas através da reflexão. Outras opções seriam: SOURCE e CLASS.

E a anotação @Target(ElementType.METHOD) indica que a nossa anotação só é aplicada a métodos. Outras opções seriam: FIELD, TYPE (classe e interface), PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, e PACKAGE.

Reparem que para declarar a nossa própria anotação, deve-se utilizar “@interface” antes do nome da anotação.

Pronto! Só isso! É assim que as anotações são criadas. Uma vez que já temos ela, vamos criar a classe que irá ser testada.

ClasseParaTestar.java

public class ClasseParaTestar {
 
    @Testar
    public void metodo1() {
        throw new RuntimeException("Deu zebra!");
    }
 
    @Testar
    public void metodo2() {
    }
 
    @Testar
    public void metodo3() {
    }
 
    public void metodo4() {
    }
 
    @Testar
    public void metodo5() {
        throw new RuntimeException("Ixi maria... Erro!");
    }
 
    public void metodo6() {
    }
 
    @Testar
    public void metodo7() {
    }
 
    public void metodo8() {
    }
}

Como o propósito é só demonstrar as anotações, os métodos não fazem nada.

Beleza, agora os métodos que eu quero testar já estão “anotados”. Vamos criar a classe principal do nosso framework de testes.

Testador.java

public class Testador {
 
    public static void testar(Object obj) {
        Class<?> classe = obj.getClass();
        int passou = 0;
        int falhou = 0;
 
        System.out.println("-------------Inicio dos Testes--------------");
        for (Method m : classe.getDeclaredMethods()) {
            if (m.isAnnotationPresent(Testar.class)) {
                try {
                    System.out.print("Testando o método: "; + m.getName());
                    m.invoke(obj);
                    passou++;
                    System.out.println(" => passou!");
                } catch (Throwable t) {
                    falhou++;
                    System.out.println(" => falhou! " + t.getCause());
                }
            }
        }
        System.out.println("---------------Fim dos Testes---------------");
        System.out.println("Passaram: " + passou + ", Falharam: " + falhou);
    }
}

Simples simples (caso você entenda a reflexão)… Tudo o que a gente faz é verificar se o método possui a anotação @Testar, caso ele possua, o método é invocado. Se não ocorrer nenhuma exceção, então ele passou no teste, caso contrário ele falhou.

Para utilizar o nossa pequeno (micro) framework, basta chamar o método estático passando um objeto da nossa classe para testar:

Testador.testar(new ClasseParaTestar());

Para o nosso exemplo, você deve obter a seguinte saída:

-------------Inicio dos Testes--------------
Testando o método: metodo1 => falhou! java.lang.RuntimeException: Deu zebra!
Testando o método: metodo2 => passou!
Testando o método: metodo3 => passou!
Testando o método: metodo5 => falhou! java.lang.RuntimeException: Ixi maria... Erro!
Testando o método: metodo7 => passou!
---------------Fim dos Testes---------------
Passaram: 3, Falharam: 2

Obs: Eu tirei este exemplo da documentação oficial.

Exemplo 2: Validando seus atributos

Vamos criar uma classe genérica que faz a validação dos atributos de qualquer classe que você peça para ele validar. É claro que os atributos a serem validados devem possuir as anotações que nós vamos criar.

Vamos criar as nossas anotações então: @ValidarContemTexto e @ValidarPositivo.

ValidarPositivo.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ValidarPositivo { }

ValidarContemTexto.java

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface ValidarContemTexto {
    int min() default 1;
}

Opa! Apareceu uma coisa nova aqui. A anotação @ValidarContemTexto possui um atributo???

É isso mesmo! As anotações podem conter atributos para realizar alguma lógica durante o processamento delas.

No nosso caso, a anotação @ValidarContemTexto irá validar se o atributo que está decorado com a anotação possui pelo menos min caracteres (que por default é 1).

Reparem que a meta-anotação @Target é ElementType.FIELD, porque vamos utilizar essas anotações para decorar atributos.

A classe Usuario para o nosso teste será a seguinte:

Usuario.java

public class Usuario {
 
    @ValidarContemTexto(min = 10)
    private String login;
 
    @ValidarContemTexto(min = 20)
    private String senha;
 
    @ValidarPositivo
    private int nivel;
 
    //Construtores, getters e setters
    //...
}

O login deverá possuir pelo menos 10 caracteres, a senha deverá possuir pelo menos 20 caracteres (para garantir alguma segurança… hehehe) e o nível deverá ser um inteiro positivo maior ou igual a zero.

Vamos ver a classe responsável pela validação:

Validador.java

public class Validador {
 
    public static boolean validar(Object obj) {
        Class<?> classe = obj.getClass();
        boolean ok = true;
 
        for (Field f : classe.getDeclaredFields()) {
            f.setAccessible(true);
 
            //Annotation @ValidarPositivo
            if (f.isAnnotationPresent(ValidarPositivo.class)) {
                try {
                    int num = Integer.parseInt(f.get(obj).toString());
                    if (num < 0) {
                        ok = false;
                        throw new Exception();
                    }
                } catch (Throwable t) {
                    System.out.println(f.getName() + " deve ser um valor inteiro positivo.");
                }
            }
 
            //Annotation @ValidarContemTexto
            if (f.isAnnotationPresent(ValidarContemTexto.class)) {
                ValidarContemTexto anotacao = f.getAnnotation(ValidarContemTexto.class);
                try {
                    String texto = f.get(obj).toString();
                    if (texto.length() < anotacao.min()) {
                        ok = false;
                        System.out.println(f.getName() + " deve possuir pelo menos " + anotacao.min() + " caracteres.");
                    }
                } catch (Throwable t) {
                    System.out.println(f.getName() + ": " + t.getCause());
                }
            }
        }
        return ok;
    }
}

Quase igual ao exemplo anterior, porém nós percorremos os atributos (getDeclaredFields()) ao invés do métodos (getDeclaredMethods()).

Um if para cada anotação… nada muito novo. A única novidade aqui é a recuperação da anotação @ValidarContemTexto para poder acessar o valor que foi definido para o seu atributo min. Mas também não é nada de outro mundo.

O código a seguir cria 3 usuários e executa a validação com cada um deles:

ArrayList<usuario> usuarios = new ArrayList<usuario>();
usuarios.add(new Usuario("login", "senha", 2));
usuarios.add(new Usuario("felipesaab", "SaabRocks", -5));
usuarios.add(new Usuario("javasimples", "javasimplesjavasimples", 0));
 
for (Usuario u : usuarios) {
    System.out.println("Validando usuario: " + u.getLogin());
    if (Validador.validar(u)) {
        System.out.println("Usuário OK.");
    } else {
        System.out.println("Corrija os erros.");
    }
    System.out.println();
}

O resultado será o seguinte:

Validando usuario: login
login deve possuir pelo menos 10 caracteres.
senha deve possuir pelo menos 20 caracteres.
Corrija os erros.
 
Validando usuario: felipesaab
senha deve possuir pelo menos 20 caracteres.
nivel deve ser um valor inteiro positivo.
Corrija os erros.
 
Validando usuario: javasimples
Usuário OK.

Chegamos ao fim de mais um post aqui do Java Simples. Espero que tenham gostado, eu pelo menos achei esse assunto interessantíssimo.

Quem quiser pode pegar os arquivos que eu fiz e testei aqui.

[]s e até a próxima,

Saab.

Imagine que você desenvolveu um super software (em Java é claro…) para atender um determinado nicho de mercado, levou 1 ano da sua vida para fazer isso. Quando você começou a vendê-lo foi o maior sucesso, seus clientes falaram bem do seu software pra todo mundo. Cada dia apareciam mais clientes, maravilha!

Até que um certo dia um americano ouviu falar do seu software e diz que paga um preço 5x maior do que você está acostumado a cobrar, porém o software tem que ser totalmente em Inglês…

E agora José???? Vai copiar o projeto e sair mudando todas as strings? Boa sorte…

Se tivesse pensado nisso antes, você teria planejado melhor o seu software e teria utilizado as facilidades que o Java oferece para Internacionalizar seu programa.

Mais chega de história, vamos a algo um pouco mais prático. Vamos criar uma pequena aplicação apenas para demonstrar como é fácil e útil internacionalizar seu programa em Java.

Crie um novo projeto Java para Área de Trabalho no NetBeans e apague tudo que ele já cria. Crie 2 pacotes: internacionalizacao e internacionalizacao.linguas:

Dentro do pacote internacionalizacao crie um JFrame e o deixe parecido com este:

Eu mudei os nomes dos JLabel’s e do JComboBox para:

• jL_Lingua
• jL_Nome
• jL_Telefone
• jL_Email
• jCB_Lingua

Fique a vontade para nomear como achar melhor.

Essa vai ser a cara do nosso aplicativo. Quando o usuário selecionar uma língua no combobox, todos os JLabel’s e o título do JFrame vão mudar para a língua escolhida.

Como as coisas não caem do céu, as informações de cada idioma devem estar armazenadas em algum lugar. E esse lugar é um arquivo que vai ficar no pacote internacionalizacao.linguas. Um arquivo para cada idioma.

O nome dos arquivos devem serguir um padrão: <nome*>_<idioma>_<país>.properties
O padrão pode variar um pouco pois existem alguns parâmetros opcionais, porém o que nos interessa é este mesmo.

* O nome de todos os arquivos devem ser iguais. Ex:

• Idioma_pt_BR
• Idioma_en_US

Sabendo disso, adicione 4 arquivos ao pacote internacionalizacao.linguas. Para adicioná-los clique com o botão direito no projeto e em Novo > Outro. Selecione a categoria “Java” e o tipo de arquivo “Arquivo de Propriedade”.

Adicione os seguintes arquivos:

Eu dei o nome padrão de “Linguas” aos meus arquivos. Como já foi dito, cada arquivo é responsável por um idioma:

• Linguas_de_DE –> Alemão
• Linguas_en_US –> Inglês
• Linguas_fr_FR –> Francês
• Linguas_pt_BR –> Português

Segue o conteúdo de cada arquivo de Línguas:

Linguas_de_DE.properties

titulo = Internationalisierung  - EinfacheJava
lingua = Sprache
nome = Name
telefone = Telefon
email = E-Mail

Linguas_en_US.properties

titulo = Internationalization - SimpleJava
lingua = Language
nome = Name
telefone = Phone
email = Email

Linguas_fr_FR.properties

titulo =  Internationalisation - SimpleJava
lingua = Langue
nome = Nom
telefone = Téléphone
email = Email

Linguas_pt_BR.properties

titulo =  Internacionalização - JavaSimples
lingua = Língua
nome = Nome
telefone = Telefone
email = Email

Uma vez que os arquivos de idioma já contenham tudo o que vamos precisar, vamos atualizar o combobox. Mude a propriedade “model”  e adicione os seguintes itens:

• pt_BR
• en_US
• fr_FR
• de_DE

Agora só falta adicionar o evento que vai cuidar da mudança dos idiomas de acordo com a seleção do usuário. Adicione o seguinte código ao evento ActionPerfomed do jCB_Linguas:

String[] selecionado = jCB_Lingua.getSelectedItem().toString().split("_");
Locale.setDefault(new Locale(selecionado[0],selecionado[1]));
internacionaliza();

O vetor de String “selecionado” recebe o item que o usuário selecionou, porém separado pelo _ (underscore). Ex: se o usuário selecionar “pt_BR” –> “selecionado = {pt , BR}”.

Depois o Locale** default é setado para o que o usuário selecionou e é chamada a função internacionaliza().

** A Locale object represents a specific geographical, political, or cultural region. Um objeto Locale representa uma região geográfica, política ou cultural específica. (de acordo com a Documentação). Por default é a configuração do sistema operacional no qual a JVM foi instalada, ex: se o seu Windows é em português do Brasil, provavelmente sua Locale default será pt_BR.

Por fim, vamos ao código da função internacionaliza(), que é onde a mágica acontece:

public void internacionaliza() {
    Locale locale = Locale.getDefault();
    ResourceBundle palavras = ResourceBundle.getBundle("internacionalizacao.linguas.Linguas", locale);
 
    this.setTitle(palavras.getString("titulo"));
    jL_Lingua.setText(palavras.getString("lingua"));
    jL_Nome.setText(palavras.getString("nome"));
    jL_Telefone.setText(palavras.getString("telefone"));
    jL_Email.setText(palavras.getString("email"));
}

Primeiro é recuperado o Locale atual do computador e depois é instaciado o objeto palavras da classe ResouceBundle através do método estático ResourceBundle.getBundle(String,Locale). O que este método faz é procurar o arquivo cujo nome seja igual o passado no primeiro parâmetro e o Locale seja igual ao passado no segundo parâmetro.

Ex: A execução desse método:

ResourceBundle.getBundle("internacionalizacao.linguas.Linguas", new Locale(“pt”,”BR”);

Vai resultar na escolha do arquivo “Linguas_pt_BR.properties” do pacote “internacionalizacao.linguas”.

OBS Importante: É necessário passar o caminho completo do arquivo, ou seja: “pacote.NomePadrao”.

Agora que o objeto palavras contém a referência para todas as palavras daquele idioma, basta atribuí-las aos respectivos JLabels e ao título.

Quem quiser pode baixar o projeto através desse link.

É isso ai galera, qualquer dúvida é só deixar um comentário e prometo que respondo o mais rápido possível.

[]s,

Saab.

PS: Esse post também foi dica do Dang do Programei.org. Valew!

Hoje a gente vai desvendar a classe Robot, muito útil para testes automáticos, criação de bots e outros.

Em resumo, a classe Robot simula eventos do teclado, mouse e outros.

É tudo muito fácil, vamos ao código:

try {
	Robot robot = new Robot();
	robot.delay(1000);
	robot.keyPress(KeyEvent.VK_J);
	robot.keyPress(KeyEvent.VK_A);
	robot.keyPress(KeyEvent.VK_V);
	robot.keyPress(KeyEvent.VK_A);
	robot.keyPress(KeyEvent.VK_SPACE);
	robot.keyPress(KeyEvent.VK_S);
	robot.keyPress(KeyEvent.VK_I);
	robot.keyPress(KeyEvent.VK_M);
	robot.keyPress(KeyEvent.VK_P);
	robot.keyPress(KeyEvent.VK_L);
	robot.keyPress(KeyEvent.VK_E);
	robot.keyPress(KeyEvent.VK_S);
} catch (Exception ex) {
	System.out.println(ex.getMessage());
}

Para testar esse código basta executar o aplicativo e alternar para um editor de texto qualquer (em menos de 1 segundo).

Tudo o que esse código faz é criar um novo objeto da classe Robot, esperar por um segundo (pra dar tempo de alternar para um editor de texto)  e simular o pressionamento de algumas teclas.

Um efeito bem legal é colocar um delay entre cada uma das teclas. Isso faz parecer que as teclas estão sendo digitas. Segue o código:

try {
	Robot robot = new Robot();
	robot.delay(1000);
	robot.keyPress(KeyEvent.VK_J);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_A);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_V);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_A);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_SPACE);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_S);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_I);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_M);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_P);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_L);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_E);
	robot.delay(500);
	robot.keyPress(KeyEvent.VK_S);
} catch (Exception ex) {
	System.out.println(ex.getMessage());
}

A classe Robot permite a simulação de eventos do mouse também:

try {
    Robot robot = new Robot();
    robot.mouseMove(1100, 10);
    robot.delay(500);
    robot.mousePress(InputEvent.BUTTON1_MASK);
} catch (Exception ex) {
    System.out.println(ex.getMessage());
}

O código acima apenas coloca o mouse na posição 1100,10 da tela e simula um clique do botão esquerdo.

Post curto pra um assunto de fácil entendimento. Espero que ninguem encontre dificuldades quando estiver utilizando essa classe tão legal.

[]s,

Saab.

PS: Esse post foi uma dica do Dang do Programei.org. Valew fera!

Se você caiu de paraquedas nesse post eu sugiro a leitura do post anterior: Criando um cliente para Twitter – Parte 1.

Segunda parte do nosso tutorialzinho!
Agora iremos criar:

• Um formulário para realizar o login (sem utilizar o OAuth)
• Um formulário para:
  • mostrar os ultimos tweets da timeline
  • possibilitar o envio de um tweet

Vamos lá então, crie um novo projeto no NetBeans e adicione o twitter4j nas bibliotecas.
Adicione um JFrame e deixe parecido com este:

O campo para usuário é um JTextField com o nome jTF_Nome.
O campo para a senha é um JPasswordField com o nome jPF_Senha.
O JButton não tem nada de mais, só coloquei o passarinho ai pra ficar mais bonitinho. ^^

O JPasswordField é mais do que um JTextField que mascara as letras, existem todo um esquema de segurança por trás deste componente. Tanto que a recuperação do que foi digitado é um pouco mais chatinha: ao invés de uma String, é recuperado um objeto do tipo char[]. Como o login é exige duas strings (usuário e senha) como parâmetro, fiz um método para realizar a conversão.
Vamos ao código do botão responsável pelo login:

public String pegaSenha() {
	char[] senha = jPF_Senha.getPassword();
	String str = "";
	for (int i = 0; i < senha.length; i++) {
		str += senha[i];
	}
	return str;
}
 
public void EfetuarLogin() {
	String usu = jTF_Usuario.getText();
	String senha = pegaSenha();
 
	try {
		Twitter t = new TwitterFactory().getInstance(usu, senha);
		User u = t.verifyCredentials();
 
		Principal p = new Principal(t,u);
		p.setLocationRelativeTo(null);
		p.setVisible(true);
 
		this.dispose();
	} catch (TwitterException e) {
		if (e.getStatusCode() == 401) {
			JOptionPane.showMessageDialog(this, "Usuário e/ou senha inválidos!");
		}
	}
}

Nada muito novo em relação ao post anterior. É criado um novo objeto Twitter com os dados que foram digitados. Para garantir que os dados estão corretos existe o método verifyCredentials() que em caso de sucesso retorna um objeto User que referencia o usuário que acabou de se logar.  Se estiver tudo certo então chama o próximo JFrame (Principal) e retira o formulário de login da memória (uma vez que ele não será mais usado).

Em caso de falha, é jogada uma exceção do tipo TwitterException. Se o status code da exceção for 401 significa que o usuário e/ou senha estão errados, daí é só avisar o usuário.

O próximo formulário é um pouco mais complexo… Adicione um novo JFrame ao projeto e chame de Principal.java. Deixe ele parecido como este:

Segue a lista dos componentes:

JLabel jL_Foto –> tamanho 48×48

JTextArea jTA_Status –> pra digitar a mensagem

JLabel jL_Restantes –> vai indicar quantos caracteres ainda restam

JScrollPane jScrollPane2 –> a borda foi mudada para ficar mais legal como esta na figura (Ultimos Tweets)

JPanel jP_Tweets –> este panel vai receber os ultimos tweets, ele fica dentro do jScrollPane2. O layout desse panel é do tipo BoxLayout (layout de caixa)  com a propriedade eixo setada em Y.

Vamos lá então! Exibindo os últimos tweets:

public class Principal extends javax.swing.JFrame {
    private Twitter t;
    private User eu;
    Image foto;
 
    /** Creates new form Principal */
    public Principal(Twitter t, User eu) {
        this.t = t;
        this.eu = eu;
        initComponents();
        recuperarDados();
    }
 
    private void recuperarDados() {
        this.foto = this.getToolkit().getImage(eu.getProfileImageURL());
        jL_Foto.setIcon(new ImageIcon(foto));
        carregaTimeline();
    }
 
    public void carregaTimeline() {
        try {
            JPanel pane;
            JLabel novaFoto;
            JTextArea msg;
            int i = 0;
 
            jP_Tweets.removeAll();
 
            for (Status s : t.getFriendsTimeline()) {
                i++;
                //cria o panel
                pane = new JPanel(new FlowLayout(FlowLayout.LEFT));
                pane.setBorder(new LineBorder(Color.black, 1));
                pane.setSize(370, 50);
 
                //cria o label com a foto
                novaFoto = new JLabel(new ImageIcon(this.getToolkit().getImage(s.getUser().getProfileImageURL())));
 
                //cria o textarea com o texto
                msg = new JTextArea(3, 27);
                msg.setEditable(false);
                msg.setText(s.getText());
                msg.setLineWrap(true);
 
                pane.add(novaFoto);
                pane.add(msg);
                jP_Tweets.add(pane);
            }
 
        } catch (TwitterException ex) {
            JOptionPane.showMessageDialog(this, "Erro recuperando a timeline: " + ex.getMessage());
        }
    }
 
    ...
}

A classe possui 3 atributos que eu considero completamente autoexplicativos mas vamos dar uma pequena passada por eles:

• Twitter t –> velho conhecido nosso não é…
• User eu –> para guardar as informações de quem está logado
• Image foto –> para guardar a imagem de perfil do usuário

Logo quando o formulário é criado, o método recuperarDados() é chamado, a foto do usuário é carregada e então o método carregaTimeline() é invocado.

O carregaTimeline() cria dinamicamente a lista com os ultimos tweets. O código está todo comentado e está bem fácil de entender.

Vale ressaltar que para a lista ficar certinha (um tweet por linha) o layout do panel jP_Tweets deve ser BoxLayout!

Vamos para a próxima parte então: Atualizando o status.

Mude a propriedade lineWrap do jTA_Status para true, com isso a linha não vai ultrapassar os limites do text area e o texto vai ficar dentro dela.

Para fazer a contagem dos caracteres restantes vamos utilizar de uma funcionalidade bem interessante do text area: O evento caretUpdate é chamado toda vez que uma tecla é adiciona ou deletada, sendo assim, adicione o seguinte código neste evento caretUpdate do jTA_Status:

private void jTA_StatusCaretUpdate(javax.swing.event.CaretEvent evt) {
    jL_Restantes.setText(String.valueOf(140 - jTA_Status.getText().length()));
}

Próximos passos: não deixar o usuário digitar mais do que 140 caracteres e postar a mensagem.

O que vamos fazer é o seguinte: se o usuário for digitar o 141º a gente simplesmente cancela ele. Podemos tratar as duas funções no evento keyTyped do jTA_Status.

Segue o código:

private void jTA_StatusKeyTyped(java.awt.event.KeyEvent evt) {
    if (jTA_Status.getText().length() == 140) {
	evt.setKeyChar((char) KeyEvent.VK_CLEAR);
    }
 
    if (evt.getKeyChar() == KeyEvent.VK_ENTER) {
	try {
	    t.updateStatus(jTA_Status.getText());
            jTA_Status.setText("");
	    carregaTimeline();
	} catch (TwitterException ex) {
	    JOptionPane.showMessageDialog(this, "Erro atualizando o status: " + ex.getMessage());
	}
    }
}

Muito tranquilo. Pouco código e muitas funcionalidades.

Agora nosso cliente já está com uma cara bem legal. Eu implementei mais algumas frescurinhas e ele ficou assim:

Ali embaixo da minha foto tem um label que mostra um pedacinho do ultimo post… embaixo da lista mostra quantos tweets foram carregados… enfim, um monte de frescura que eu nem mostrei aqui…

Quem quiser conferir o projeto completo pode pegar aqui.

Sugestões para quem quiser aperfeiçoar um pouco mais esse humilde cliente de Twitter:

• De 5 em 5 minutos recarregar a lista de tweets. Dica: utilizando Threads fica facinho.
• Ao clicar na foto da pessoa, uma janela abre com as informações da pessoa.
• Adicionar um botão para retwittar a mensagem.

Quem quiser tem como brincar bastante com isso ai…

Valew pessoal,

[]s e até a próxima.

Saab.