CURSO - JPA - Parte 2

Os primeiros passos na JPA

Com o ambiente configurado, agora podemos  configurar a JPA e dar nossos primeiros passos em sua execução, entendendo como funciona e o que podemos fazer.
Esta parte do artigo está baseada na configuração, criação da entidade e manipulação básica do banco de dados.

Configurando o arquivo persistence.xml

Ao criar o projeto, também foram criados um diretório e arquivo. Note o arquivo chamado persistence.xml,  encontrado no diretório META-INF, dentro de src.
Abra o arquivo persistence.xml e verá que o Eclipse IDE possui um editor do arquivo.
Sua estrutura básica é como mostrada na Listagem 1 abaixo:
Listagem 1 – O arquivo persistence.xml
Ela pode ser visualizada no Editor do Eclipse, em Source.

Configurando a conexão com o banco de dados

No editor do Eclipse, vá na aba Connection, em persistence.xml.
Adicionando as configurações de conexão ao persistence.xml
Adicionando as configurações de conexão ao persistence.xml
Comece alterando para Resource Local em Transaction type.
Esta pequena alteração adiciona o atributo transaction-type com o valor “RESOURCE_LOCAL” em <persistence-unit/> no arquivo persistence.xml.  O atributo transaction-type está definindo que a unidade de persistência terá sua integridade gerida  através da API local (RESOURCE_LOCAL), que é o nosso caso, onde não haverá um servidor de aplicativos Java EE por enquanto envolvido para transações JTA (Java Transaction API).
Mais abaixo, em EclipseLink Connection Pool, clique em Populate from Connection.
Adicionando os parâmetros de conexão no arquivo persistence.xml
Adicionando os parâmetros de conexão no arquivo persistence.xml
Ao abrir a caixa de diálogo Connection Selection, selecione a conexão do MySQL que fez na criação do projeto e confirme.
Conexão do MySQL feita na criação do Projeto
Conexão do MySQL feita na criação do Projeto
Ao retornar ao arquivo persistence.xml, os dados pertencentes ao banco de dados estarão preenchidos.
Configurações para a conexão ao banco de dados
Configurações para a conexão ao banco de dados
Esta mudança da conexão alterou o arquivo persistence.xml da seguinte forma:
Na JPA 2.0, algumas propriedades foram padronizadas. As propriedades que foram adicionadas ao arquivo persistence.xml são padrões para se conectar ao banco de dados. Veja o que significa cada uma delas:
  • javax.persistence.jdbc.driver — o nome do driver da classe totalmente qualificado
  • javax.persistence.jdbc.url — URL específico do driver
  • javax.persistence.jdbc.user — usuário do banco de dados para a conexão
  • javax.persistence.jdbc.password — senha do banco de dados para a conexão
Vá agora até a aba Logging e, em Logging level, altere para All. Isso tornará visível todas as operações que fizemos, utilizando a JPA, no Console do Eclipse.
Alterando o nível de logging para ALL
Alterando o nível de logging para ALL
Infelizmente, nem todas as propriedades de persistence.xml foram padronizadas. A seguinte propriedade foi adicionada ao arquivo:
<property name=“eclipselink.logging.level” value=“ALL”/>
Ainda em persistence.xml, vá até a aba Schema Generation.  Nesta aba temos DDL generation type. Como não fizemos nenhuma tabela no banco de dados, teremos que criá-la ao executar nossa primeira entidade.
Temos três opções:
  • None – não ocorre nada;
  • Create Tables – cria as tabelas baseando-se nas informações contidas nas entidades;
  • Drop and Create Tables – exclui e cria as tabelas através das informações contidas nas entidades;
Para o nosso trabalho inicial, vamos manter um ciclo de criação e exclusão,  selecionando Drop and Create Tables.
Gerando tabelas através da configuração de persistence.xml
Gerando tabelas através da configuração de persistence.xml
As últimas alterações incluíram a seguinte propriedade:
<property name=“eclipselink.ddl-generation” value=“drop-and-create-tables”/>
Com estas mudanças, temos tudo pronto para trabalhar com a JPA.

Criando sua primeira entidade

Clique com o direito do mouse sobre src, do seu projeto JPA. Selecione no menu de contexto New>Entity.
Criando uma entidade JPA no Eclipse IDE
Criando uma entidade JPA no Eclipse IDE
Na caixa de diálogo New JPA Entity, preencha Java package Class name, no caso: br.com.integrator e Categoria, respectivamente. Mantenha Entity em Inheritance e clique no botão Next.
Criando a classe/entidade Categoria
Criando a classe/entidade Categoria
Na segunda etapa, definimos o nome da tabela que será utilizada pela entidade Categoria e seus respectivos campos/colunas.
Segunda etapa da criação da Entidade JPA
Segunda etapa da criação da Entidade JPA
O Eclipse IDE, através do seu assistente, irá manter o nome da tabela como padrão existente ao nome da entidade. Desmarque Use default e altere para categorias em Table name.
Esta pequena alteração informa que a entidade Categoria está ligada a tabela categorias do banco de dados.
Alteração do nome da tabela para o banco de dados
Alteração do nome da tabela para o banco de dados
Abaixo você vai encontrar Entity fields. Clique em Add para adicionar as os atributos que existirão na entidade Categoria e seus respectivos tipos.

