Hibernate: (Introdução à) Persistência de Objectos em Bases de Dados Relacionais

1.1 Objectivo

Manter, numa base de dados relacional, o estado de uma aplicação orientada a objectos feita em Java, com um mínimo de alterações ao modelo de programação.

1.2 Características do Hibernate

O Hibernate é uma framework de open source para persistência de objectos em bases de dados relacionais. Na génese deste tipo de ferramentas está a diferença entre os paradigmas relacional (usado pela maioria dos Sistemas de Gestão de Bases de Dados) e orientado a objectos (usado pelas aplicações Java), e a necessidade de estabelecer uma correspondência entre os dois modelos de dados (mapeamento objecto/relacional). Este mapeamento é posteriormente utilizado pelo Hibernate para suportar a leitura e escrita de objectos em suporte persistente no contexto de uma unidade de trabalho.¹

2.1 Unidade de trabalho

  Uma unidade de trabalho regista todas as operações de uma transacção de negócio que podem afectar a base de dados. Quando uma unidade de trabalho termina com sucesso, as operações registadas são propagadas para a base de dados. Se a unidade de trabalho abortou, todas as operações registadas são descartadas, como se a unidade de trabalho nunca tivesse existido.

2.2 Modelo de domínio

O modelo de domínio de uma aplicação é o conjunto de classes (dados e comportamento), e suas relações, que representa os conceitos manipulados pela aplicação. É este conjunto de classes que necessita de ser mantido de forma persistente através de uma framework como o Hibernate.

2.3 Mapeamento Objecto/Relacional

Esta correspondência é feita através de meta-informação associada às classes do modelo de domínio, através de anotações e/ou de ficheiros de configuração em XML.

Sempre que um objecto persistente é acedido pela primeira vez, o Hibernate usa a meta-informação associada à sua classe para:

• gerar as query SQL que obterão da base de dados o registo que contém os dados do objecto;
• preencher os atributos do objecto com base no registo lido da base de dados.

Quando uma unidade de trabalho termina, a meta-informação sobre a correspondência entre o modelo de domínio e a sua representação relacional é utilizada pelo Hibernate para fazer as validações necessárias e gerar as queries SQL que efectuarão as alterações necessárias aos registos da base de dados.

3.1 Declarar uma classe persistente

1. Identificar classe como persistente

   Para identificar uma classe como persistente basta anotá-la com @Entity, como se mostra no exemplo:

    @Entity
    public class Airplane {
        ...
    }
   

   Por omissão, o Hibernate associa a classe persistente a uma tabela com o mesmo nome. Caso este comportamento não seja desejável, é possível definir a tabela onde serão guardados os dados dos objectos usando a anotação @Table:

    @Entity
    @Table(name=AIRPLANE_DATA)
    public class Airplane {
        ...
    }
   

   Documentação: http://www.hibernate.org/hib_docs/annotations/reference/en/html/entity.html#entity-mapping-entity

2. Definir atributo identificador da classe.

   Para definir um atributo como identificador da classe é necessário anotá-lo com @Id e, caso se queiram identificadores gerados automaticamente pelo Hibernate (fortemente recomendado), @GeneratedValue. Seguindo as regras previamente descritas, o atributo não deve ser de um tipo primitivo (por exemplo, Long) e o seu nome deve seguir uma convenção (por exemplo, atributos identificadores têm sempre o nome id):

    @Entity
    public class Airplane {
        @Id @GeneratedValue(strategy=GenerationType.AUTO)
        private Long id;
   
        ...
    }
   

   Documentação: http://www.hibernate.org/hib_docs/annotations/reference/en/html/entity.html#entity-mapping-identifier

3. Actualizar o ficheiro de configuração do Hibernate

   Para dar a conhecer ao Hibernate o novo tipo de objectos persistentes é necessário alterar o ficheiro hibernate.cfg.xml para que inclua a classe recém-anotada.

    ...
   
    <hibernate-configuration>
        <session-factory>
            ...
            <mapping class="examples.hibernate.domain.Airplane" />
            ...
        </session-factory>
    </hibernate-configuration>
   

   Documentação: http://www.hibernate.org/hib_docs/annotations/reference/en/html/ch01.html#setup-configuration

3.2 Mapear atributos simples

Todos os atributos não estáticos e não transientes de um objecto persistente são por omissão persistentes, excepto se anotados com @Transient. É possível identificar explicitamente um atributo como persistente utilizando a anotação @Basic (que permite, adicionalmente, definir a politica de carregamento de atributos).

O Hibernate suporta directamente o mapeamento de todos os tipos primitivos do Java, suas classes wrapper e qualquer classe serializável.

Valores Enum podem ser representados numa coluna quer como ordinais (é guardado o ordinal do tipo enumerado), quer como texto (é guardada a representação textual do tipo). Por omissão é utilizada a representação ordinal para enumerados, mas pode definir-se explicitamente o tipo de representação (ORDINAL ou STRING) através da anotação @Enumerated.

Em Java a precisão de um atributo temporal não está definida, pelo que a mesma classe (java.util.Date) pode representar uma data, um instante ao longo do dia ou ambos (um instante numa dada data). A semântica do atributo temporal é no entanto relevante para a representação em base de dados, pelo que se pode usar a anotação @Temporal para a definir (DATE para uma data, TIME para um instante ao longo do dia e TIMESTAMP para um instante numa dada data). Por omissão, o Hibernate assume a precisão máxima para atributos temporais.

Caso se pretenda guardar uma sequência de bytes ou caracteres de grande dimensão pode usar-se a anotação @Lob do Hibernate.

 @Entity
 public class Airplane {
     ...

     private static int airplaneCount;        // transient property

     private transient double weightInPounds; // transient property

     @Transient
     private String currentPilot;             // transient property

     private long wingSpan;                   // persistent property

     @Basic
     private long length;                     // persistent property

     @Enumerated(EnumType.STRING)
     private AirplaneState state;             // enum persisted as String in database

     @Temporal(TemporalType.DATE)
     private Date lastMaintenance;            // persistent property

     @Lob
     private String specs;                    // persistent property persisted as a CLOB

     ...
 }

 CREATE TABLE Airplane (
     ...
     wingSpan        BIGINT NOT NULL,
     length          BIGINT NOT NULL,
     state           VARCHAR(255),
     lastMaintenance DATE,
     specs           TEXT
     ...
 );

No exemplo anterior, os valores dos atributos airplaneCount (atributo de classe), weightInPounds (um atributo transiente) e currentPilot (anotado com @Transient) não serão guardados na base de dados. wingSpan e length são atributos persistentes que serão guardados na base de dados. O atributo maintenanceStatus é um enumerado, e será guardada na base de dados a sua representação textual. Finalmente o atributo lastMaintenance representa o dia da última manutenção, pelo que apenas será guardada na base de dados a informação relativa à data (não sendo relevante o instante em que ocorreu).

Documentação: http://www.hibernate.org/hib_docs/annotations/reference/en/html/entity.html#d0e304

 @Entity
 public class Airplane {
     ...

     @Column(name="WING_SPAN")
     private long wingSpan;

     ...
 }

3.3 Mapear associações entre classes persistentes

  Quando existem associações entre um (ou mais) objecto(s) persistente(s) e um outro objecto persistente, um dos objectos (objecto origem) guarda uma referência para o outro (objecto destino). No modelo relacional isto equivale à tabela que corresponde ao objecto origem ter uma coluna com uma chave estrangeira para a tabela que corresponde ao objecto destino, cuja declaração é suportada pela anotação @JoinColumn.

