Ruhezustand - Kriterienabfragen

Der Ruhezustand bietet alternative Möglichkeiten zum Bearbeiten von Objekten und Daten, die in RDBMS-Tabellen verfügbar sind. Eine der Methoden ist die Kriterien-API, mit der Sie programmgesteuert ein Kriterienabfrageobjekt erstellen können, in dem Sie Filterregeln und logische Bedingungen anwenden können.

Der Winterschlaf Session Schnittstelle bietet createCriteria() Methode, mit der eine erstellt werden kann Criteria Objekt, das Instanzen der Klasse des Persistenzobjekts zurückgibt, wenn Ihre Anwendung eine Kriterienabfrage ausführt.

Das einfachste Beispiel für eine Kriterienabfrage ist eines, bei dem einfach jedes Objekt zurückgegeben wird, das der Employee-Klasse entspricht.

Criteria cr = session.createCriteria(Employee.class);
List results = cr.list();

Einschränkungen mit Kriterien

Sie können verwenden add() Methode verfügbar für CriteriaObjekt zum Hinzufügen einer Einschränkung für eine Kriterienabfrage. Das folgende Beispiel fügt eine Einschränkung hinzu, um die Datensätze mit einem Gehalt von 2000 zurückzugeben.

Criteria cr = session.createCriteria(Employee.class);
cr.add(Restrictions.eq("salary", 2000));
List results = cr.list();

Im Folgenden finden Sie einige weitere Beispiele für verschiedene Szenarien, die je nach Anforderung verwendet werden können.

Criteria cr = session.createCriteria(Employee.class);

// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));

// To get records having salary less than 2000
cr.add(Restrictions.lt("salary", 2000));

// To get records having fistName starting with zara
cr.add(Restrictions.like("firstName", "zara%"));

// Case sensitive form of the above restriction.
cr.add(Restrictions.ilike("firstName", "zara%"));

// To get records having salary in between 1000 and 2000
cr.add(Restrictions.between("salary", 1000, 2000));

// To check if the given property is null
cr.add(Restrictions.isNull("salary"));

// To check if the given property is not null
cr.add(Restrictions.isNotNull("salary"));

// To check if the given property is empty
cr.add(Restrictions.isEmpty("salary"));

// To check if the given property is not empty
cr.add(Restrictions.isNotEmpty("salary"));

Sie können UND- oder ODER-Bedingungen mithilfe der LogicalExpression-Einschränkungen wie folgt erstellen:

Criteria cr = session.createCriteria(Employee.class);

Criterion salary = Restrictions.gt("salary", 2000);
Criterion name = Restrictions.ilike("firstNname","zara%");

// To get records matching with OR conditions
LogicalExpression orExp = Restrictions.or(salary, name);
cr.add( orExp );

// To get records matching with AND conditions
LogicalExpression andExp = Restrictions.and(salary, name);
cr.add( andExp );

List results = cr.list();

Alle oben genannten Bedingungen können jedoch direkt mit HQL verwendet werden, wie im vorherigen Lernprogramm erläutert.

Paginierung anhand von Kriterien

Es gibt zwei Methoden der Kriterienschnittstelle für die Paginierung.

Sr.Nr. Methode & Beschreibung
1

public Criteria setFirstResult(int firstResult)

Diese Methode verwendet eine Ganzzahl, die die erste Zeile in Ihrer Ergebnismenge darstellt, beginnend mit Zeile 0.
2

public Criteria setMaxResults(int maxResults)

Diese Methode weist Hibernate an, eine feste Nummer abzurufen maxResults von Objekten.

Mit den beiden oben genannten Methoden können wir eine Paging-Komponente in unserer Web- oder Swing-Anwendung erstellen. Das folgende Beispiel können Sie erweitern, um 10 Zeilen gleichzeitig abzurufen:

Criteria cr = session.createCriteria(Employee.class);
cr.setFirstResult(1);
cr.setMaxResults(10);
List results = cr.list();

Ergebnisse sortieren

Die Kriterien-API bietet die org.hibernate.criterion.OrderKlasse, um Ihre Ergebnismenge in aufsteigender oder absteigender Reihenfolge nach einer der Eigenschaften Ihres Objekts zu sortieren. Dieses Beispiel zeigt, wie Sie die Order-Klasse zum Sortieren der Ergebnismenge verwenden würden -

