Vamos começar com o que será necessário. Primeiro de tudo meu ambiente é um linux configurado em inglês por isso as telas aqui estão em inglês, então pode ser que precise adaptar os detalhes das telas para o seu ambiente. Aqui eu uso tanto MySQL quanto PostgreSQL, mas nesse tutorial vou assumir que existe um MySQL instalado com um banco de dados criado de nome “curso” com um usuário “javadb” (e a senha você precisa saber qual configurou aí.) Infelizmente a configuração do MySQL não está no nosso escopo, mas qualquer banco de dados relacional serve (só precisa mudar durante a configuração conforme vou mostrar mais a frente.) Finalmente a última definição é usar o Netbeans 6.7, já temos o 6.8 disponível, mas por questões de projeto ainda não migrei nem testei ele, já a versão 6.7.1 tem alguns problemas com detalhes de web e CVS então sugiro ficar com o 6.7 por enquanto, e pode ser encontrado aqui.

Então agora vamos começar!

Primeiro precisamos entender do que estamos falando, isso costuma ajudar muito no desenvolvimento de qualquer coisa na vida. JPA é a sigla para Java Persistence Api, ou seja, uma especificação de persistência para Java. Isso significa que depois de anos de trabalho tentando mapear sistemas orientados a objetos em bancos de dados relacionais aprendemos quais são os problemas recorrentes e as soluções foram sendo catalogadas. O resultado disso ao longo dos anos foi a construção de ferramentas que ofereciam soluções parcialmente automáticas. Com a chegada do EJB3 a Sun mudou os Entity Beans (entidades do sistema) para marcar seus relacionamentos via anotações, e além disso incorporou os mecanismos das diversas ferramentas de persistência. Como implementação de referência a Oracle disponibilizou gratuitamente o TopLink, na época Oracle ainda não tinha comprado a Sun.

É claro que usar uma ferramenta de persistência pode sacrificar um pouco o desempenho da aplicação, mas tenha em mente o seguinte, nem todas as partes do sistema precisam ser extremamente rápidas. Quando alguma das partes do sistema não estiver satisfatória podemos deixar de lado a ferramenta e prover alguma solução construída manualmente. Mas por experiência própria, são poucas as vezes que isso é necessário em sistemas de informação.

Então para fechar a parte teórica e começarmos a meter a mão na massa. A Sun já tinha proposto anteriormente o JDBC que é a especificação que permite que os fornecedores de bancos de dados disponibilizem os drivers para acessar seus produtos, agora com o JPA temos o papel de provedor de persistência, neste caso temos Hibernate, TopLink, EclipseLink e assim por diante. Entre estes eu não usei ainda o eclipse link.

Agora então temos uma nova camada entre a aplicação e o banco de dados tentando tornar a aplicação cada vez mais independente de tecnologias de infraestrutura. Para o nosso exemplo vamos usar o TopLink que já vem com o Netbeans simplesmente porque o Hibernate requer que a aplicação seja gerenciada por um container, se a ideia fosse uma aplicação web isso seria mais fácil, mas vou usar aqui uma aplicação desktop.

Vamos começar então criando um projeto Java no Netbeans. Escolha Java e Aplicação Java como na figura a seguir.

Agora precisamos dar um nome ao projeto, sugiro TutorialJPA, uma coisa que o Netbeans sempre faz é perguntar se você quer criar uma classe main, pode desabilitar essa opção. E vamos escolher finalizar.

Agora que temos um projeto para trabalhar fica tudo um pouco mais fácil. Para entender melhor o que vamos fazer, a ideia e criar uma aplicação que grave as informações de uma classe Livro no banco de dados. Então precisamos de uma entidade Livro, e vou usar os atributos título, autor, isbn e número de páginas. Para isso vamos criar um pacote java de nome “domain” para guardar todas as entidades do nosso pequeno sistema.

E em seguida indique o nome do pacote, domain.

Certo, agora vamos criar a classe de entidade, para isso temos a opção criar nova classe de entidade que já considera que você vai usar as facilidades de JPA.

Agora precisamos escolher o nome da entidade, Livro.

Note que usamos o tipo Long para o id dos objetos, além disso o Netbeans no diz que não tem uma unidade de persitência configurada, agora começa a mágica do negócio. Antes de criar essa unidade de persistência, vamos entender do que se trata, para que a nossa aplicação tenha tantas indepedências precisamos configurar em algum lugar onde está o banco, e que tipo de banco estamos usando. Isso é feito em um xml que fica embutido no projeto, se você quiser mudar alguma coisa do banco, basta mexer nesse xml sem compilar nada! Aqui escolhemos Toplink, damos um nome para referenciar dentro da aplicação e precisamos escolher também qual a conexão com o banco de dados. Além disso podemos escolher o comportamento do JPA, se deve criar; remover e criar, ou não tomar ações em relação as tabelas, sim! O JPA pode criar as tabelas para nós no banco de ddaos!