Por omissão é gerada uma coluna cujo nome é composto pelo nome do atributo, no objecto origem, que mantém a referência para o objecto destino, seguido do carácter _ (underscore), seguido do nome do atributo identificador da classe destino.

 @Entity
 public class Airplane {
     ...

     @OneToOne
     @JoinColumn(name="engineNumber")
     private Engine engine;

     ...
 }

 @Entity
 public class Engine {
     @Id
     private Long id;

     ...
 }

 CREATE TABLE Airplane (
     ...
     engineNumber BIGINT  UNIQUE  REFERENCES Engine (id),
     ...
 );

 CREATE TABLE Engine (
     id           BIGINT  NOT NULL  PRIMARY KEY,
     ...
 );

 @Entity
 public class Airplane {
     ...

     @OneToOne
     @JoinColumn(name="engineNumber")
     private Engine engine;

     ...
 }

 @Entity
 public class Engine {
     @Id
     private Long id;

     @OneToOne(mappedBy="engine")
     private Airplane airplane;
     ...
 }

4.1 Criação

Um objecto recém-criado encontra-se no estado transiente, sendo necessário associá-lo a uma unidade de trabalho do Hibernate para o tornar persistente. Esta associação é feita através do método save de uma instância de Session:

     ...
     Airplane airplane = new Airplane("Air Force 1", ...);
     session.save(airplane);                    // make object persistent
     ...

Nota: Uma vez que foi definido um gerador automático de identificadores para Airplane, só após a invocação do método save será atribuido o identificador à instância do objecto.

Documentação: http://www.hibernate.org/hib_docs/v3/reference/en/html/objectstate.html#objectstate-makingpersistent

4.2 Leitura

  O Hibernate permite obter objectos persistentes através de dois mecanismos complementares:

• carregamento directo, através do identificador do objecto que se pretende ler;
• pesquisa, usando restrições sobre os valores das propriedades dos objectos que se pretendem³.

  Nota: Num programa orientado a objectos as associações entre objectos são o mecanismo natural para obter referências para outros objectos. Embora se possam invocar aspectos de eficiência de execução para justificar o carregamento de objectos através do atributo identificador ou de pesquisa na base de dados, os custos a nível de manutenção do código aumentam substancialmente visto haver uma maior dependência do mecanismo de persistência/acesso. Por esta razão, o uso dos mecanismos de acesso a objectos fornecidos pelo Hibernate deve ser bem ponderado (idealmente apenas os objectos raiz do grafo de objectos precisam de ser carregados directamente).

Para obter um objecto persistente do qual sabemos previamente o identificador podemos usar o método load de uma instância de Session. O método load recebe como argumentos a classe a ler e o identificador a utilizar e devolve um novo objecto persistente dessa classe, com os dados obtidos da base de dados.

     ...
     Long id = new Long(554);                  // load does not accept primitive types
     Airplane plane = (Airplane) session.load(Airplane.class, id);
     ...

Nota: Se não existir um registo na tabela Airplane da base de dados com o identificador 554, o método load lança uma excepção.

Documentação: http://www.hibernate.org/hib_docs/v3/reference/en/html/objectstate.html#objectstate-loading

4.3 Modificação

Ao manipular um objecto persistente no contexto de uma unidade de trabalho, as alterações serão automaticamente detectadas e persistidas quando a unidade de trabalho terminar.

Documentação: http://www.hibernate.org/hib_docs/v3/reference/en/html/objectstate.html#objectstate-modifying

4.4 Eliminação

Um objecto persistente pode ser tornado transiente (eliminado da base de dados) através do método delete na classe Session. É no entanto importante referir que as referências em memória se mantêm, pelo que se mantém a necessidade de eliminar o objecto (agora transiente) do grafo de objectos da aplicação².

     ...
     // obtain plane to remove
     Airplane plane = (Airplane) session.load(Airplane.class, new Long(554));

     // obtain airline
     Airline airline = (Airline) session.load(Airline.class, new Long(1));

     airline.removeAirplane(plane);             // remove all references to plane

     session.delete(plane);                     // make object transient
     ...

No exemplo, existe uma única companhia aérea (singleton), ao qual pertence o avião que pretendemos remover. Para eliminar o avião é necessário:

• removê-lo dos aviões da companhia aérea;
• tornar o objecto transiente, para que deixe de ter uma representação persistente.

Documentação: http://www.hibernate.org/hib_docs/v3/reference/en/html/objectstate.html#objectstate-deleting