1. Configurando o Hibernate para ser usado. 2. Obtendo

1. Configurando o Hibernate para ser usado.
Config. 1
Configuration cfg = new Configuration()
.addFile("Vertex.hbm.xml")
.addFile("Edge.hbm.xml");
Config. 2
Configuration cfg = new Configuration()
.addClass(eg.Vertex.class)
.addClass(eg.Edge.class);
Config. 3
Properties props = new Properties();
...
Configuration cfg = new Configuration()
.addClass(eg.Vertex.class)
.addClass(eg.Edge.class)
.setProperties(props);
Método .addFile(<Arquivo>)
Adiciona o arquivo .hbm.xml que contém o mapeamento da classe para realização da persistência na
configuração do hibernate
Médodo .addClass(<arquivo.class>)
Adiciona a classe do objeto a ser instanciado, porém é necessário o arquivo .hbm.xml que comtém o
mapeamento da classe para realização da persistência.
Método .setProperties(<arquivo de propriedades>)
Define as propriedades de conexão do banco de dados pelo arquivo de propriedades.
2. Obtendo sessão, abrindo e fechando conexão no hibernate
* Para criar uma sessão use:
SessionFactory factory = cfg.buildSessionFactory();
onde cfg é um objeto do tipo Configuration
* Para abrir uma seção
Session session = factory.openSession();
* Verificar se a sessão foi aberta
boolean session.isOpen();
* Fechando uma conexão
session.close();
3. Transações
* Para iniciar uma transação
Transaction transaction = session.beginTransaction();
* Para comitar uma transação
void transaction.commit();
* Para cancelar uma transação (Rollback)
void transaction.rollback();
Atenção: Para salvar um registro você deve usar uma transação e dar um commit, ou usar o método
abaixo (testei com o IB, e não deu muito certo)
void session.flush();
Teoricamente o session.flush() limpa o buffer da sessão e confirma a gravação das alterações.
4. Gravando, Atualizando, Excluindo e Recuperando registros (CERA)
4.1. Gravando um registro
Session session = factory.openSession();
session.save(<objeto_tabela>);
4.2. Atualizando um registro
Session session = factory.openSession();
session.update(<objeto_tabela>);
4.3. Excluindo um registro
Session session = factory.openSession();
session.delete(<objeto_tabela>);
4.4. Recuperando um registro
Session session = factory.openSession();
<classe> <variável> = (<classe>)session.load(<classe>.class, <valor da pk>);
Exemplo:
Session session = factory.openSession();
Amigo amigo = (Amigo)session.load(Amigo.class, 12);
4.5. Recuperando uma lista de registros
Session session = factory.openSession();
java.util.List lista = session.find(String query);
java.util.List lista = session.find(String query, Object[] value, Type tipo);
java.util.List lista = session.find(String query, Object value, Type tipo);
* query --> string contendo a consulta
* value --> Objeto (podendo ser um array) contendo os valores para “?” (? - parametros no JDBC)
* tipo --> Tipo de dados do Hibernate (Hibernate.STRING, Hibernate.INTEGER)
4.5.1. Exemplo de condições (linguagem de consulta do hibernate)
Exemplo 1
String stQuery = “select mate from Cat as cat join cat.mate as mate” +
“ where cat.name = ?“;
List lista = session.find(stQuery,“O GATO“,Hibernate.STRING);
Exemplo 2
String stQuery = “from Amigo as amigo where amigo.nome = “FULANO””;
List amigo = session.find(stQuery);
*** a linguagem é igual ao SQL Ansi99.
5. Criando consultas com a interface Query
5.1. Criando uma query:
Query q = sess.createQuery("from Amigo amigo");
List amigo = q.list();
//Cria a consulta
//Retorna uma lista dos resultados
5.2. Criando uma query parametrizada
/* parametro nomeado (preferencial) */
Query q = sess.createQuery("from Amigo amigo where" +
"amigo.nome = :name");
q.setString("name", "Jose");
Iterator amigo = q.iterate(); or List amigo = g.list();
//Cria a query
//Define valor do parametro
//Recupera a lista de reg.
/* parametro posicionado */
Query q = sess.createQuery("from Amigo amigo where" +
"amigo.nome = ?");
//Cria a query
q.setString(0, "Jose");
//Define valor do parametro
Iterator amigo = q.iterate(); or List amigo = g.list(); //Recupera a lista de reg.
/* lista de parametros */
List params = new ArrayList();
params.add("Jose");
params.add("Maria");
Query q = sess.createQuery("from Amigo amigo where" +
"amigo.nome in (:namesList)");
q.setParameterList("namesList", params); //Define valor da lista de
List amigo = g.list();
//Recupera a lista de reg.
parametros
public Query createQuery(String queryString) throws HibernateException
Parameters:
queryString - String contendo a a consulta do hibernate
5.3. Consultas em SQL nativo use createSQLQuery().
List amigo = session.createSQLQuery(
"SELECT {amigo.*} FROM Amigo AS {amigo} WHERE amigo.nome = 'Jose'",
"amigo",
Amigo.class).list();
String sql = "select cat.originalId as {cat.id}, cat.mateid as {cat.mate}, " +
" cat.sex as {cat.sex}, cat.weight " +
" from cat_log cat where {cat.mate} = :catId"
List loggedCats = session.createSQLQuery(sql, "cat", Cat.class)
.setLong("catId", catId)
.list();
* o {cat.id} representa a propriedade da classe que representa o campo.
* o {amigo.*} diz que todos os campos da tabela amigo, tem o mesmo nome das propriedades da classe
Amigo.
public Query createSQLQuery (String sql,
String returnAlias,
Class returnClass)
Parameters:
sql - consult em SQL
returnAlias - alias da tabela entre { } dentro do SQL que representa a classe.
returnClass - Classe de retorno dos dados da consulta.
public Query createSQLQuery (String sql,
String[] returnAliases,
Class[] returnClasses)
Parameters:
sql - consult em SQL
returnAliases - conjunto de alias da tabela entre { } dentro do SQL que
representa a classe.
returnClasses - conjunto de classes de retorno dos dados da consulta.
5.4. Filtrando coleções (Collection session.filter();)
Aplica um filtro em uma coleção persistente. Um filtro é uma consulta do
Hibernate.
Collection blackKittens = session.filter(pk.getKittens(),
"where this.color = ?",
Color.BLACK,
Hibernate.enum(Color.class));
public Collection filter(Object collection,
String filter) throws HibernateException
Parameters:
collection - a persistent collection to filter
filter - a filter query string
public Collection filter (Object collection,
String filter,
Object value,
Type type) thows HibernateException
Parameters:
collection - a persistent collection to filter
filter - a filter query string
value - a value to be witten to a "?" placeholder in the query string
type - the hibernate type of value
public Collection filter (Object collection,
String filter,
Object[] values,
Type[] types) thows HibernateException
Parameters:
collection - a persistent collection to filter
filter - a filter query string
values - a list of values to be written to "?" placeholders in the query
types - a list of Hibernate types of the values
6. Arquivo de Configuração (.hbm.xml)
6.1. Declaração do Mapeamento.
Exemplo
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 2.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-2.0.dtd">
<hibernate-mapping package="eg">
<class name="Cat" table="CATS" discriminator-value="C">
<id name="id" column="uid" type="long">
<generator class="hilo"/>
</id>
<discriminator column="subclass" type="character"/>
<property name="birthdate" type="date"/>
<property name="color" not-null="true"/>
<property name="sex" not-null="true" update="false"/>
<property name="weight"/>
<many-to-one name="mate" column="mate_id"/>
<set name="kittens">
<key column="mother_id"/>
<one-to-many class="Cat"/>
</set>
<subclass name="DomesticCat" discriminator-value="D">
<property name="name" type="string"/>
</subclass>
</class>
<class name="Dog">
<!-- mapping for Dog could go here -->
</class>
</hibernate-mapping>
6.1.1. hibernate-mapping
<hibernate-mapping
schema="schemaName"
default-cascade="none|save-update"
auto-import="true|false"
package="package.name"
/>
1.
2.
3.
(1)
(2)
(3)
(4)
(optional): Nome do schema do database.
(optional - defaults to none): Estilo cascata (cascade style) padrão.
auto-import (optional - defaults to true): especifica se pode usar um nome de classe (definidas neste
mapeamento) não adequado na linguagem de consulta.
4. package (optional): Especifica um prefixo do pacote para assumir um nome de classe não qualificado no
documento de mapeamento.
schema
default-cascade
6.1.2. class
Declaração da classe persistente use class
<class
name="ClassName"(1)
table="tableName“(2)
discriminator-value="discriminator_value"(3)
mutable="true|false“(4)
schema="owner" (5)
proxy="ProxyInterface" (6)
dynamic-update="true|false"(7)
dynamic-insert="true|false"(8)
select-before-update="true|false"(9)
polymorphism="implicit|explicit"(10)
where="arbitrary sql where condition"(11)
persister="PersisterClass"(12)
batch-size="N"(13)
optimistic-lock="none|version|dirty|all"(14)
lazy="true|false"(15)
/>
1.
2.
3.
name:
nome completo e qualificado de uma classe Java de uma classe ou interface persistente.
Nome da tabela no banco de dados.
discriminator-value (opcional - padrão para o nome da classe): Um valor para distinguir subclasses
individuais. Usado para comportamento polimorfo. Aceita valores inclusive null e not null.
4. mutable (opcional, padrão true): Especifica se a instancia da classe é ou não mutante.
5. schema (opcional): Sobrepõe o nome do Schema specificado no elemento raíz (<hibernate-mapping>).
6. proxy (opcional): Especifica uma interface para uso de inicialização de proxies lentos. Você possivelmente
especifica o nome da propria classe.
7. dynamic-update (opcional, padrão false): Especifica que o SQL de UPDATE Somente será gerado em runtime
e contendo apenas as colunas que tiveram seus dados alterados.
8. dynamic-insert (opcional, padrão false): Especifica que o SQL de INSERT Somente será gerado em runtime
e conterá apenas os valores das colunas com valores diferentes de null.
9. select-before-update (opcional, padrão false): Especifica se o Hibernate deverá executar um SQL para
atualizar os registros para ter certeza de que o objeto foi atualizado.
10.polymorphism (opcional, padrão implicit): Determina se será usado uma consulta polimorfa implicita ou
explicita.
11.where (opcional) especifica com uma clausula WHERE, uma condição para trazer os objetos desta classe.
12.persister (opcional): Especifica uma ClassPersister customizada.
13.batch-size (opcional, padrão 1) especifica um “batch size” (tamanho do lote) para trazer instancias desta
classe.
14.optimistic-lock (opcional, padrão version): determina a estratégia otimista de “locking” de registro.
15.lazy (opcional): Definindo lazy="true" is é uma nome curto equivalente para especificar o nome da própria
classe para uma interface de proxy.
table:
Estas definições são também aceitas na seção <subclass> que realizam a persistência de classes internas
(inner class).
6.1.3. id
Definição da chave primária da classe (tabela)
<id
name="propertyName"(1)
type="typename"(2)
column="column_name"(3)
unsaved-value="any|none|null|id_value"(4)
access="field|property|ClassName">(5)
<generator class="generatorClass"/>
</id>
name (opcional): O nome para identificar a propriedade.
type (opcional): Um nome apra indicar o tipo no Hibernate.
column (opcional - padrão o nome da propriedade): O nome da coluna de chave primaria.
unsaved-value (opcional - padrão null): Uma uma valor para a propridade para indicar uma
nova instancia cujo
o valor não for definido.
access (opcional - defaults to property): Estratégia necessária para o hibernate acessar o valor da propriedade.
O <composite-id> é uma alterantiva para tabelas com chaves compostas, porém é fortemente
desencorajada o seu uso, porém pode se fazer necessário o seu uso.
6.1.4. generator
Elemento filho utilizado para gerar identificadores unicos para instancias das classes persistentes.
<id name="id" type="long" column="uid" unsaved-value="0">
<generator class="net.sf.hibernate.id.TableHiLoGenerator">
<param name="table">uid_table</param>
<param name="column">next_hi_value_column</param>
</generator>
</id>
- gera identificadores do tipo long, short ou int este é unico somente em outro processo de inserção
de dados na mesma tabela. Não use em um cluster.
increment
suporte às colunas identificadas (identity) no DB2, MySQL, MS SQL Server, Sybase e
HypersonicSQL. O retorno é identificado como tipo long, short ou int.
identity -
usa a sequencia (sequence) do DB2, PostgreSQL, Oracle, SAP DB, McKoi or um generator no
Interbase. O retorno do identificador é do tipo long, short ou int
sequence -
usa um algoritimo hi/lo para gerar um eficiente identificador do tipo long, short ou int, dado a tabela e
a coluna (por default hibernate_unique_key e next respectivamente) para uma fonte de valores altos. O
algoritimo hi/lo gera identificadores que são unicos somente para uma base de dados particular. Não use este
generator com conexões inscritas com JTA ou com uma user-supplied connection.
hilo -
usa algoritimo hi/lo para gerar um eficiente identificador do tipo long, short or int, dado a tabela e o
nome do database sequence.
seqhilo -
usas um algoritimo de 128-bit UUID para gerar identificadores do tipo string, unicos na rede (o
endereço IP é usado). O UUID é codificado em uma string de digitos hexadecimais de 32 digitos de tamanho.
uuid.hex -
usa o mesmo algoritimo UUID. O UUID é codificado em uma string de 16 caracteres ASCII. Não
usar com o PostgreSQL.
uuid.string -
native - Pega o identity, sequence
ou hilo dependendo da capacidade do database.
assigned -
a aplicação define o identificador para o objeto antes do save() ser chamado.
usa o identificador de outro objeto associado. Comumente usado em conjunto com uma chave primária
de uma associação <one-to-one>.
foreign -
6.1.5. composite-id
Exemplo 1
<composite-id
name="propertyName"
class="ClassName"
unsaved-value="any|none"
access="field|property|ClassName">
<key-property name="propertyName" type="typename" column="column_name"/>
<key-many-to-one name="propertyName class="ClassName" column="column_name"/>
......
</composite-id>
Exemplo 2
<composite-id>
<key-property name="medicareNumber"/>
<key-property name="dependent"/>
</composite-id>
• name (opcional): Um propriedade do tipo de componente para passar o identificador composto.
• class (opcional - padrão o tipo de propriedade determinado para reflecção (reflection)): A classe componente
usada para o identificador composto.
• unsaved-value (opcional - padrão none): indica a instancia transiente necessária para uma nova instanciação, se
definido para any.
6.1.6. timestamp (opcional)
<timestamp
column="timestamp_column"(1)
name="propertyName"(2)
access="field|property|ClassName"(3)
unsaved-value="null|undefined"(4)
/>
•
•
•
column (opcional - padrão o nome da propriedade): O nome de uma coluna proprietaria do TimeStamp.
name: O nome de um estilo de propriedade do JavaBeans do tipo Date or Timestamp de uma classe persistente.
access (opcional - padrão property): A estratégia do Hibernate necessária para uso no acesso ao valor da
propriedade.
•
(opcional - padrão null): Um versão do valor da propriedade para indicar se uma instancia foi
recentemente instanciada (unsaved).
unsaved-value
6.1.9. property
A tag <property> define a persistencia da classe no estilo de propriedade JavaBeans.
<property
name="propertyName" (1)
column="column_name"(2)
type="typename"(3)
update="true|false"(4)
insert="true|false"(4)
formula="arbitrary SQL expression"(5)
access="field|property|ClassName"(6)
/>
1.
2.
name:
o nome da propriedade, com uma letra inicial em minuscula.
column (opcional - padrão o nome da propriedade): o nome da coluna da tabela do banco de dados mapeado.
3.
4.
(opcional): um nome para indicar o tipo no Hibernate.
(opcional - padrão true): especifições para as colunas mapeadas que necessitam ser incluidas
no enunciado do SQL UPDATE e/ou INSERT. Definindo ambos para false permite uma propriedade puramente
derivada do qual o valor é inicializado à alguma outra propriedade mapeada para a mesma coluna ou por uma
trigger ou outra aplicação.
5. formula (opcional): uma expressão SQL para definir o valor para uma propriedade computed. Propriedade
Computed não tem uma coluna mapeada pertencente a ele.
6. access (opcional - padrão property): A estratégia do Hibernate necessária acessar o valor da propriedade.
type
update, insert
6.1.10. many-to-one
Para definir uma associação com outras classe persistente use a tag <many_to_one>. No modelo
relacional é a associação many-to-one.
<many-to-one
name="propertyName"(1)
column="column_name"(2)
class="ClassName"(3)
cascade="all|none|save-update|delete"(4)
outer-join="true|false|auto"(5)
update="true|false"(6)
insert="true|false"(6)
property-ref="propertyNameFromAssociatedClass"(7)
access="field|property|ClassName"(8)
/>
1.
2.
3.
4.
5.
6.
7.
8.
name: O nome da propriedade.
column (opcional): O nome da coluna.
class (opcional - padrão o tipo da propriedade determinada para reflexão): O nome da classe associativa.
cascade (opcional): Especifica quais operações serão realizadas para cascatear a partir do objeto pai para o
objeto associado.
outer-join (opcional - padrão auto): habilita recuperação de outer-join para esta associação quando
definido hibernate.use_outer_join.
update, insert (opcional - padrão true) especifica para a coluna mapeada se será incluido o enunciado
do SQL de UPDATE e/ou INSERT. Definindo ambos para false permite uma associação pura com valor
inicializado a partir da mesma propriedade para o mapa da mesma coluna ou por uma trigger ou outra
aplicação.
property-ref: (opcional) Nome de uma propriedade da classe associada para ligação atravéz de uma chave
estrangeira. Se na for especificado, a chave primária será usada para associar a classe.
access (opcional - padrão property): Estratégia usada pelo Hibernate no acesso ao valor da propriedade.
Uma declaração simples de <many-to-one>:
<many-to-one name="product" class="Product" column="PRODUCT_ID"/>
6.1.11. one-to-one
Para relacionamentos um-para-um.
<one-to-one
name="propertyName"
class="ClassName"
cascade="all|none|save-update|delete"
constrained="true|false"
outer-join="true|false|auto"
property-ref="propertyNameFromAssociatedClass"
access="field|property|ClassName"
/>
1.
2.
3.
4.
name:
(1)
(2)
(3)
(4)
(5)
(6)
(7)
O nome da propriedade.
class (opcional - padrão o tipo da propriedade determinado para reflexão): O nome da classe associada.
cascade (opcional) especifica para quais operações serão cascateadas para do objeto pai do objeto associado.
constrained (opcional) especifica que a constraint de chave estrangeira será a chave primaria da tabela
mapeada referenciando a tabela da classe associativa. Esta opção afeta a ordem em que save() e delete()
serão cascateada (e é além disso é usada na ferramenta de exportação do schema).
5. outer-join (opcional - padrão auto): habilita recuperação de outer-join para a associação que o
hibernate.use_outer_join definir
6. property-ref: (opcional) O nome da propriedade da classe associada que é ligada com a chave primária desta
classe. Se não especificado, a chave primária da classe associada será usada.
7. access (opcional - padrão property): A estratégia do Hibernate que será usada para acessar o valor da
propriedade.
Person,
Para uma associação pela chave primária, adicionando o seguinte mapeamento para Employee and
respectivamente.
<one-to-one name="person" class="Person"/>
<one-to-one name="employee" class="Employee" constrained="true"/>
No caso anterior, a associação das classes será feita pela chave primária da tabela que foi associada, no
caso chave primária da tabela Person e Employee.
6.1.12. subclass
<subclass
name="ClassName"
discriminator-value="discriminator_value"
proxy="ProxyInterface"
lazy="true|false"
dynamic-update="true|false"
dynamic-insert="true|false">
<property .... />
.....
</subclass>
(1)
(2)
(3)
(4)
✑✎name: Nome qualificado completo da subclass.
✒✎discriminator-value (opcional - padrão o nome da classe): Um valor que distingue uma subclasse
individual.
✓✎proxy (opcional): Especifica uma classe ou interface para ser usada em iniciar proxies.
✔✎lazy (opcional): Definindo lazy="true" é um atalho equivalente para especificar o nome de uma classe para
si próprio para a interface proxy.
6.1.13. joined-subclass
Alterantivamente, uma subclasse para persistencia de uma tabela (estratégia de mapeamento table-persubclass) é declarada usando o elemento <joined-subclass>.
<joined-subclass
name="ClassName"
proxy="ProxyInterface"
lazy="true|false"
dynamic-update="true|false"
dynamic-insert="true|false">
<key .... >
<property .... />
.....
</subclass>
(1)
(2)
(3)
✑✎name: O nome completo qualificado da classe da subclasse.
✒✎proxy (opcional): Especifica uma classe ou interface para iniciar o uso de proxies.
3.
(opcional): Definindo lazy="true" o um atalho equivalente especificado no nome da classe será usado
para em uma interface proxy.
lazy
6.1.14. import
Suponha que sua aplicação tenha duas classes persistentes com o mesmo nome, e você não que especificar o
nome qualificado completo (package) nas consultas do Hibernate.
<import class="java.lang.Object" rename="Universe"/>
<import
class="ClassName"
rename="ShortName"
/>
(1)
(2)
1. class: O nome completo qualificado da classe de qualquer classe Java.
2. rename (opcional - padrão o nome não qualificado da classe) : Um nome para ser usado na linguagem de
consulta.
7. Hibernate Types
integer, long, short, float, double, character, byte, boolean, yes_no, true_false
Tipos primitivos mapeados para Java ou cobertura da classe para o tipo da coluna do SQL apropriada. boolean,
yes_no e true_false are são todos alternativos codificando para um Java boolean ou java.lang.Boolean.
string
Um tipo mapeado do java.lang.String para VARCHAR (ou Oracle VARCHAR2).
date, time, timestamp
Tipo mapeado a partir de java.util.Date and e subclasses para tipo SQL DATE, TIME e TIMESTAMP (ou
equivalente).
calendar, calendar_date
Tipo mapeado de java.util.Calendar
para tipos SQL TIMESTAMP e DATE (ou equivalente).
big_decimal
Um tipo mapeado de java.math.BigDecimal para NUMERIC (ou Oracle NUMBER).
locale, timezone, currency
Tipo mapeado de java.util.Locale, java.util.TimeZone
VARCHAR2). Instancias de Locale e Currency são mapeada
mepeadas para o mesmo ID.
e java.util.Currency para VARCHAR (ou Oracle
para os codigos ISO. Instancias de TimeZone são
class
Um tipo mapeado de java.lang.Class para VARCHAR (ou Oracle VARCHAR2). Uma Class é mapeada para o nome
completo qualificado.
binary
Array de mapa de byte para um apropriado tipo binário do SQL.
text
Mapea Strings longas do Java para um tipo SQL CLOB ou TEXT.
serializable
Mapea tipo Java serializable para um tipo binário do SQL apropriado. Voce além disso pode indicar o tipo
Hibernate serializable com o nome de uma classe serializable do Java ou interface para fazer notdefault para
um tipo basico ou implementação PersistentEnum.
clob, blob
Tipo mapeados para a classe do JDBC java.sql.Clob e java.sql.Blob. Estes tipos talvez sejam inconvenientes
para algumas aplicações, desde que o os objetos blob ou o clob não sejam reutilizados fora de uma transação.
8. Mapeando Coleções