Hibernate: Persistindo datas no Java sem incompatibilidade de tipos

Motivaç�o

Com o lançamento da API Date and Time, cujo objetivo principal � simplificar a manipulaç�o de datas, um pequeno problema surgiu: os novos tipos de dados n�o eram completamente suportados pela especificaç�o da JPA 2.1. Dessa forma, classes como LocalDate podem ser utilizadas como atributo de uma entidade, mas devido � incompatibilidade, n�o � poss�vel anotar esses atributos com @Temporal e armazen�-los no banco de dados.

Como o lançamento do JPA 2.2 ainda n�o ocorreu (at� o momento da publicaç�o desse artigo), uma das implementaç�es da JPA criou uma soluç�o pr�pria. O Hibernate 5 tornou poss�vel o mapeamento de classes da API de datas do Java 8 com os tipos JDBC. A Figura 1 mostra o mapeamento criado entre os novos tipos do pacote java.time e os tipos JDBC.

Figura 1. Mapeamento de tipos da java.time e do JDBC

Nesse artigo, veremos como utilizar a API de datas do Java 8 juntamente com o Hibernate 5.

Passo 1: Criar o projeto

Para o exemplo que desenvolveremos aqui, vamos utilizar o MySQL 5.7.11, o NetBeans 8.2 e, com eles, criaremos uma aplicaç�o exemplo simples, contendo apenas uma entidade, chamada Ordem, cujo script SQL para criaç�o no banco de dados � apresentado na Listagem 1.

Listagem 1. Script para criaç�o da tabela Ordem


CREATE TABLE ordem (
 ordemId bigint(20) NOT NULL AUTO_INCREMENT,
 OrdemProduct varchar(255) DEFAULT NULL,
 ordemCreated timestamp NULL DEFAULT NULL,
 ordemDate date DEFAULT NULL,
 ordemTime time DEFAULT NULL,
 ordemStart timestamp,
 ordemEnd timestamp,
 ordemTimeExecuted bigint(20), 
 ordemTimeZonedTime timestamp,
 PRIMARY KEY (ordemId) );

Ap�s criar o banco de dados, crie um novo projeto Java, chamado hibernate-time, e adicione as bibliotecas referentes ao Hibernate Core em seu classpath. A vers�o do Hibernate que faremos uso � a 5.2.6.Final, a mais recente no momento da escrita desse material.

Passo 2: Mapear as classes do dom�nio da aplicaç�o

Para definir o mapeamento objeto/relacional da entidade do dom�nio da aplicaç�o, adicione ao projeto uma nova classe chamada Ordem, cujo c�digo pode ser visto na Listagem 2.

Listagem 2. C�digo da classe Ordem


 //imports omitidos   

 @Entity
 @Table(name = "ordem")
 public class Ordem {
     
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long ordemId;

    private String OrdemProduct;
    private LocalDate ordemDate;
    private LocalTime ordemTime;
    private LocalDateTime ordemCreated;
    private ZonedDateTime ordemTimeZonedTime;
    private Instant ordemStart;
    private Instant ordemEnd;
    private Duration ordemTimeExecuted;

   //construtores e m�todos gets e sets omitidos  
 }

Nesse exemplo, fizemos uso dos novos tipos da API Java Time para definir os atributos da classe. LocalTime, LocalDate e LocalDateTime, provavelmente, s�o as classes mais utilizadas ao lidar com essa API, e representam, respectivamente, uma data, um hor�rio e os dois juntos. A classe ZonedDateTime representa uma data e hora em um fuso hor�rio espec�fico. J� a classe Instant, diz respeito a um ponto no tempo com a precis�o de nanosegundos. A classe Duration, por sua vez, geralmente utiliza internamente a classe anterior e serve para medir um intervalo de tempo em nanosegundos.

As anotaç�es presentes nessa classe s�o: @Entity e @Table, que indicam que os objetos dessa classe ser�o persistidos no banco de dados; al�m de @GeneratedValue e @Id, para criaç�o de uma chave prim�ria para o objeto.

O destaque aqui fica para a aus�ncia da anotaç�o @Temporal nos demais atributos. O Hibernate 5 tem informaç�es suficientes para inferir o mapeamento correto da propriedade dentro do banco. Com isso, ele l�, por exemplo, o tipo LocalDateTime e, corretamente, insere o dado no banco de dados como um timestamp.

Passo 3: Configurar o acesso ao banco de dados

Agora, � necess�rio informar ao Hibernate onde est� o banco de dados e as informaç�es necess�rias para se conectar a ele. Portanto, crie um arquivo XML de nome hibernate.cfg, na pasta src do projeto, e defina nele as configuraç�es comumente utilizadas.

O passo seguinte � codificar a classe utilit�ria HibernateUtil, que far� a ligaç�o entre o arquivo XML e o banco de dados, disponibilizando uma inst�ncia de SessionFactory para obter um objeto de sess�o. A Listagem 3 mostra a implementaç�o dessa classe.

Listagem 3. C�digo da classe HibernateUtil


 //imports omitidos

 public class HibernateUtil {

  private static SessionFactory sessionFactory;

  public static SessionFactory getSessionFactory() {
    if (sessionFactory == null) {         
       Configuration configuration = new Configuration().configure();           
       sessionFactory = configuration.buildSessionFactory();
     }
    return sessionFactory;
   }
  }

Passo 4: Criar a classe DAO

Com a classe de persist�ncia mapeada com as anotaç�es do Hibernate, o arquivo de configuraç�o e a conex�o com o banco de dados implementados, partiremos para a criaç�o do DAO, OrdemDAO, respons�vel por disponibilizar as operaç�es de persist�ncia. Seu c�digo pode ser visto na Listagem 4.

Listagem 4. C�digo da classe OrdemDAO


 //imports omitidos...

 public class OrdemDAO { 

     private static SessionFactory factory; 

     public OrdemDAO() { 
           factory = HibernateUtil.getSessionFactory();  
     } 

     public void addOrdem(Ordem ordem) { 
           Session session = factory.openSession(); 
           Transaction tx = null;
           Integer cod_aluno = null; 

           try { 
                  tx = session.beginTransaction(); 
                  session.save(ordem); 
                  tx.commit();
           } 
           catch (HibernateException e) { 
                  if (tx != null) {
                         tx.rollback(); 
                  } 
                  e.printStackTrace(); 
           } finally { 
                  session.close(); 
           } 
     }

Linhas 7 a 9: Obtemos uma inst�ncia da sess�o a partir da classe utilit�ria HibernateUtil;
Linhas 11 a 29: Definimos o m�todo de inserç�o de um objeto do tipo Ordem no banco de dados.

Passo 5: Testar a aplicaç�o

Por fim, chega o momento de testar a aplicaç�o. A execuç�o da classe Main, apresentada na Listagem 5, permite visualizar as inserç�es no banco de dados.

Na linha 5 � criado um objeto do tipo Ordem e em seguida seus atributos s�o preenchidos. Esse objeto � persistido no banco de dados atrav�s da chamada ao m�todo addOrdem(), da classe OrdemDAO.

Listagem 5. Implementaç�o da classe de teste, Main


 //imports omitidos�

 public class Main {
    public static void main(String[] args) {       
            Instant inicio = Instant.now();
            Ordem ordem1=new Ordem();
            ordem1.setOrderProduct("Internet Link");
            ordem1.setOrderDate(LocalDate.now());
            ordem1.setOrdemTime(LocalTime.now());
            
            ZoneId fusoHorario = ZoneId.of("America/Sao_Paulo");
            ZonedDateTime agoraEmSaoPaulo = ZonedDateTime.now(fusoHorario);
            ordem1.setOrdemTimeZonedTime(agoraEmSaoPaulo);
            ordem1.setOrderCreated(LocalDateTime.now());  
            ordem1.setOrdemStart(inicio);
            Instant fim = Instant.now();
            ordem1.setOrdemStart(fim);
            ordem1.setOrdemTimeExecuted(Duration.between(inicio, fim));
            OrdemDAO ord = new OrdemDAO();
            ord.addOrdem(ordem1);
     }
 }

A Figura 2 mostra a vis�o do banco de dados ap�s a execuç�o da classe de teste. Veja que os valores definidos foram inseridos corretamente no banco de dados.

Figura 2. Banco de dados ap�s a execuç�o da classe Main

O Hibernate 5, como vimos, simplificou o trabalho com as classes da API de datas do Java 8, evitando a necessidade de efetuar v�rias convers�es a fim de manter a compatibilidade entre os tipos de dados dos objetos e do banco.