É com grande prazer que venho informar que escrevi um artigo sobre Hibernate Annotations para a revista Java Magazine e o artigo foi publicado na edição número 90.

Segue um pequeno resumo do artigo:

Hibernate Annotations – Mapeamento Objeto Relacional através de Anotações

Desde que surgiu o Hibernate para ser uma ponte entre a orientação a objetos e a persistência de dados em bancos de dados relacionais, tudo o que o desenvolvedor precisa fazer é descrever suas classes com alguns metadados para poder se focar no desenvolvimento da aplicação (regras de negócio). Assim, sem se preocupar muito com a persistência de seus objetos em bancos de dados o desenvolvedor consegue aumentar sua produtividade.

Durante um bom tempo os metadados foram descritos através de XML (e são até hoje). Para cada classe que seria persistida no banco de dados era criado um novo XML explicando como o Hibernate deveria realizar o mapeamento entre atributos da classe e colunas da tabela.

Atualmente este não é mais o único modo de descrever os metadados, existe também o Hibernate Annotations, projeto que provê a descrição dos metadados através de anotações. Deste modo, ao invés de um arquivo XML para cada classe, os metadados podem ser anotados na própria classe e em seus atributos, facilitando ainda mais o processo de mapeamento.

Nesse artigo serão apresentados os conceitos necessários para entender como utilizar o framework Hibernate para persistir as classes Java em bancos de dados relacionais apenas com a descrição de metadados providos por anotações, utilizando, para isso, a IDE NetBeans 6.9.1 e o banco de dados MySQL.

Caso o assunto seja de seu interesse pode dar um pulo no site da revista ou então dar uma conferida nas bancas..

[]s,
Saab.