Detalhe da adição de atributos na entidade Categoria
O diálogo Entity Fields possui Type para colocar o tipo ( que também é acessível com Ctrl+Space) e o nome.
Adicionando um atributo
Adicionando um atributo
Os atributos da entidade são mostrados na Figura abaixo:
Atributos da entidade Categoria
Atributos da entidade Categoria
Veja que foi marcado id como key. Isso fará com que este atributo/campo seja a chave primária.
Diálogo completamente preenchido
Diálogo completamente preenchido
Com tudo preenchido, clique no botão Finish para gerar a classe Categoria com as devidas anotações que a fará uma Entidade da JPA.
A classe/entidade Categoria possui a estrutura como mostrado na Listagem 2 após sua geração:
Listagem 2 – A entidade Categoria
As entidades, na especificação da JPA, são POJOS (Plain Old Java Objects ), onde podemos alocar com o operador new, assim como faríamos com qualquer outro objeto Java simples. As instâncias de uma classe do tipo entidade não se tornam persistentes até estarem associadas a um EntityManager.
No arquivo persistence.xml, verá a classe adicionada em General>Managed Classes.
Detalhe de Managed Classes em persistence.xml
Detalhe de Managed Classes em persistence.xml
No XML de persistence.xml, haverá a seguinte linha adicionada:
<class>br.com.integrator.Categoria</class>
O elemento <class/> lista explicitamente as classes que são consideradas entidades no persistence.xml.
Para finalizar, vá até a classe Categoria. Na view JPA Structure, clique em id. Marque Primary key generation na view JPA Details e selecione Identity em Strategy. Isso informa a entidade que o campo da chave primária é auto-incrementado e, portanto, gerado pela tabela do banco de dados.
Definindo a estratégia de auto-incremento no campo id da entidade
Definindo a estratégia de auto-incremento no campo id da entidade
Na classe veremos a seguinte anotação: @GeneratedValue(strategy = IDENTITY), onde IDENTITY é de javax.persistence.GenerationType.

Testando a JPA

Antes de explicar qualquer coisa, vamos fazer um teste para saber se está tudo corretamente funcionando, simplesmente chamando a persistence-unit através de uma simples classe Java com um método main().
Crie uma classe no próprio projeto JPA , chamando-a de TesteDaJPA. Coloque em um pacote diferente do qual vem usando e marque public static void main(String[] args). Confirme a criação da classe no botão Finish.
Criação da classe de testes
Criação da classe de testes
Altere a classe TesteDaJPA conforme a Listagem 3:
Listagem 3 – A classe TesteDaJPA
Execute a classe através do menu Run>Run As>Java Application.
Graças à configuração que fizemos de logging no arquivo persistence.xml (em <property name=“eclipselink.logging.level” value=“ALL”/>) , possuímos uma saída bem detalhada do que ocorreu ao gerar este simples teste.
Assim que iniciada a classe, veremos a saída contendo a conexão ao banco de dados:
Entre a saída, veremos que, devido a configuração no persistence.xml (em <property name=“eclipselink.ddl-generation” value=“drop-and-create-tables”/>) , primeiro houve uma tentativa de fazer um drop table na tabela categorias. Como não existia tal tabela, veremos este erro:
Por fim, será possível ver que ocorre a desconexão ao banco de dados.

A tabela gerada no banco de dados

Ao entrar no banco de dados, veremos que a simples classe anotada se transformou em uma tabela. Evidentemente que o POJO, sem a devida configuração no arquivo persistence.xml, antes da sua chamada pela classe executora que fizemos de teste, não teria esse poder.
A tabela gerada no MySQL
A tabela gerada no MySQL
Graças a anotação @Table, pudemos dar o nome da tabela que seria gerada, através do atributo name.

Atributos convertidos em colunas
Observe que cada atributo da classe se transformou em uma coluna na tabela. A coluna chave, tida por ID, foi gerada graças à anotação @Id. Além disso, o MySQL considerou esta coluna como auto-incrementada, ou seja, ela possui um modificador que incrementa em um toda vez que uma informação é inserida na tabela. Isso é automático e gerenciado pelo banco de dados. A anotação @GeneratedValue foi a responsável pela geração do auto-increment do MySQL.
Os tipos de cada coluna são gerados pelo similar em Java. Logo, Long se transformou em bigint e String em varchar. Cada tipo de coluna, na tabela do banco de dados, possui também um tamanho definido na sua criação. Como não especificamos isso na classe Categoria, através de anotações, a tabela foi gerada utilizando o tamanho máximo obtido pelo tipo, isso no banco de dados em questão. Logo, Long se transformou em bigint(20) e String em varchar(255).

Nenhum comentário:

Postar um comentário