Hibernate - Mapeamentos de lista
UMA Listé uma coleção java que armazena elementos em sequência e permite elementos duplicados. O usuário desta interface tem controle preciso sobre onde na lista cada elemento é inserido. O usuário pode acessar os elementos por meio de seu índice inteiro e pesquisar os elementos na lista. Mais formalmente, as listas normalmente permitem pares de elementos e1 e e2 tais que e1.equals (e2), e normalmente permitem vários elementos nulos se permitirem elementos nulos.
Uma lista é mapeada com um elemento <list> na tabela de mapeamento e inicializada com java.util.ArrayList.
Definir tabelas RDBMS
Considere uma situação em que precisamos armazenar nossos registros de funcionários na tabela EMPLOYEE, que terá a seguinte estrutura -
create table EMPLOYEE (
id INT NOT NULL auto_increment,
first_name VARCHAR(20) default NULL,
last_name VARCHAR(20) default NULL,
salary INT default NULL,
PRIMARY KEY (id)
);Além disso, assuma que cada funcionário pode ter um ou mais certificados associados a ele. Um mapeamento de coleção de Lista precisa de uma coluna de índice na tabela de coleção. A coluna de índice define a posição do elemento na coleção. Portanto, vamos armazenar as informações relacionadas ao certificado em uma tabela separada com a seguinte estrutura -
create table CERTIFICATE (
id INT NOT NULL auto_increment,
certificate_name VARCHAR(30) default NULL,
idx INT default NULL,
employee_id INT default NULL,
PRIMARY KEY (id)
);Haverá one-to-many relação entre os objetos EMPLOYEE e CERTIFICATE.
Definir classes POJO
Vamos implementar uma classe POJO Employee, que será usado para persistir os objetos relacionados à tabela EMPLOYEE e ter uma coleção de certificados em List variável.
import java.util.*;
public class Employee {
private int id;
private String firstName;
private String lastName;
private int salary;
private List certificates;
public Employee() {}
public Employee(String fname, String lname, int salary) {
this.firstName = fname;
this.lastName = lname;
this.salary = salary;
}
public int getId() {
return id;
}
public void setId( int id ) {
this.id = id;
}
public String getFirstName() {
return firstName;
}
public void setFirstName( String first_name ) {
this.firstName = first_name;
}
public String getLastName() {
return lastName;
}
public void setLastName( String last_name ) {
this.lastName = last_name;
}
public int getSalary() {
return salary;
}
public void setSalary( int salary ) {
this.salary = salary;
}
public List getCertificates() {
return certificates;
}
public void setCertificates( List certificates ) {
this.certificates = certificates;
}
}Precisamos definir outra classe POJO correspondente à tabela CERTIFICATE para que os objetos de certificado possam ser armazenados e recuperados na tabela CERTIFICATE.
public class Certificate{
private int id;
private String name;
public Certificate() {}
public Certificate(String name) {
this.name = name;
}
public int getId() {
return id;
}
public void setId( int id ) {
this.id = id;
}
public String getName() {
return name;
}
public void setName( String name ) {
this.name = name;
}
}Definir arquivo de mapeamento do Hibernate
Vamos desenvolver nosso arquivo de mapeamento, que instrui o Hibernate como mapear as classes definidas para as tabelas do banco de dados. O elemento <list> será usado para definir a regra para a coleção de lista usada. O índice da lista é sempre do tipo inteiro e é mapeado usando o elemento <list-index>.
<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD//EN"
"http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name = "Employee" table = "EMPLOYEE">
<meta attribute = "class-description">
This class contains the employee detail.
</meta>
<id name = "id" type = "int" column = "id">
<generator class="native"/>
</id>
<list name = "certificates" cascade="all">
<key column = "employee_id"/>
<list-index column = "idx"/>
<one-to-many class="Certificate"/>
</list>
<property name = "firstName" column = "first_name" type = "string"/>
<property name = "lastName" column = "last_name" type = "string"/>
<property name = "salary" column = "salary" type = "int"/>
</class>
<class name = "Certificate" table = "CERTIFICATE">
<meta attribute = "class-description">
This class contains the certificate records.
</meta>
<id name = "id" type = "int" column = "id">
<generator class="native"/>
</id>
<property name = "name" column = "certificate_name" type = "string"/>
</class>
</hibernate-mapping>Você deve salvar o documento de mapeamento em um arquivo com o formato <classname> .hbm.xml. Salvamos nosso documento de mapeamento no arquivo Employee.hbm.xml. Você já está familiarizado com a maioria dos detalhes de mapeamento, mas vamos ver todos os elementos do arquivo de mapeamento mais uma vez -
O documento de mapeamento é um documento XML com <hibernate-mapping> como o elemento raiz, que contém dois elementos <class>> correspondentes a cada classe.
o <class>elementos são usados para definir mapeamentos específicos de classes Java para as tabelas do banco de dados. O nome da classe Java é especificado usando oname atributo do elemento de classe e o nome da tabela do banco de dados é especificado usando o table atributo.
o <meta> element é um elemento opcional e pode ser usado para criar a descrição da classe.
o <id>elemento mapeia o atributo de ID exclusivo na classe para a chave primária da tabela do banco de dados. oname atributo do elemento id refere-se à propriedade na classe e o columnaattribute se refere à coluna na tabela do banco de dados. otype O atributo contém o tipo de mapeamento de hibernação, esses tipos de mapeamento serão convertidos do tipo de dados Java para SQL.
o <generator>O elemento dentro do elemento id é usado para gerar os valores da chave primária automaticamente. oclass atributo do elemento gerador é definido como native para deixar a hibernação pegar também identity, sequence ou hilo algoritmo para criar a chave primária, dependendo dos recursos do banco de dados subjacente.
o <property>elemento é usado para mapear uma propriedade de classe Java para uma coluna na tabela de banco de dados. oname atributo do elemento refere-se à propriedade na classe e o columnatributo refere-se à coluna na tabela do banco de dados. otype O atributo contém o tipo de mapeamento de hibernação, esses tipos de mapeamento serão convertidos do tipo de dados Java para SQL.
o <list>O elemento é usado para definir o relacionamento entre as classes Certificado e Funcionário. Usamos ocascadeatributo no elemento <list> para dizer ao Hibernate para persistir os objetos Certificate ao mesmo tempo que os objetos Employee. oname atributo é definido como definido Listvariável na classe pai, no nosso caso são certificados .
o <key> element é a coluna na tabela CERTIFICATE que contém a chave estrangeira para o objeto pai, ou seja, a tabela EMPLOYEE.
o <list-index>elemento é usado para manter a posição do elemento e mapear com a coluna de índice na tabela de coleção. O índice da lista persistente começa em zero. Você pode mudar isso, por exemplo, com <list-index base = "1" ... /> em seu mapeamento.
o <one-to-many>O elemento indica que um objeto Employee está relacionado a muitos objetos Certificate e, como tal, o objeto Certificate deve ter um pai Employee associado a ele. Você pode usar qualquer<one-to-one>, <many-to-one> ou <many-to-many>elementos com base em seus requisitos. Se alterarmos este exemplo para usar um relacionamento muitos para muitos, precisaremos de uma tabela de associação para mapear entre os objetos pai e filho.
Criar classe de aplicativo
Por fim, criaremos nossa classe de aplicativo com o método main () para executar o aplicativo. Usaremos este aplicativo para salvar alguns registros de Funcionários junto com seus certificados e, em seguida, aplicaremos as operações CRUD a esses registros.
import java.util.*;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class ManageEmployee {
private static SessionFactory factory;
public static void main(String[] args) {
try {
factory = new Configuration().configure().buildSessionFactory();
} catch (Throwable ex) {
System.err.println("Failed to create sessionFactory object." + ex);
throw new ExceptionInInitializerError(ex);
}
ManageEmployee ME = new ManageEmployee();
/* Let us have a set of certificates for the first employee */
ArrayList set1 = new ArrayList();
set1.add(new Certificate("MCA"));
set1.add(new Certificate("MBA"));
set1.add(new Certificate("PMP"));
/* Add employee records in the database */
Integer empID1 = ME.addEmployee("Manoj", "Kumar", 4000, set1);
/* Another set of certificates for the second employee */
ArrayList set2 = new ArrayList();
set2.add(new Certificate("BCA"));
set2.add(new Certificate("BA"));
/* Add another employee record in the database */
Integer empID2 = ME.addEmployee("Dilip", "Kumar", 3000, set2);
/* List down all the employees */
ME.listEmployees();
/* Update employee's salary records */
ME.updateEmployee(empID1, 5000);
/* Delete an employee from the database */
ME.deleteEmployee(empID2);
/* List down all the employees */
ME.listEmployees();
}
/* Method to add an employee record in the database */
public Integer addEmployee(String fname, String lname, int salary, ArrayList cert){
Session session = factory.openSession();
Transaction tx = null;
Integer employeeID = null;
try {
tx = session.beginTransaction();
Employee employee = new Employee(fname, lname, salary);
employee.setCertificates(cert);
employeeID = (Integer) session.save(employee);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
return employeeID;
}
/* Method to list all the employees detail */
public void listEmployees( ){
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
List employees = session.createQuery("FROM Employee").list();
for (Iterator iterator1 = employees.iterator(); iterator1.hasNext();){
Employee employee = (Employee) iterator1.next();
System.out.print("First Name: " + employee.getFirstName());
System.out.print(" Last Name: " + employee.getLastName());
System.out.println(" Salary: " + employee.getSalary());
List certificates = employee.getCertificates();
for (Iterator iterator2 = certificates.iterator(); iterator2.hasNext();){
Certificate certName = (Certificate) iterator2.next();
System.out.println("Certificate: " + certName.getName());
}
}
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
/* Method to update salary for an employee */
public void updateEmployee(Integer EmployeeID, int salary ){
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Employee employee = (Employee)session.get(Employee.class, EmployeeID);
employee.setSalary( salary );
session.update(employee);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
/* Method to delete an employee from the records */
public void deleteEmployee(Integer EmployeeID){
Session session = factory.openSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Employee employee = (Employee)session.get(Employee.class, EmployeeID);
session.delete(employee);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
}
}Compilação e execução
Aqui estão as etapas para compilar e executar o aplicativo acima. Certifique-se de definir PATH e CLASSPATH apropriadamente antes de prosseguir com a compilação e execução.
Crie o arquivo de configuração hibernate.cfg.xml conforme explicado no capítulo de configuração.
Crie o arquivo de mapeamento Employee.hbm.xml conforme mostrado acima.
Crie o arquivo de origem Employee.java conforme mostrado acima e compile-o.
Crie o arquivo de origem Certificate.java conforme mostrado acima e compile-o.
Crie o arquivo de origem ManageEmployee.java conforme mostrado acima e compile-o.
Execute o binário ManageEmployee para executar o programa.
Você obteria o seguinte resultado na tela e os mesmos registros de tempos seriam criados nas tabelas EMPLOYEE e CERTIFICATE. Você pode ver que os certificados foram classificados na ordem inversa. Você pode tentar alterar seu arquivo de mapeamento, basta definirsort="natural" e execute seu programa e compare os resultados.
$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
First Name: Manoj Last Name: Kumar Salary: 4000
Certificate: MCA
Certificate: MBA
Certificate: PMP
First Name: Dilip Last Name: Kumar Salary: 3000
Certificate: BCA
Certificate: BA
First Name: Manoj Last Name: Kumar Salary: 5000
Certificate: MCA
Certificate: MBA
Certificate: PMPSe você verificar as tabelas EMPLOYEE e CERTIFICATE, elas devem ter os seguintes registros -
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 51 | Manoj | Kumar | 5000 |
+----+------------+-----------+--------+
1 row in set (0.00 sec)
mysql> select * from CERTIFICATE;
+----+------------------+------+-------------+
| id | certificate_name | idx | employee_id |
+----+------------------+------+-------------+
| 6 | MCA | 0 | 51 |
| 7 | MBA | 1 | 51 |
| 8 | PMP | 2 | 51 |
+----+------------------+------+-------------+
3 rows in set (0.00 sec
mysql>Como alternativa, você pode mapear um array Java em vez de uma lista. Um mapeamento de matriz é virtualmente idêntico ao exemplo anterior, exceto com diferentes nomes de elementos e atributos (<array> e <array-index>). No entanto, pelos motivos explicados anteriormente, os aplicativos do Hibernate raramente usam arrays.