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: 10000

Wenn 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>