Ruhezustand - Beispiele
Nehmen wir nun ein Beispiel, um zu verstehen, wie wir Hibernate verwenden können, um Java-Persistenz in einer eigenständigen Anwendung bereitzustellen. Wir werden die verschiedenen Schritte zum Erstellen einer Java-Anwendung mithilfe der Hibernate-Technologie durchgehen.
Erstellen Sie POJO-Klassen
Der erste Schritt beim Erstellen einer Anwendung besteht darin, die Java-POJO-Klasse oder -Klassen zu erstellen, abhängig von der Anwendung, die in der Datenbank beibehalten wird. Betrachten wir unsereEmployee Klasse mit getXXX und setXXX Methoden, um es JavaBeans-kompatible Klasse zu machen.
Ein POJO (Plain Old Java Object) ist ein Java-Objekt, das einige spezielle Klassen und Schnittstellen, die vom EJB-Framework benötigt werden, nicht erweitert oder implementiert. Alle normalen Java-Objekte sind POJO.
Wenn Sie eine Klasse entwerfen, die von Hibernate beibehalten werden soll, ist es wichtig, JavaBeans-kompatiblen Code sowie ein Attribut bereitzustellen, das wie ein Index funktioniert id Attribut in der Employee-Klasse.
public class Employee {
private int id;
private String firstName;
private String lastName;
private int salary;
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;
}
}Erstellen Sie Datenbanktabellen
Der zweite Schritt wäre das Erstellen von Tabellen in Ihrer Datenbank. Es würde eine Tabelle geben, die jedem Objekt entspricht. Sie sind bereit, Persistenz bereitzustellen. Beachten Sie, dass die oben genannten Objekte gespeichert und in der folgenden RDBMS-Tabelle abgerufen werden müssen.
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)
);Erstellen Sie eine Zuordnungskonfigurationsdatei
In diesem Schritt wird eine Zuordnungsdatei erstellt, die Hibernate anweist, wie die definierte Klasse oder die definierten Klassen den Datenbanktabellen zugeordnet werden sollen.
<?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>
<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>Sie sollten das Zuordnungsdokument in einer Datei mit dem Format <Klassenname> .hbm.xml speichern. Wir haben unser Zuordnungsdokument in der Datei Employee.hbm.xml gespeichert. Lassen Sie uns wenig Details über das Kartendokument sehen -
Das Zuordnungsdokument ist ein XML-Dokument mit <Hibernate-Mapping> als Stammelement, das alle <Klassen> -Elemente enthält.
Das <class>Elemente werden verwendet, um bestimmte Zuordnungen von Java-Klassen zu den Datenbanktabellen zu definieren. Der Java-Klassenname wird mit dem angegebenname Das Attribut des Klassenelements und der Name der Datenbanktabelle werden mit dem angegeben table Attribut.
Das <meta> element ist ein optionales Element und kann zum Erstellen der Klassenbeschreibung verwendet werden.
Das <id> element ordnet das eindeutige ID-Attribut in der Klasse dem Primärschlüssel der Datenbanktabelle zu. Dasname Das Attribut des ID-Elements bezieht sich auf die Eigenschaft in der Klasse und die columnAttribut bezieht sich auf die Spalte in der Datenbanktabelle. Dastype Das Attribut enthält den Zuordnungstyp für den Ruhezustand. Diese Zuordnungstypen werden vom Java- in den SQL-Datentyp konvertiert.
Das <generator>Element innerhalb des ID-Elements wird verwendet, um die Primärschlüsselwerte automatisch zu generieren. Dasclass Attribut des Generatorelements wird auf gesetzt native um den Winterschlaf auch aufnehmen zu lassen identity, sequence oder hilo Algorithmus zum Erstellen eines Primärschlüssels in Abhängigkeit von den Funktionen der zugrunde liegenden Datenbank.
Das <property>Element wird verwendet, um eine Java-Klasseneigenschaft einer Spalte in der Datenbanktabelle zuzuordnen. Dasname Das Attribut des Elements bezieht sich auf die Eigenschaft in der Klasse und die columnAttribut bezieht sich auf die Spalte in der Datenbanktabelle. Dastype Das Attribut enthält den Zuordnungstyp für den Ruhezustand. Diese Zuordnungstypen werden vom Java- in den SQL-Datentyp konvertiert.
Es sind andere Attribute und Elemente verfügbar, die in einem Zuordnungsdokument verwendet werden. Ich würde versuchen, so viele wie möglich zu behandeln, während ich andere Themen im Zusammenhang mit dem Ruhezustand diskutiere.
Anwendungsklasse erstellen
Schließlich erstellen wir unsere Anwendungsklasse mit der main () -Methode, um die Anwendung auszuführen. Wir werden diese Anwendung verwenden, um einige Mitarbeiterdatensätze zu speichern, und dann werden wir CRUD-Operationen auf diese Datensätze anwenden.
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.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();
/* 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(fname, lname, 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();
}
}
}Zusammenstellung und Ausführung
Hier sind die Schritte zum Kompilieren und Ausführen der oben genannten Anwendung. Stellen Sie sicher, dass Sie PATH und CLASSPATH entsprechend eingestellt haben, bevor Sie mit der Kompilierung und Ausführung fortfahren.
Erstellen Sie die Konfigurationsdatei hibernate.cfg.xml wie im Konfigurationskapitel erläutert.
Erstellen Sie die Zuordnungsdatei Employee.hbm.xml wie oben gezeigt.
Erstellen Sie die Quelldatei Employee.java wie oben gezeigt und kompilieren Sie sie.
Erstellen Sie die Quelldatei ManageEmployee.java wie oben gezeigt und kompilieren Sie sie.
Führen Sie die ManageEmployee-Binärdatei aus, um das Programm auszuführen.
Sie erhalten das folgende Ergebnis und Datensätze werden in der Tabelle EMPLOYEE erstellt.
$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: 10000Wenn Sie Ihre EMPLOYEE-Tabelle überprüfen, sollte sie die folgenden Datensätze enthalten:
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>