Ibernazione - Annotazioni
Finora hai visto come Hibernate utilizza il file di mapping XML per la trasformazione dei dati da POJO a tabelle di database e viceversa. Le annotazioni di ibernazione sono il modo più recente per definire le mappature senza l'uso di file XML. È possibile utilizzare annotazioni in aggiunta o in sostituzione dei metadati di mapping XML.
Annotazioni di ibernazione è il modo efficace per fornire i metadati per il mapping di oggetti e tabelle relazionali. Tutti i metadati vengono inseriti nel file java POJO insieme al codice, questo aiuta l'utente a comprendere la struttura della tabella e POJO simultaneamente durante lo sviluppo.
Se si intende rendere portabile la propria applicazione su altre applicazioni ORM conformi a EJB 3, è necessario utilizzare le annotazioni per rappresentare le informazioni di mappatura, ma se si desidera una maggiore flessibilità, è necessario utilizzare le mappature basate su XML.
Configurazione dell'ambiente per l'annotazione di ibernazione
Prima di tutto dovresti assicurarti di utilizzare JDK 5.0 altrimenti devi aggiornare il tuo JDK a JDK 5.0 per sfruttare il supporto nativo per le annotazioni.
In secondo luogo, dovrai installare il pacchetto di distribuzione delle annotazioni Hibernate 3.x, disponibile da sourceforge: ( Scarica Hibernate Annotation ) e copiahibernate-annotations.jar, lib/hibernate-comons-annotations.jar e lib/ejb3-persistence.jar dalla distribuzione Annotazioni di Hibernate al tuo CLASSPATH.
Esempio di classe annotata
Come accennato in precedenza mentre si lavora con Hibernate Annotation, tutti i metadati vengono raggruppati nel file java POJO insieme al codice, questo aiuta l'utente a comprendere la struttura della tabella e POJO simultaneamente durante lo sviluppo.
Considera che utilizzeremo la seguente tabella EMPLOYEE per memorizzare i nostri oggetti:
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)
);Di seguito è riportata la mappatura della classe Employee con annotazioni per mappare oggetti con la tabella EMPLOYEE definita -
import javax.persistence.*;
@Entity
@Table(name = "EMPLOYEE")
public class Employee {
@Id @GeneratedValue
@Column(name = "id")
private int id;
@Column(name = "first_name")
private String firstName;
@Column(name = "last_name")
private String lastName;
@Column(name = "salary")
private int salary;
public Employee() {}
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;
}
}Hibernate rileva che l'annotazione @Id si trova su un campo e presume che debba accedere alle proprietà di un oggetto direttamente tramite i campi in fase di esecuzione. Se hai posizionato l'annotazione @Id sul metodo getId (), abiliterai l'accesso alle proprietà tramite i metodi getter e setter per impostazione predefinita. Quindi, anche tutte le altre annotazioni vengono posizionate sui campi o sui metodi getter, seguendo la strategia selezionata.
La sezione seguente spiegherà le annotazioni utilizzate nella classe precedente.
@Entity Annotation
Le annotazioni standard EJB 3 sono contenute nel file javax.persistencepacchetto, quindi importiamo questo pacchetto come primo passaggio. In secondo luogo, abbiamo utilizzato il file@Entity annotazione alla classe Employee, che contrassegna questa classe come un bean di entità, quindi deve avere un costruttore senza argomenti visibile almeno con ambito protetto.
@ Annotazione tabella
L'annotazione @Table consente di specificare i dettagli della tabella che verrà utilizzata per rendere persistente l'entità nel database.
L'annotazione @Table fornisce quattro attributi, consentendo di sovrascrivere il nome della tabella, il suo catalogo e il suo schema e imporre vincoli univoci alle colonne nella tabella. Per ora, stiamo usando solo il nome della tabella, che è EMPLOYEE.
Annotazioni @Id e @GeneratedValue
Ogni bean di entità avrà una chiave primaria, che annoti sulla classe con il @Idannotazione. La chiave primaria può essere un singolo campo o una combinazione di più campi a seconda della struttura della tabella.
Per impostazione predefinita, l'annotazione @Id determinerà automaticamente la strategia di generazione della chiave primaria più appropriata da utilizzare ma è possibile sovrascriverla applicando il @GeneratedValue annotazione, che accetta due parametri strategy e generatordi cui non parlerò qui, quindi utilizziamo solo la strategia di generazione delle chiavi predefinita. Lasciando che Hibernate determini quale tipo di generatore utilizzare rende il tuo codice portabile tra database diversi.
@ Annotazione colonna
L'annotazione @Column viene utilizzata per specificare i dettagli della colonna a cui verrà mappato un campo o una proprietà. Puoi utilizzare l'annotazione di colonna con i seguenti attributi più comunemente usati:
name l'attributo consente di specificare esplicitamente il nome della colonna.
length l'attributo consente la dimensione della colonna utilizzata per mappare un valore in particolare per un valore String.
nullable l'attributo consente alla colonna di essere contrassegnata come NOT NULL quando viene generato lo schema.
unique l'attributo consente di contrassegnare la colonna come contenente solo valori univoci.
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 e quindi applicheremo le operazioni CRUD su quei record.
import java.util.List;
import java.util.Date;
import java.util.Iterator;
import org.hibernate.HibernateException;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
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 AnnotationConfiguration().
configure().
//addPackage("com.xyz") //add package if used.
addAnnotatedClass(Employee.class).
buildSessionFactory();
} catch (Throwable ex) {
System.err.println("Failed to create sessionFactory object." + ex);
throw new ExceptionInInitializerError(ex);
}
ManageEmployee ME = new ManageEmployee();
/* Add few employee records in database */
Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
Integer empID3 = ME.addEmployee("John", "Paul", 10000);
/* List down all the employees */
ME.listEmployees();
/* Update employee's records */
ME.updateEmployee(empID1, 5000);
/* Delete an employee from the database */
ME.deleteEmployee(empID2);
/* List down new list of the employees */
ME.listEmployees();
}
/* Method to CREATE an employee in the database */
public Integer addEmployee(String fname, String lname, int salary){
Session session = factory.openSession();
Transaction tx = null;
Integer employeeID = null;
try {
tx = session.beginTransaction();
Employee employee = new Employee();
employee.setFirstName(fname);
employee.setLastName(lname);
employee.setSalary(salary);
employeeID = (Integer) session.save(employee);
tx.commit();
} catch (HibernateException e) {
if (tx!=null) tx.rollback();
e.printStackTrace();
} finally {
session.close();
}
return employeeID;
}
/* Method to READ all the employees */
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());
}
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();
}
}
}Configurazione del database
Ora creiamo hibernate.cfg.xml file di configurazione per definire i parametri relativi al database.
<?xml version = "1.0" encoding = "utf-8"?>
<!DOCTYPE hibernate-configuration SYSTEM
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property name = "hibernate.dialect">
org.hibernate.dialect.MySQLDialect
</property>
<property name = "hibernate.connection.driver_class">
com.mysql.jdbc.Driver
</property>
<!-- Assume students is the database name -->
<property name = "hibernate.connection.url">
jdbc:mysql://localhost/test
</property>
<property name = "hibernate.connection.username">
root
</property>
<property name = "hibernate.connection.password">
cohondob
</property>
</session-factory>
</hibernate-configuration>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.
Elimina il file di mapping Employee.hbm.xml dal percorso.
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 e i record verranno creati nella tabella EMPLOYEE.
$java ManageEmployee
.......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
First Name: Zara Last Name: Ali Salary: 1000
First Name: Daisy Last Name: Das Salary: 5000
First Name: John Last Name: Paul Salary: 10000
First Name: Zara Last Name: Ali Salary: 5000
First Name: John Last Name: Paul Salary: 10000Se controlli la tua tabella EMPLOYEE, dovrebbe avere i seguenti record:
mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 29 | Zara | Ali | 5000 |
| 31 | John | Paul | 10000 |
+----+------------+-----------+--------+
2 rows in set (0.00 sec
mysql>