Uma facilidade que o Netbeans nos oferece é criar a conexão durante este processo, é claro que se você já tiver conexões de banco de dados (até porque o Netbeans permite conectar no banco e executar comandos SQL) você pode simplesmente escolher. É claro que aqui eu vou mostrar como criar.

E agora configurar a conexão, colocando driver, endereço, nome do banco de dados, login e senha, escolhi também para lembrar a senha.

Terminando esse processo voltamos para a tela de criação da unidade de persistência e clicamos em criar.

O resultado é uma tela que nos permite visualizar de forma amigável o conteúdo do arquivo xml.

Agora vamos retomar nossa classe de Entidade, é claro que se fossemos criar várias classes de entidade, apenas na primeira vez seria necessário. Bom podemos ver que a classe Livro foi criada apenas com o atributo id, e vamos colocar agora 4 novos atributos que estão marcados na figura a seguir.

Pela especificação de java beans (já bem antiga) devemos criar os métodos acessores (get/set) para esses atributos, mas calma! O Netbeans ajuda a gente nisso. Para isso vamos clicar com o botão direito do lado de qualquer um dos atributos e aparecerá um menu no qual vamos escolher Refatorar.

Depois disso aparecerá outro menu no qual vamos escolher Encapsular Campos.

Com isso aparecerá uma nova tela na qual vamos escolher quais campos (atributos) queremos encapsular. Vamos escolher os quatro atributos que acabamos de criar.

Agora temos um detalhe, quando a classe foi criada o Netbeans gerou para a gente automanticamente dois métodos importantes o equals e o hashCode, esses métodos são fundamentais para conseguir comparar corretamente dois objetos, só que como criamos atributos novos precisamos recriar esses métodos, e novamente vamos ter uma ajuda. Podemos remover os métodos gerados.

Agora podemos recriar os métodos clicando novamente com o botão direito na tela, dentro da classe e escolhendo inserir código.

E uma nova janela aparece onde escolhemos equals e hashCode.

Agora, surgirá uma nova tela onde podemos escolher os atributos que serão usados para comparar dois objetos.

Antes de continuar, vamos dar uma pausa para uma outra configuração, precisamos importar para o nosso projeto a biblioteca do MySQL, como esse passo é bem simples é um bom momento para descansar a cabeça Então agora vamos clicar com o botão direito sobre o projeto e vamos escolher propriedades.

Isso nos abre uma outra tela na qual vamos escolher a opção bibliotecas. E agora vamos escolher adicionar bibliotecas.

Com isso vai aparecer a opção para escolhermos quais as bibliotecas queremos adicionar, neste caso a do MySQL.

Fim dos comerciais, agora podemos voltar ao nosso projeto. Vamos agora criar um pacote java chamado app onde ficará nossa classe de “aplicação” que vai representar o que seria uma interface gráfica por exemplo. Isso já está explicado aí em cima né ? Então vamos seguir para criar uma classe Java tradicional.

E basta agora dar o nome de Aplicacao e colocar a classe no pacote app. Vamos deixar essa classe em banho-maria por enquanto. Vamos seguir agora para uma outra parte mágica do JPA, o Netbeans permite criar um tipo de classe chamado JPAController, aplicando o padrão de projetos Controller, ele permite fazer a ponte entre a classe de entidade e o banco de dados efetivamente. Quando criada, está classe já vem com as operações básicas, e que muitas vezes são suficientes para alguns cadastros. Algumas vezes o tipo de recurso que queremos criar não está disponível no menu, basta ir até “outros”.

E em seguida escolher em persistência, JPAController.

Agora uma nova tela surgirá para que escolhamos para qual Entidade vamos criar o JPAController, sim, para cada entidade teremos um controller diferente.

Em nosso projeto só existe uma entidade, e portanto fica fácil de escolher, basta clicar na classe domain.Livro e clicar em adicionar, depois vamos para a próxima tela onde vamos escolher em que pacote as classes vão ser criadas.

Neste momento estamos com toda a infraestrutura do nosso projeto criada e podemos retomar a nossa classe de aplicação que vai utilizar todos esses mecanismos. Para conferir a estrutura e as classes criadas segue a próxima figura.

Agora retomando nossa classe de aplicação, o que queremos fazer com um banco de dados ? Persistir os dados de nossa aplicação! Então precisamos criar objetos, preencher os valores, criar uma instância de JPAController e chamar os métodos para realizar as ações desejadas. Nesta figura temos todos os usos das chamadas, criar, buscar, editar e remover. Esse código precisa ser colocado no método main da nossa classe Aplicacao.

É isso, é claro que até aqui só temos o suficiente para criar um pequeno projeto, mas podemos ampliar os estudos com alguns livros importantes, mais para frente vou colocar aqui umas resenhas de livros importantes para esse tópico.