Criteria cr = session.createCriteria(Employee.class);

// To get records having salary more than 2000
cr.add(Restrictions.gt("salary", 2000));

// To sort records in descening order
cr.addOrder(Order.desc("salary"));

// To sort records in ascending order
cr.addOrder(Order.asc("salary"));

List results = cr.list();

Projektionen & Aggregationen

Die Kriterien-API bietet die org.hibernate.criterion.ProjectionsKlasse, die verwendet werden kann, um den Durchschnitt, das Maximum oder das Minimum der Eigenschaftswerte abzurufen. Die Projections-Klasse ähnelt der Restrictions-Klasse, da sie mehrere statische Factory-Methoden zum Abrufen bereitstelltProjection Instanzen.

Im Folgenden finden Sie einige Beispiele für verschiedene Szenarien, die je nach Anforderung verwendet werden können.

Criteria cr = session.createCriteria(Employee.class);

// To get total row count.
cr.setProjection(Projections.rowCount());

// To get average of a property.
cr.setProjection(Projections.avg("salary"));

// To get distinct count of a property.
cr.setProjection(Projections.countDistinct("firstName"));

// To get maximum of a property.
cr.setProjection(Projections.max("salary"));

// To get minimum of a property.
cr.setProjection(Projections.min("salary"));

// To get sum of a property.
cr.setProjection(Projections.sum("salary"));

Beispiel für Kriterienabfragen

Betrachten Sie die folgende POJO-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 wir die folgende EMPLOYEE-Tabelle zum Speichern von Mitarbeiterobjekten:

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)
);

Es folgt die Zuordnungsdatei.

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

Schließlich erstellen wir unsere Anwendungsklasse mit der main () -Methode, um die Anwendung dort auszuführen, wo wir sie verwenden werden Criteria Anfragen -

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.Criteria;
import org.hibernate.criterion.Restrictions;
import org.hibernate.criterion.Projections;
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", 2000);
      Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
      Integer empID3 = ME.addEmployee("John", "Paul", 5000);
      Integer empID4 = ME.addEmployee("Mohd", "Yasee", 3000);

      /* List down all the employees */
      ME.listEmployees();

      /* Print Total employee's count */
      ME.countEmployee();

      /* Print Total salary */
      ME.totalSalary();
   }
   
   /* 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 having salary more than 2000 */
   public void listEmployees( ) {
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Criteria cr = session.createCriteria(Employee.class);
         // Add restriction.
         cr.add(Restrictions.gt("salary", 2000));
         List employees = cr.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 print total number of records */
   public void countEmployee(){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Criteria cr = session.createCriteria(Employee.class);

         // To get total row count.
         cr.setProjection(Projections.rowCount());
         List rowCount = cr.list();

         System.out.println("Total Coint: " + rowCount.get(0) );
         tx.commit();
      } catch (HibernateException e) {
         if (tx!=null) tx.rollback();
         e.printStackTrace(); 
      } finally {
         session.close(); 
      }
   }
  
   /* Method to print sum of salaries */
   public void totalSalary(){
      Session session = factory.openSession();
      Transaction tx = null;
      
      try {
         tx = session.beginTransaction();
         Criteria cr = session.createCriteria(Employee.class);

         // To get total salary.
         cr.setProjection(Projections.sum("salary"));
         List totalSalary = cr.list();

         System.out.println("Total Salary: " + totalSalary.get(0) );
         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: Daisy  Last Name: Das  Salary: 5000
First Name: John  Last Name: Paul  Salary: 5000
First Name: Mohd  Last Name: Yasee  Salary: 3000
Total Coint: 4
Total Salary: 15000

Wenn Sie Ihre EMPLOYEE-Tabelle überprüfen, sollte sie die folgenden Datensätze enthalten

mysql> select * from EMPLOYEE;
+----+------------+-----------+--------+
| id | first_name | last_name | salary |
+----+------------+-----------+--------+
| 14 | Zara       | Ali       |   2000 |
| 15 | Daisy      | Das       |   5000 |
| 16 | John       | Paul      |   5000 |
| 17 | Mohd       | Yasee     |   3000 |
+----+------------+-----------+--------+
4 rows in set (0.00 sec)
mysql>
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved