标准查询

Hibernate 提供了操纵对象和相应的 RDBMS 表中可用的数据的替代方法。一种方法是标准的 API，它允许你建立一个标准的可编程查询对象来应用过滤规则和逻辑条件。

Hibernate Session 接口提供了 createCriteria() 方法，可用于创建一个 Criteria 对象，使当您的应用程序执行一个标准查询时返回一个持久化对象的类的实例。

以下是一个最简单的标准查询的例子，它只是简单地返回对应于员工类的每个对象： 

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

对标准的限制

你可以使用 Criteria 对象可用的 add() 方法去添加一个标准查询的限制。

以下是一个示例，它实现了添加一个限制，令返回工资等于 2000 的记录： 

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

以下是几个例子，涵盖了不同的情况，可按要求进行使用： 

  1. Criteria cr = session.createCriteria(Employee.class);
  3. // To get records having salary more than 2000
  4. cr.add(Restrictions.gt("salary", 2000));
  6. // To get records having salary less than 2000
  7. cr.add(Restrictions.lt("salary", 2000));
  9. // To get records having fistName starting with zara
  10. cr.add(Restrictions.like("firstName", "zara%"));
  12. // Case sensitive form of the above restriction.
  13. cr.add(Restrictions.ilike("firstName", "zara%"));
  15. // To get records having salary in between 1000 and 2000
  16. cr.add(Restrictions.between("salary", 1000, 2000));
  18. // To check if the given property is null
  19. cr.add(Restrictions.isNull("salary"));
  21. // To check if the given property is not null
  22. cr.add(Restrictions.isNotNull("salary"));
  24. // To check if the given property is empty
  25. cr.add(Restrictions.isEmpty("salary"));
  27. // To check if the given property is not empty
  28. cr.add(Restrictions.isNotEmpty("salary"));

你可以模仿以下示例，使用逻辑表达式创建 AND 或 OR 的条件组合： 

  1. Criteria cr = session.createCriteria(Employee.class);
  3. Criterion salary = Restrictions.gt("salary", 2000);
  4. Criterion name = Restrictions.ilike("firstNname","zara%");
  6. // To get records matching with OR condistions
  7. LogicalExpression orExp = Restrictions.or(salary, name);
  8. cr.add( orExp );
  11. // To get records matching with AND condistions
  12. LogicalExpression andExp = Restrictions.and(salary, name);
  13. cr.add( andExp );
  15. List results = cr.list();

另外，上述所有的条件都可按之前的教程中解释的那样与 HQL 直接使用。

分页使用标准

这里有两种分页标准接口方法：

序号 方法描述
1 public Criteria setFirstResult(int firstResult)，这种方法需要一个代表你的结果集的第一行的整数，以第 0 行为开始。
2 public Criteria setMaxResults(int maxResults)，这个方法设置了 Hibernate 检索对象的 maxResults。

利用上述两种方法结合在一起，我们可以在我们的 Web 或 Swing 应用程序构建一个分页组件。以下是一个例子，利用它你可以一次取出 10 行：

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

排序结果

标准 API 提供了 org.hibernate.criterion.order 类可以去根据你的一个对象的属性把你的排序结果集按升序或降序排列。这个例子演示了如何使用 Order 类对结果集进行排序： 

  1. Criteria cr = session.createCriteria(Employee.class);
  2. // To get records having salary more than 2000
  3. cr.add(Restrictions.gt("salary", 2000));
  5. // To sort records in descening order
  6. crit.addOrder(Order.desc("salary"));
  8. // To sort records in ascending order
  9. crit.addOrder(Order.asc("salary"));
  11. List results = cr.list();

预测与聚合

标准 API 提供了 org.hibernate.criterion.projections 类可得到各属性值的平均值，最大值或最小值。Projections 类与 Restrictions 类相似，均提供了几个获取预测实例的静态工厂方法。

以下是几个例子，涵盖了不同的情况，可按要求进行使用： 

  1. Criteria cr = session.createCriteria(Employee.class);
  3. // To get total row count.
  4. cr.setProjection(Projections.rowCount());
  6. // To get average of a property.
  7. cr.setProjection(Projections.avg("salary"));
  9. // To get distinct count of a property.
  10. cr.setProjection(Projections.countDistinct("firstName"));
  12. // To get maximum of a property.
  13. cr.setProjection(Projections.max("salary"));
  15. // To get minimum of a property.
  16. cr.setProjection(Projections.min("salary"));
  18. // To get sum of a property.
  19. cr.setProjection(Projections.sum("salary"));

标准查询示例

考虑下面的 POJO 类： 

  1. public class Employee {
  2.    private int id;
  3.    private String firstName; 
  4.    private String lastName;   
  5.    private int salary;  
  7.    public Employee() {}
  8.    public Employee(String fname, String lname, int salary) {
  9.       this.firstName = fname;
  10.       this.lastName = lname;
  11.       this.salary = salary;
  12.    }
  13.    public int getId() {
  14.       return id;
  15.    }
  16.    public void setId( int id ) {
  17.       this.id = id;
  18.    }
  19.    public String getFirstName() {
  20.       return firstName;
  21.    }
  22.    public void setFirstName( String first_name ) {
  23.       this.firstName = first_name;
  24.    }
  25.    public String getLastName() {
  26.       return lastName;
  27.    }
  28.    public void setLastName( String last_name ) {
  29.       this.lastName = last_name;
  30.    }
  31.    public int getSalary() {
  32.       return salary;
  33.    }
  34.    public void setSalary( int salary ) {
  35.       this.salary = salary;
  36.    }
  37. }

让我们创建以下员工表来存储 Employee 对象：

  1. create table EMPLOYEE (
  2.    id INT NOT NULL auto_increment,
  3.    first_name VARCHAR(20) default NULL,
  4.    last_name  VARCHAR(20) default NULL,
  5.    salary     INT  default NULL,
  6.    PRIMARY KEY (id)
  7. );

以下是映射文件： 

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-mapping PUBLIC 
  3.  "-//Hibernate/Hibernate Mapping DTD//EN"
  4.  "http://www.hibernate.org/dtd/hibernate-mapping-3.0.dtd"> 
  6. <hibernate-mapping>
  7.    <class name="Employee" table="EMPLOYEE">
  8.       <meta attribute="class-description">
  9.          This class contains the employee detail. 
  10.       </meta>
  11.       <id name="id" type="int" column="id">
  12.          <generator class="native"/>
  13.       </id>
  14.       <property name="firstName" column="first_name" type="string"/>
  15.       <property name="lastName" column="last_name" type="string"/>
  16.       <property name="salary" column="salary" type="int"/>
  17.    </class>
  18. </hibernate-mapping>

最后，我们将用 main() 方法创建应用程序类来运行应用程序，我们将使用 Criteria 查询： 

  1. import java.util.List; 
  2. import java.util.Date;
  3. import java.util.Iterator; 
  5. import org.hibernate.HibernateException; 
  6. import org.hibernate.Session; 
  7. import org.hibernate.Transaction;
  8. import org.hibernate.SessionFactory;
  9. import org.hibernate.Criteria;
  10. import org.hibernate.criterion.Restrictions;
  11. import org.hibernate.criterion.Projections;
  12. import org.hibernate.cfg.Configuration;
  14. public class ManageEmployee {
  15.    private static SessionFactory factory; 
  16.    public static void main(String[] args) {
  17.       try{
  18.          factory = new Configuration().configure().buildSessionFactory();
  19.       }catch (Throwable ex) { 
  20.          System.err.println("Failed to create sessionFactory object." + ex);
  21.          throw new ExceptionInInitializerError(ex); 
  22.       }
  23.       ManageEmployee ME = new ManageEmployee();
  25.       /* Add few employee records in database */
  26.       Integer empID1 = ME.addEmployee("Zara", "Ali", 2000);
  27.       Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
  28.       Integer empID3 = ME.addEmployee("John", "Paul", 5000);
  29.       Integer empID4 = ME.addEmployee("Mohd", "Yasee", 3000);
  31.       /* List down all the employees */
  32.       ME.listEmployees();
  34.       /* Print Total employee's count */
  35.       ME.countEmployee();
  37.       /* Print Toatl salary */
  38.       ME.totalSalary();
  39.    }
  40.    /* Method to CREATE an employee in the database */
  41.    public Integer addEmployee(String fname, String lname, int salary){
  42.       Session session = factory.openSession();
  43.       Transaction tx = null;
  44.       Integer employeeID = null;
  45.       try{
  46.          tx = session.beginTransaction();
  47.          Employee employee = new Employee(fname, lname, salary);
  48.          employeeID = (Integer) session.save(employee); 
  49.          tx.commit();
  50.       }catch (HibernateException e) {
  51.          if (tx!=null) tx.rollback();
  52.          e.printStackTrace(); 
  53.       }finally {
  54.          session.close(); 
  55.       }
  56.       return employeeID;
  57.    }
  59.    /* Method to  READ all the employees having salary more than 2000 */
  60.    public void listEmployees( ){
  61.       Session session = factory.openSession();
  62.       Transaction tx = null;
  63.       try{
  64.          tx = session.beginTransaction();
  65.          Criteria cr = session.createCriteria(Employee.class);
  66.          // Add restriction.
  67.          cr.add(Restrictions.gt("salary", 2000));
  68.          List employees = cr.list();
  70.          for (Iterator iterator = 
  71.                            employees.iterator(); iterator.hasNext();){
  72.             Employee employee = (Employee) iterator.next(); 
  73.             System.out.print("First Name: " + employee.getFirstName()); 
  74.             System.out.print("  Last Name: " + employee.getLastName()); 
  75.             System.out.println("  Salary: " + employee.getSalary()); 
  76.          }
  77.          tx.commit();
  78.       }catch (HibernateException e) {
  79.          if (tx!=null) tx.rollback();
  80.          e.printStackTrace(); 
  81.       }finally {
  82.          session.close(); 
  83.       }
  84.    }
  85.    /* Method to print total number of records */
  86.    public void countEmployee(){
  87.       Session session = factory.openSession();
  88.       Transaction tx = null;
  89.       try{
  90.          tx = session.beginTransaction();
  91.          Criteria cr = session.createCriteria(Employee.class);
  93.          // To get total row count.
  94.          cr.setProjection(Projections.rowCount());
  95.          List rowCount = cr.list();
  97.          System.out.println("Total Coint: " + rowCount.get(0) );
  98.          tx.commit();
  99.       }catch (HibernateException e) {
  100.          if (tx!=null) tx.rollback();
  101.          e.printStackTrace(); 
  102.       }finally {
  103.          session.close(); 
  104.       }
  105.    }
  106.   /* Method to print sum of salaries */
  107.    public void totalSalary(){
  108.       Session session = factory.openSession();
  109.       Transaction tx = null;
  110.       try{
  111.          tx = session.beginTransaction();
  112.          Criteria cr = session.createCriteria(Employee.class);
  114.          // To get total salary.
  115.          cr.setProjection(Projections.sum("salary"));
  116.          List totalSalary = cr.list();
  118.          System.out.println("Total Salary: " + totalSalary.get(0) );
  119.          tx.commit();
  120.       }catch (HibernateException e) {
  121.          if (tx!=null) tx.rollback();
  122.          e.printStackTrace(); 
  123.       }finally {
  124.          session.close(); 
  125.       }
  126.    }
  127. }

编译和执行

这是编译并运行上述应用程序的步骤。确保你有适当的 PATH 和 CLASSPATH，然后执行编译程序。

  • 按照在配置一章讲述的方法创建 hibernate.cfg.xml 配置文件。
  • 如上述所示创建 employee.hbm.xml 映射文件。
  • 如上述所示创建 employee.java 源文件并编译。
  • 如上述所示创建 manageemployee.java 源文件并编译。
  • 执行 manageemployee 二进制代码运行程序。

你会得到下面的结果，并且记录将会在 EMPLOYEE 表创建。 

  1. $java ManageEmployee
  2. .......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
  4. First Name: Daisy  Last Name: Das  Salary: 5000
  5. First Name: John  Last Name: Paul  Salary: 5000
  6. First Name: Mohd  Last Name: Yasee  Salary: 3000
  7. Total Coint: 4
  8. Total Salary: 15000

如果你检查你的 EMPLOYEE 表，它应该有以下记录： 

  1. mysql> select * from EMPLOYEE;
  2. +----+------------+-----------+--------+
  3. | id | first_name | last_name | salary |
  4. +----+------------+-----------+--------+
  5. | 14 | Zara       | Ali       |   2000 |
  6. | 15 | Daisy      | Das       |   5000 |
  7. | 16 | John       | Paul      |   5000 |
  8. | 17 | Mohd       | Yasee     |   3000 |
  9. +----+------------+-----------+--------+
  10. 4 rows in set (0.00 sec)
  11. mysql>