Artigos Java 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.

Mapeamento de tipos da java.time e do 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.

Banco de dados após a execução da classe Main
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.