PS: Isso não foi marketing! Estou feliz pois meu primeiro artigo para a revista foi publicado.

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.

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 estenda 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<produto> produtos;
 
    public ProdutoTableModel() {
        produtos = new ArrayList();
    }
 
    public ProdutoTableModel(List<produto> 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<produto>() {
 
            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<produto>() {
 
            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 getProduto(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 que implementa a interface 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.getProduto(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
        List<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){
            List<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.

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.

Vamos ao assunto de hoje: criando um cliente de Twitter.

Ah o Twitter… Quem não usa o twitter? Quem nunca ouviu falar do twitter? Acho que hoje em dia é bem difícil.
Mas aproveitar todas as funcionalidades do twitter no navegador é – na minha opinião – um saco! Toda hora fica recarregando, tem horas que aparece aquela PIIII daquela baleia dizendo que o servidor está congestionado…

Enfim, para não passar por esses probleminhas normalmente a gente apela para os clientes de twitter, que nada mais são do que softwares que acessam o twitter com a nossa conta e mostram as atualizações de um jeito bem bonitinho e cheio de frescuras - vide TweetDeck, ÜberTwitter, entre outros.

Contudo, esses clientes não foram feitos especificamente para nós, ou seja, podem existir funções que não sejam do nosso gosto e pode também faltar algumas funções que sejam essenciais para nós. Então por que não criar o seu próprio cliente de Twitter? É muito simples e personalizável, podemos criá-lo do jeito que quisermos. Vamos a algumas informações essenciais:

Para conseguir mostrar as informações da nossa conta do Twitter em uma telinha de um software desktop, eles fazem chamadas para a API do Twitter. A equipe do Twitter já deixou tudo pronto pra nós não termos muito trabalho recuperando as informações. Basta fazer uma requisição HTTP e será retornado um XML com as informações requisitadas.

Para a sorte do desenvolvedor Java, um tal de Yusuke Yamamoto desenvolveu uma biblioteca chamada Twitter4J onde ele já encapsula todas as requisições HTTP, tratamentos da resposta, enfim, é responsável por todo o trabalho duro necessário para interagir com o Twitter, sendo assim, nós podemos nos concentrar mais na aplicação em si.

Nessa primeira parte do tutorial vou mostrar apenas como conectar, atualizar o status e recuperar a timeline. Nas próximas partes a gente vai modelando e dando vida ao nosso cliente.

Mãos a obra então: baixe o twitter4j-core e crie uma nova aplicação no NetBeans (não precisa ser aplicação desktop por enquanto). Adicione a biblioteca que você acabou de baixar às bibliotecas do projeto como na figura:

O código da aplicação é muito simples, como segue abaixo:

public static void main(String[] args) {
    try {
        String usuario = "seu nome de usuario";
        String senha = "sua senha";
        //conectando
        Twitter twitter = new TwitterFactory().getInstance(usuario, senha);
 
        //recuperando a timeline
        List<status> timeline = twitter.getFriendsTimeline();
        System.out.println("Exibindo a timeline");
        System.out.println("----------------------------------------");
        for (Status s : timeline) {
            System.out.println(s.getUser().getScreenName() + " - " + s.getText());
        }
        System.out.println("----------------------------------------");
 
        //atualizando o status
        String novoStatus = "#JavaSimples - testando o twitter4j!";
        twitter.updateStatus(novoStatus);
        System.out.println("Status atualizado com sucesso!");
    } catch (TwitterException ex) {
        System.out.println("Erro: " + ex.toString());
    }
}

Para conectar no Twitter é criado um objeto da classe Twitter que é um intermediário entre a nossa aplicação e a API do Twitter, ou seja, tudo o que nós quisermos fazer deve ser através de um método desse objeto. Ele é criado seguindo um padrão de projeto (olha a engenharia de software marcando presença…) chamado Abstract Factory – que provê a padronização na criação de um objeto, mas como a engenharia não é o foco aqui, vamos em frente.

Logo em seguida, é criada uma lista chamada timeline que é do tipo List<Status> e que recebe todas as atualizações das pessoas que você segue através do método getFriendsTimeLine() do nosso objeto da classe Twitter.
Cada update/status/post de um usuário no twitter é representado pela classe Status, através da qual pode-se obter qualquer tipo de informação do update/status/post. No exemplo nós recuperamos o usuário (recuperamos um objeto da classe User que contém as informações do usuário) e a partir dele, o seu screenName (sigla que te identifica no twitter. ex: fesaab) e também o texto do update/status/post.

Por fim, eu atualizo o status com uma simples mensagem e se não ocorrer nenhum erro mostra uma mensagem de sucesso.

Tudo muito prático e simples!

Ficamos por aqui nessa primeira parte do nosso tutorial sobre Java + Twitter. Quem quiser o projeto completo pode pegar aqui.

[]s,
Saab.

No último post eu mostrei uma técnica bem interessante da programação dinâmica: a reflexão, através da qual agente consegue perguntar pra um objeto qualquer quais são suas variáveis de instância (inclusive os seus valores) e seus métodos.

Beleza, daí um monte de gente me perguntou: “Pra que diabos eu preciso saber disso?” ou então “Quando eu vou usar?” entre outras… Para exemplificar o uso da reflexão vamos criar uma pequena aplicação. Nada muito complicado… uma agenda de contatos. OK, só mais um detalhe: não vou explicar nada sobre a conexão com o banco de dados, ou tratamento de erros ou outras coisas que vou utilizar no tutorial, o foco vai ser a reflexão. Qualquer dúvida é só deixar um comentário que a gente resolve.

Então vamos ao que interessa! Primeiro vamos criar uma tabela no banco de dados para representar um contato:

CREATE TABLE `contatos` (
 
`con_id` INT NOT NULL ,
`con_nome` VARCHAR( 60 ) NOT NULL ,
`con_endereco` VARCHAR( 100 ) NOT NULL ,
`con_email` VARCHAR( 50 ) NOT NULL ,
`con_telefone` VARCHAR( 20 ) NOT NULL ,
PRIMARY KEY ( `con_id` )
 
) ENGINE = INNODB CHARACTER SET utf8 COLLATE utf8_unicode_ci;

Pronto, com o banco pronto vamos para a aplicação. Crie uma nova aplicação no NetBeans (aplicação para área de trabalho, porque ela já importa o .jar do swing), apague tudo que ele crie a seguinte estrutura:

Vamos aplicar um pequeno padrão aqui, algo que lembra o MVC, que é utilizar uma estrutura de 3 camadas:

1. Apresentação: mostra os dados para o usuário;
2. Negócios: cuida das regras de negócio da aplicação (nada muito complexo nessa nossa agenda);
3. Persistência: cuida do armazenamento físico dos dados.

Não vou explicar muito a engenharia da coisa portanto vamos em frente. Vamos começar de baixo pra cima, ou seja, vamos ver primeiro a classe da camada de persistência:

public class ConexaoMySQL {
 
    private Connection connect;
    private String erro = "";
 
    public static ConexaoMySQL getConexao() throws Exception {
        ConexaoMySQL c = new ConexaoMySQL();
        Connection connect = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            String url = "jdbc:mysql://localhost/agenda";
            connect = DriverManager.getConnection(url, "root", "123");
            c.setConnection(connect);
        } catch (ClassNotFoundException cnfex) {
            throw new Exception("Falha ao ler o driver JDBC" + cnfex.toString());
        } catch (SQLException sqlex) {
            throw new Exception("Impossível conectar com a base de dados" + sqlex.toString());
        } catch (Exception ex) {
            throw new Exception("Outro erro" + ex.toString());
        }
        return c;
    }
 
    public void close() {
        try {
            this.connect.close();
        } catch (Exception ex) {
            System.out.println(ex.toString());
        }
    }
 
    private void setErro(String erro) {
        this.erro = erro;
    }
 
    private void setConnection(Connection connection) {
        this.connect = connection;
    }
 
    public Connection getConnection() {
        return this.connect;
    }
 
    public String getMensagemErro() {
        return erro;
    }
 
    public boolean getEstadoConexao() {
        if (connect == null) {
            return false;
        } else {
            return true;
        }
    }
 
    public boolean manipular(String sql) // inserir, alterar,excluir
    {
        try {
            Statement statement = connect.createStatement();
            int result = statement.executeUpdate(sql);
            statement.close();
            if (result != 1) {
                return true;
            }
        } catch (SQLException sqlex) {
            erro = "Erro: " + sqlex.toString();
            return false;
        }
        return false;
    }
 
    public int getMaxPK(String tabela, String chave) {
        String sql = "select max(" + chave + ") as max from " + tabela;
        int max = 0;
        ResultSet rs = null;
        try {
            Statement statement = connect.createStatement(
            ResultSet.TYPE_SCROLL_INSENSITIVE,
            ResultSet.CONCUR_READ_ONLY);
            System.out.println(sql);
            rs = statement.executeQuery(sql);
 
            if (rs.next()) {
                max = rs.getInt("max");
            }
            statement.close();
        } catch (SQLException sqlex) {
            erro = "Erro: " + sqlex.toString();
            return -1;
        }
 
        return max;
    }
 
    //aqui que a mágica da reflexão acontece
    public void Insere(String tabela, Object objeto) throws Exception {
        SimpleDateFormat sd = new SimpleDateFormat("yyyy-MM-dd");
        String sql = "INSERT INTO " + tabela.toUpperCase() + "(";
 
        //percorre os atributos vendo o nome dos campos
        Class classe = objeto.getClass();
        for (Field f : classe.getDeclaredFields()) {
            f.setAccessible(true);
            sql += f.getName() + ",";
        }
 
        sql = sql.substring(0, sql.length() - 1); //retira a ultima virgula..
        sql += ") VALUES(";
 
        //percorre os atributos vendo o valor dos campos
        for (Field f : classe.getDeclaredFields()) {
            f.setAccessible(true);
            if (f.getType().getSimpleName().equals("String")) {
                sql += "'" + f.get(objeto) + "',";
            } else {
                sql += f.get(objeto) + ",";
            }
        }
 
        sql = sql.substring(0, sql.length() - 1); //retira a ultima virgula..
        sql += ")";
 
        //executa a query
        System.out.println(sql);
        if (!manipular(sql)) {
            throw new Exception(getMensagemErro());
        }
    }
}

O único método que merece explicações é o método Insere(String tabela, Object objeto) que utiliza da reflexão computacional para criar dinâmicamente o SQL referente à inserção do objeto “objeto” na tabela “tabela”.

O código é bem simples de entender:

1. Inicializa a variável responsável por guardar o SQL;
2. Passa por todos os atributos do objeto adiciondo os nomes deles ao SQL;
3. Passa pelos atributos novamente, só que desta vez adicionando os valores dos atributos (caso seja uma variável da classe String, adiciona aspas simples antes e depois do valor).
4. Executa a query. Se algo deu errado, joga uma nova exceção com a mensagem de erro.

Muito simples não?!?!?
Vamos ver como funciona na prática então, vamos subir uma camada e ver como funciona a classe Contatos.java:

public class Contatos {
 
    private int con_id;
    private String con_nome;
    private String con_endereco;
    private String con_telefone;
    private String con_email;
 
    public Contatos(String con_nome, String con_endereco, String con_telefone, String con_email) throws Exception {
        ConexaoMySQL c = ConexaoMySQL.getConexao();
        this.con_id = c.getMaxPK("contatos", "con_id") + 1;
        c.close();
        this.con_nome = con_nome;
        this.con_endereco = con_endereco;
        this.con_telefone = con_telefone;
        this.con_email = con_email;
    }
 
    public void Insere() throws Exception{
        if (this.con_nome.equals("") || this.con_telefone.equals("")){
            throw new Exception("Preencha pelo menos o nome e o telefone.");
        }
 
        ConexaoMySQL c = ConexaoMySQL.getConexao();
        c.Insere("contatos", this);
        c.close();
    }
 
//getters e setters
}

Uma classe extremamente simples que representa fielmente a tabela que criamos no banco de dados.

O construtor não exige o ID do contato, ao invés disso ele pega um novo para o contato (busca no banco o maior ID existente e soma 1).

O método Insere() não faz nada além de validar se pelo menos o nome e o telefone estão preenchidos e chamar o método Insere(..) da camada inferior passando uma String com o nome da tabela e passando ele mesmo (o objeto Contato) através da palavra reservada this. Caso ocorra algum erro na query, será retornada uma exceção do método Insere(…) da classe ConexaoMySQL.java para o método Insere() da classe Contato.java e este por sua vez irá retornar essa mesma exceção para quem o chamou.

Os nomes dos atributos devem ser iguais aos nomes das colunas da tabela, pois o método Insere(..) da classe ConexaoMySQL.java trata cada atributo como uma coluna da tabela para montar o SQL, como já vimos antes.

Agora vem a última (ou a primeira, depende do ponto de vista.. ) camada: a responsável pela apresentação. A classe Principal.java é um JFrame que vai fornecer a interface visual para o usuário. Deve ficar mais ou menos assim:

Os campos de texto são JTextFields com os respectivos nomes: jTF_Nome, jTF_Endereco, jTF_Telefone e jTF_Email.

Creio que eu nem precise comentar sobre o que o botão Limpar faz não é?

O código do botão Inserir segue abaixo:

public void Inserir() {
    try {
        Contatos c = new Contatos(jTF_Nome.getText(), jTF_Endereco.getText(), jTF_Telefone.getText(), jTF_Email.getText());
        c.Insere();
        JOptionPane.showMessageDialog(this, "Contato adicionado com sucesso");
    } catch (Exception e) {
        JOptionPane.showMessageDialog(this, e.getMessage());
    }
}

Cria-se um objeto Contato a partir dos dados do formulário e chama o método Insere(), caso ocorra algum erro, o programa desviará para o bloco catch(…) e será mostrado o erro, mas se der tudo certo, será mostrada a mensagem de sucesso.

DICA: Debuge o projeto para ver como o SQL é montado dinâmicamente. É bem interessante.

É isso! Repare como o código fica simples e fácil de ler.
Ao invés de ter uma classe só que cuida de mostrar os dados, validá-los, tratar a conexão com o banco e tratar o SQL (como eu mesmo já fiz e sei que muita gente faz), agora a gente tem uma estrutura muito bem projetada que facilita a manutenção e futuras mudanças, como por exemplo:

1. Se você quiser guardar o twitter do contato também, basta criar uma nova coluna no banco, um novo atributo na classe Contatos.java e um novo campo de texto na classe de apresentação. Não precisa se preocupar com SQL pois a reflexão cuida disso pra nós.
2. Se precisar mudar o banco para o SQL Server, basta trocar a classe ConexaoMySQL por uma ConexaoSQLServer. Não há necessidade de alteração na lógica nem na apresentação do projeto.

Minha intenção neste post era mostrar um exemplo somente sobre reflexão, mas eu acabei mostrando um pouco sobre o modelo de desenvolvimento em 3 camadas, algo realmente muito útil quando se trata do desenvolvimento de software.

Obrigado a você que teve paciência de ler até aqui.
Quem quiser o projeto do NetBeans, basta pegar aqui.
Qualquer dúvida é só deixar um comentário.

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

PS: Só queria deixar uns créditos a outras pessoas:

Professor Silvio Carro (FIPP) que criou a base para a classe de conexão com o banco. A maior parte do código foi feito por ele.

Professor Emerson Silas Dória (FIPP) que mostrou esses conceitos de reflexão e camadas em aula, o que motivou a criação destes posts.

São componentos visuais que facilitam imensamente o usuário selecionar uma data. Segue uma pequena imagem dos componentes:

O JCalendar é como o calendário do Windows, já o JDateChooser é como um combobox, que abre um mini-calendário quando o usuário clica no ícone do lado direito e o fecha quando o usuário clica na data desejada.

Site do projeto – http://www.toedter.com/en/jcalendar/

Para instalar esses componentes é necessário fazer o download no site do projeto e procurar dentro da pasta /lib o .jar desejado, mas como eu sou mto bonzinho, eu coloquei no meu 4shared o único arquivo necessário. Para baixar clique aqui.

Antes de configurar, vale lembrar que o Netbeans vai fazer apenas uma referência ao arquivo, ou seja, ele vai usar o que está dentro do arquivo, então se deixar ele na área de trabalho, ou no diretório dos seus downloads, não vai ter como mudar de lugar depois, então vale a pena guardar em um local seguro (tipo: …/Java/jdk/lib).

Com o Netbeans aberto (estou usando o 6.7.1), clique em “Ferramentas > Paleta > Componentes Swing/AWT”. Voce deverá chegar na seguinte tela:

Clique em “Nova Categoria” e de o nome desejado, algo como Calendário ou Data, sei lá… Se não quiser não precisa, só acho mais organizado deixar separado.

Com a nova categoria criada (ou não), clique em “Adicionar do JAR…” e navegue até o .jar que você acabou de baixar.

Selecione todos os componentes e clique em “Próximo”.

Na última tela basta selecionar a pasta que vai conter os novos componentes e clicar em “Finalizar”.

Prontinho, agora você já tem a sua disposição o JCalendar, o JDateChooser e mais alguns componentes. Para usar é só clicar e arrastar pra tela.

Duas coisas que valem ser lembradas:

1. A propriedade dateFormatString é responsável pela formatação da string exibida no componente. Ex:
   ”dd/MM/yyyy” –> 19/01/2010
   ”MM/dd/yyyy” –> 01/19/2010
2. Todos os componentes possuem o método getDate que retorna a data selecionada em um objeto java.util.Date

É isso ai galera.
Qualquer dúvida é só comentar…

Até a próxima,
Saab.