Hibernate - Mappature dei componenti
UN Componentmapping è un mapping per una classe che ha un riferimento a un'altra classe come variabile membro. Abbiamo visto tale mappatura pur avendo due tabelle e usando l'elemento <set> nel file di mappatura. Ora useremo l'elemento <component> nel file di mappatura e verrà utilizzata una singola tabella per mantenere gli attributi contenuti nella variabile di classe.
Definisci tabelle RDBMS
Considera una situazione in cui dobbiamo archiviare i record dei nostri dipendenti nella tabella EMPLOYEE che avrà la seguente struttura:
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)
);Inoltre, supponiamo che ogni dipendente abbia un indirizzo, quindi aggiungiamo campi specifici dell'indirizzo nella stessa tabella come segue:
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,
street_name VARCHAR(40) default NULL,
city_name VARCHAR(40) default NULL,
state_name VARCHAR(40) default NULL,
zipcode VARCHAR(10) default NULL,
PRIMARY KEY (id)
);Definisci classi POJO
Implementiamo la nostra classe POJO Employee, che verrà utilizzato per rendere persistenti gli oggetti relativi alla tabella EMPLOYEE.
import java.util.*;
public class Employee implements java.io.Serializable {
private int id;
private String firstName;
private String lastName;
private int salary;
private Address address;
public Employee() {}
public Employee(String fname, String lname, int salary, Address address ) {
this.firstName = fname;
this.lastName = lname;
this.salary = salary;
this.address = address;
}
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 Address getAddress() {
return address;
}
public void setAddress( Address address ) {
this.address = address;
}
}Dobbiamo definire un'altra classe POJO corrispondente all'entità ADDRESS con campi relativi all'indirizzo.
import java.util.*;
public class Address{
private int id;
private String street;
private String city;
private String state;
private String zipcode;
public Address() {}
public Address(String street, String city, String state, String zipcode) {
this.street = street;
this.city = city;
this.state = state;
this.zipcode = zipcode;
}
public int getId() {
return id;
}
public void setId( int id ) {
this.id = id;
}
public String getStreet() {
return street;
}
public void setStreet( String street ) {
this.street = street;
}
public String getCity() {
return city;
}
public void setCity( String city ) {
this.city = city;
}
public String getState() {
return state;
}
public void setState( String state ) {
this.state = state;
}
public String getZipcode() {
return zipcode;
}
public void setZipcode( String zipcode ) {
this.zipcode = zipcode;
}
}Definisci file di mappatura ibernazione
Sviluppiamo il nostro file di mappatura, che istruisce Hibernate su come mappare le classi definite alle tabelle del database. L'elemento <component> verrà utilizzato per definire la regola per tutti i campi associati alla tabella ADDRESS.
<?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>
<component name = "address" class="Address">
<property name = "street" column = "street_name" type = "string"/>
<property name = "city" column = "city_name" type = "string"/>
<property name = "state" column = "state_name" type = "string"/>
<property name = "zipcode" column = "zipcode" type = "string"/>
</component>
<property name = "firstName" column = "first_name" type = "string"/>
<property name = "lastName" column = "last_name" type = "string"/>
<property name = "salary" column = "salary" type = "int"/>
</class>
</hibernate-mapping>È necessario salvare il documento di mappatura in un file con il formato <classname> .hbm.xml. Abbiamo salvato il nostro documento di mappatura nel file Employee.hbm.xml. Hai già familiarità con la maggior parte dei dettagli di mappatura, ma vediamo di nuovo tutti gli elementi del file di mappatura -
Il documento di mappatura è un documento XML con estensione <hibernate-mapping> come elemento radice che contiene due elementi <class> corrispondenti a ciascuna classe.
Il <class>gli elementi vengono utilizzati per definire associazioni specifiche da classi Java alle tabelle del database. Il nome della classe Java viene specificato utilizzando ilname l'attributo dell'elemento class e il nome della tabella del database viene specificato utilizzando il table attributo.
Il <meta> elemento è un elemento opzionale e può essere utilizzato per creare la descrizione della classe.
Il <id>L'elemento mappa l'attributo ID univoco nella classe alla chiave primaria della tabella del database. Ilname l'attributo dell'elemento id si riferisce alla proprietà nella classe e nel file columnl'attributo si riferisce alla colonna nella tabella del database. Iltype l'attributo contiene il tipo di mappatura ibernazione, questo tipo di mappatura convertirà da Java a tipo di dati SQL.
Il <generator>l'elemento all'interno dell'elemento id viene utilizzato per generare automaticamente i valori della chiave primaria. Ilclass l'attributo dell'elemento generatore è impostato su native per lasciare che ibernazione raccolga entrambi identity, sequence o hilo algoritmo per creare la chiave primaria a seconda delle capacità del database sottostante.
Il <property>elemento viene utilizzato per mappare una proprietà di classe Java a una colonna nella tabella del database. Ilname l'attributo dell'elemento si riferisce alla proprietà nella classe e nel columnl'attributo si riferisce alla colonna nella tabella del database. Iltype l'attributo contiene il tipo di mappatura ibernazione, questo tipo di mappatura convertirà da Java a tipo di dati SQL.
Il <component> L'elemento imposta l'esistenza di diversi attributi della classe Address all'interno delle classi Employee.
Crea classe di applicazione
Infine, creeremo la nostra classe dell'applicazione con il metodo main () per eseguire l'applicazione. Useremo questa applicazione per salvare pochi record dei Dipendenti insieme ai loro certificati e quindi applicheremo le operazioni CRUD su quei record.
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 one address object */
Address address1 = ME.addAddress("Kondapur","Hyderabad","AP","532");
/* Add employee records in the database */
Integer empID1 = ME.addEmployee("Manoj", "Kumar", 4000, address1);
/* Let us have another address object */
Address address2 = ME.addAddress("Saharanpur","Ambehta","UP","111");
/* Add another employee record in the database */
Integer empID2 = ME.addEmployee("Dilip", "Kumar", 3000, address2);
/* List down all the employees */
ME.listEmployees();
/* Update employee's salary records */
ME.updateEmployee(empID1, 5000);
/* List down all the employees */
ME.listEmployees();
}
/* Method to add an address record in the database */
public Address addAddress(String street, String city, String state, String zipcode) {
Session session = factory.openSession();
Transaction tx = null;
Integer addressID = null;
Address address = null;
try {
tx = session.beginTransaction();
address = new Address(street, city, state, zipcode);
addressID = (Integer) session.save(address);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
return address;
}
/* Method to add an employee record in the database */
public Integer addEmployee(String fname, String lname, int salary, Address address){
Session session = factory.openSession();
Transaction tx = null;
Integer employeeID = null;
try {
tx = session.beginTransaction();
Employee employee = new Employee(fname, lname, salary, address);
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 iterator = employees.iterator(); iterator.hasNext();){
Employee employee = (Employee) iterator.next();
System.out.print("First Name: " + employee.getFirstName());
System.out.print(" Last Name: " + employee.getLastName());
System.out.println(" Salary: " + employee.getSalary());
Address add = employee.getAddress();
System.out.println("Address ");
System.out.println("\tStreet: " + add.getStreet());
System.out.println("\tCity: " + add.getCity());
System.out.println("\tState: " + add.getState());
System.out.println("\tZipcode: " + add.getZipcode());
}
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();
}
}
}Compilazione ed esecuzione
Ecco i passaggi per compilare ed eseguire l'applicazione sopra menzionata. Assicurati di aver impostato PATH e CLASSPATH in modo appropriato prima di procedere per la compilazione e l'esecuzione.
Creare il file di configurazione hibernate.cfg.xml come spiegato nel capitolo sulla configurazione.
Crea il file di mappatura Employee.hbm.xml come mostrato sopra.
Crea il file sorgente Employee.java come mostrato sopra e compilarlo.
Crea il file sorgente ManageEmployee.java come mostrato sopra e compilarlo.
Esegui il binario ManageEmployee per eseguire il programma.
Si otterrebbe il seguente risultato sullo schermo e verranno creati record di tempo stesso nella tabella EMPLOYEE.
$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
First Name: Manoj Last Name: Kumar Salary: 4000
Address
Street: Kondapur
City: Hyderabad
State: AP
Zipcode: 532
First Name: Dilip Last Name: Kumar Salary: 3000
Address
Street: Saharanpur
City: Ambehta
State: UP
Zipcode: 111
First Name: Manoj Last Name: Kumar Salary: 5000
Address
Street: Kondapur
City: Hyderabad
State: AP
Zipcode: 532
First Name: Dilip Last Name: Kumar Salary: 3000
Address
Street: Saharanpur
City: Ambehta
State: UP
Zipcode: 111Se controlli la tua tabella EMPLOYEE, dovrebbe avere i seguenti record:
mysql> select id, first_name,salary, street_name, state_name from EMPLOYEE;
+----+------------+--------+-------------+------------+
| id | first_name | salary | street_name | state_name |
+----+------------+--------+-------------+------------+
| 1 | Manoj | 5000 | Kondapur | AP |
| 2 | Dilip | 3000 | Saharanpur | UP |
+----+------------+--------+-------------+------------+
2 rows in set (0.00 sec)
mysql>