O vídeo do projeto pode ser visto aqui.

Segundo a professora Caroline Chan, os produtos comercializados na Austrália contém um código de barras utilizado para fins comerciais, mas que tem potencial ilimitado, podendo ser usado para acessar informações nutricionais entre outras.

Aqui no Brasil isso seria difícil de empregar, porque nossos sistemas não usam os códigos de barra dos produtos, na maioria dos mercados o que vemos são etiquetas com códigos diferente colados por cima, o que, inclusive, dificulta muitas vezes o acesso as informações nutricionais da embalagem.

Vale ainda ressaltar que a professora Chan é da área de Sistemas de Informação, isso aliás fica bem claro no teor prático da pesquisa. Ponto para o pessoal de TI !

Antes de entender as diversas possibilidades as pessoas deveriam ser apresentadas ao modelo de trabalho proposto pela Web, isso facilitaria muito a adoção, e até mesmo a escolha consciente, de uma tecnologia de implementação. Vamos considerar que tecnologia de implementação é toda a tecnologia que permite desenvolver um sistema baseado em tecnologia Web, dessa forma ASP, PHP, JSP, ColdFusion, e claro HTML além de muitas outras são tecnologias de implementação. Por outro lado temos ainda as tecnologias de base da Web que são o protocolo HTTP e os servidores Web que são capazes de atender requisições em formato HTTP, geralmente na porta 80.

Então é interessante entender que as tecnologias de implementação usam sempre os mesmos recursos de infraestrtura, isto porque em um mundo globalizado e distribuído, a tecnologia web facilita para os administradores de sistemas proteger seus servidores, isto porque através da porta 80 são permitidas trocas de informação baseada em texto, muito mais fáceis de regular. Assim quando um administrador coloca sua máquina na rede abre apenas a porta 80, e bloqueia todas as outras formas de acesso a máquina.

Outra característica interessante, é que as conexões web são bastante voláteis, ou seja, o cliente (geralmente um browser ou navegador web) estabele a conexão, solicita o recurso (normalmente uma página), recebe sua resposta e desconecta. Até aí nenhuma novidade no mundo das redes, no entanto, como os recursos solicitados geralmente são texto (e imagens) essas conexões não duram muito tempo. “Ah mas eu acesso o youtube!” Sim, no entanto a execução de vídeos é servida através de outra conexão, geralmente com outra máquina, ou seja, o HTTP já havia encerrado. Dessa forma o temos alguns pontos a considerar:

1. O servidor web não sabe de quem é cada requisição que chega, por isso uma aplicação web precisa ter o conceito de sessão.
2. Trocamos texto entre o servidor e o browser, então a tela que aparece na máquina do cliente não veio do servidor, e sim uma descrição de como a tela deve ser montada.
3. Não ficam variáveis guardadas na memória do computador do cliente, essa é uma parte quase mística. Quando programamos uma aplicação com interface web, a aplicação fica no servidor, e somente a descrição da tela é enviada para o browser do solicitante, dessa forma toda e qualquer variável que seja manipulada, ficará armazenada na memória do servidor e não na máquina do cliente. Por isso é de extrema importância que haja algum mecanismo de controle de sessão de forma que o servidor possa identificar todas as requisições (em conexões diferentes) de um mesmo cliente.

No modelo mais simples de implementação web utilizamos a técnica de recarregar a página para cada requisição durante muito tempo essa foi a forma mais difundida de trabalhar até porque em um passado não muito distante qualquer alternativa era muito mais complicada e o esforço não compesava dado o custo extra. Atualmente temos tecnologias para contornar isso, o Ajax permite fazer chamadas ao servidor (no mesmo modelo web tradicional) de forma transparente ao usuário, ou seja, o modelo de aplicação permanece o mesmo, porém o usuário não observa o efeito de recarregar a tela. Podemos observar isso nas ferramentas da Google. Em seu mecanismo de busca e carro chefe, a primeira página apresenta apenas um campo texto e por isso quando digitamos o que buscamos ela precisa ser recarregada para apresentar a lista de itens que estamos buscando. Por outro lado, no Gmail, a interação do usuário é toda baseada em um modelo de reconstruir a tela localmente, por exemplo quando estamos enviando um email para alguém, conforme vamos digitando o nome da pessoa aparece uma área de seleção com os contatos armazenados no servidor sem que para isso precise recarregar a tela, no entanto os dados tiveram que ser buscados no servidor.

Dessa forma se conhecermos o que acontece “dentro” da web fica mais fácil de entender e conviver com os detalhes de cada tecnologia de implementação. No final elas trocam texto com seus servidores chamando seus componentes de execução. Se essa visão estiver clara, o programador vai perceber que passa a desenvolver em nível mais abstrato onde apenas descreve como a tela deve ser carregada.