Olá, tudo bom? Como vão vocês?
Este artigo é o terceiro de uma série ao qual vou ensiná-los a trabalhar com a Java Persistence API 2.0 (JPA 2.0). Dúvidas e críticas são bem vindas.
Conhecendo as anotações básicas em uma Entidade
Como pudemos perceber no artigo JPA 2.0 na Prática – Parte 2, as entidades representam as tabelas encontradas no banco de dados. Entretanto, nem sempre refletirão exatamente o modelo da entidade relacional encontrado no banco de dados mas, com certeza, são suas representações, só que em formato de objetos – o que chamamos de O/R (Object-to-Relational).
Anotando uma classe simples
Entidades são classes Java Simples (POJOs) na JPA. Ao fazer a Entidade Bean Categoria, em JPA 2.0 na Prática – Parte 2, adicionamos anotações que representavam certas características que deveriam ser refletidas na entidade relacional, como nome da tabela e o campo de chave primária.
A entidade Categoria é simples e possui atributos privados que são refletidos, tais como escritos na entidade, em seu equivalente, na tabela da entidade relacional.
A classe Categoria também é formada por métodos públicos getters e setters, tais como são os JavaBeans comuns.
Para que uma classe, como no caso da Categoria criada, não seja considerada um simples JavaBean e sim uma Entidade Bean da Java Persistence, precisamos de duas anotações básicas:
javax.persistence.Entity – Informa que classe é uma Entidade;
javax.persistence.Id – Informa o atributo na classe que será utilizado como chave primária;
Na ausência das demais anotações, o nome da tabela e das colunas existentes na entidade relacional, do banco de dados, são tidos pelo provedor de persistência como sendo exatamente iguais aos encontrados na Entidade Bean.
Desta forma, se mapearmos uma entidade bean como na Listagem 1, teremos uma tabela no banco de dados, procurada ou criada pelo provedor de persistência similar ao da Listagem 2.
Listagem 1 – Entidade Bean Categoria
package br.com.integrator;
import java.io.Serializable;
import java.lang.*;
import javax.persistence.*;
@Entity
public class Categoria implements Serializable {
@Id
private Long id;
private String categoria;
private String descricao;
//getters e setters omitidos
}
Listagem 2 – A tabela Categoria no banco de dados MySQL
create table Categoria( id bigint(20) primary key not null, categoria varchar(255), descricao varchar(255) );
Anotações @Table, @Column e @Id
Se necessitarmos definir o nome de uma tabela, como foi feito em JPA 2.0 na Prática – Parte 2, utilizamos a notação @Table, de javax.persistence.Table. O mesmo também pode ser feito para dar nomes a colunas, utilizando a anotação @Column, de javax.persistence.Column. Desta forma, se fizermos a modificação na classe Categoria, como na Listagem 3, teremos o resultado mostrado na Figura 1.
Listagem 3 – Utilizando as anotações @Table e @Column
@Entity
@Table(name="categorias")
public class Categoria implements Serializable {
@Id
@Column(name="categoria_id", nullable=false, columnDefinition="integer")
private Long id;
@Column(name="categoria_nome", length=30, nullable=false)
private String categoria;
@Column(columnDefinition="text")
private String descricao;
//getters e setters omitidos
}
Figura 1 – Anotações da Entidade Categoria refletida na tabela categorias no banco de dados
A Listagem 3 exibe os atributos contidos na anotação @Column, que são úteis no mapeamento de uma tabela equivalente no banco de dados. Temos os seguintes atributos utilizados no exemplo:
name – Nome da coluna na tabela do banco de dados, recebe como valor uma String;
columnDefinition – Recebe uma String com o tipo que será usado pela coluna equivalente na tabela do banco de dados. Um exemplo é a coluna descricao que possui columnDefinition como text.
length – Alguns tipos de colunas nas tabelas dos bancos de dados possuem um valor variável de largura do campo. Um exemplo são os campos varchar(). No MySQL, se não definirmos um valor de largura para o tipo varchar, este é criado em seu tamanho máximo de caracteres, que no caso é 255. Cada banco de dados possui um limite máximo em seu determinado tipo.
nullable – Recebe um valor booleano cujo o padrão é true, caso não declarado. Se false, este campo é obrigatório.
A anotação @Id, mostrada pela primeira vez em JPA 2.0 na Prática – Parte 2, possui uma anotação dependente, chamada de @javax.persistence.GeneratedValue. Esta anotação é utilizada quando desejamos que o provedor de persistência gere as chaves para nós.
A anotação @GeneratedValue possui um atributo chamado strategy, que define a estratégia de geração de valores incrementados. A estratégia mais comum é javax.persistence.GeneratorType.AUTO, mas no exemplo visto na parte 2 dos artigos sobre JPA, utilizamos javax.persistence.GeneratorType. IDENTITY.
Entretanto, alguns gerenciadores de banco de dados, como Oracle, possuem uma estrutura predefinida para gerar valores seqüenciais. Nestes casos, utilizamos a anotação @javax.persistence.SequenceGenerator. A Listagem 4 exibe esta anotação utilizada em um banco de dados ORACLE.
Listagem 4 – Utilizando a anotação @SequenceGenerator
@Entity
@Table(name="CATEGORIAS_TABLE")
@SequenceGenerator(name="CATEGORIA_SEQUENCE", sequenceName="MINHA_SEQ", initialValue=1, allocationSize=1)
public class Categoria implements Serializable {
@Id
@GeneratedValue(strategy=GenerationType.SEQUENCE, generator="CATEGORIA_SEQUENCE")
private Long id;
@Column(length=30, nullable=false)
private String categoria;
@Column(length=3500)
private String descricao;
//getters e setters omitidos
}
A anotação @SequenceGenerator possui um atributo name do qual é referenciado em @GeneratedValue, através do atributo generator. A anotação @GeneratedValue também precisa utilizar, no atributo strategy, o valor GenerationType.SEQUENCE.
O nome da sequence gerada no Oracle, por exemplo, seria a colocada no atributo sequenceName, de @SequenceGenerator.
Também, em @SequenceGenerator temos os atributos initialValue e allocationSize[1]. O resultado de uma sequence criada no banco de dados Oracle, com estas informações fornecidas pela entidade, através da JPA, pode ser vista na Figura 2.
Figura 2 – Sequencia gerada no Oracle XE e visualizada pelo Browser de Objetos
Atenção: A forma como adicionamos a anotação @javax.persistence.Id na Entidade determina como podemos declarar as demais anotações no Bean. Se colocarmos a anotação @Id nos atributos, as demais precisam estar nos atributos. Se colocarmos no método getter, as demais precisarão estar nos métodos getters.
Na próxima parte
Na Parte 3 da série JPA 2.0 na Prática aprendemos as anotações básicas que podemos utilizar para criar uma entidade bean e tê-la refletida em uma tabela no banco de dados relacional.
[1] Sem o atributo allocationSize em 1, o Oracle, por exemplo, usando o Hibernate como provedor JPA, criará uma sequence com valor de 50 em 50.
(New Driver Definition).
