原生 SQL

如果你想使用数据库特定的功能如查询提示或 Oracle 中的 CONNECT 关键字的话，你可以使用原生 SQL 数据库来表达查询。Hibernate 3.x 允许您为所有的创建，更新，删除，和加载操作指定手写 SQL ，包括存储过程。您的应用程序会在会话界面用 createSQLQuery() 方法创建一个原生 SQL 查询： 

  1. public SQLQuery createSQLQuery(String sqlString) throws HibernateException

当你通过一个包含 SQL 查询的 createsqlquery() 方法的字符串时，你可以将 SQL 的结果与现有的 Hibernate 实体，一个连接，或一个标量结果分别使用 addEntity(), addJoin(), 和 addScalar() 方法进行关联。

标量查询

最基本的 SQL 查询是从一个或多个列表中获取一个标量（值）列表。以下是使用原生 SQL 进行获取标量的值的语法： 

  1. String sql = "SELECT first_name, salary FROM EMPLOYEE";
  2. SQLQuery query = session.createSQLQuery(sql);
  3. query.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP);
  4. List results = query.list();

实体查询

以上的查询都是关于返回标量值的查询，只是基础性地返回结果集中的“原始”值。以下是从原生 SQL 查询中通过 addEntity() 方法获取实体对象整体的语法： 

  1. String sql = "SELECT * FROM EMPLOYEE";
  2. SQLQuery query = session.createSQLQuery(sql);
  3. query.addEntity(Employee.class);
  4. List results = query.list();

指定 SQL 查询

以下是从原生 SQL 查询中通过 addEntity() 方法和使用指定 SQL 查询来获取实体对象整体的语法： 

  1. String sql = "SELECT * FROM EMPLOYEE WHERE id = :employee_id";
  2. SQLQuery query = session.createSQLQuery(sql);
  3. query.addEntity(Employee.class);
  4. query.setParameter("employee_id", 10);
  5. List results = query.list();

原生 SQL 的例子

考虑下面的 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 表来存储 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() 方法创建应用程序类来运行应用程序，我们将使用原生 SQL 查询： 

  1. import java.util.*; 
  3. import org.hibernate.HibernateException; 
  4. import org.hibernate.Session; 
  5. import org.hibernate.Transaction;
  6. import org.hibernate.SessionFactory;
  7. import org.hibernate.SQLQuery;
  8. import org.hibernate.Criteria;
  9. import org.hibernate.Hibernate;
  10. import org.hibernate.cfg.Configuration;
  12. public class ManageEmployee {
  13.    private static SessionFactory factory; 
  14.    public static void main(String[] args) {
  15.       try{
  16.          factory = new Configuration().configure().buildSessionFactory();
  17.       }catch (Throwable ex) { 
  18.          System.err.println("Failed to create sessionFactory object." + ex);
  19.          throw new ExceptionInInitializerError(ex); 
  20.       }
  21.       ManageEmployee ME = new ManageEmployee();
  23.       /* Add few employee records in database */
  24.       Integer empID1 = ME.addEmployee("Zara", "Ali", 2000);
  25.       Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
  26.       Integer empID3 = ME.addEmployee("John", "Paul", 5000);
  27.       Integer empID4 = ME.addEmployee("Mohd", "Yasee", 3000);
  29.       /* List down employees and their salary using Scalar Query */
  30.       ME.listEmployeesScalar();
  32.       /* List down complete employees information using Entity Query */
  33.       ME.listEmployeesEntity();
  34.    }
  35.    /* Method to CREATE an employee in the database */
  36.    public Integer addEmployee(String fname, String lname, int salary){
  37.       Session session = factory.openSession();
  38.       Transaction tx = null;
  39.       Integer employeeID = null;
  40.       try{
  41.          tx = session.beginTransaction();
  42.          Employee employee = new Employee(fname, lname, salary);
  43.          employeeID = (Integer) session.save(employee); 
  44.          tx.commit();
  45.       }catch (HibernateException e) {
  46.          if (tx!=null) tx.rollback();
  47.          e.printStackTrace(); 
  48.       }finally {
  49.          session.close(); 
  50.       }
  51.       return employeeID;
  52.    }
  54.    /* Method to  READ all the employees using Scalar Query */
  55.    public void listEmployeesScalar( ){
  56.       Session session = factory.openSession();
  57.       Transaction tx = null;
  58.       try{
  59.          tx = session.beginTransaction();
  60.          String sql = "SELECT first_name, salary FROM EMPLOYEE";
  61.          SQLQuery query = session.createSQLQuery(sql);
  62.          query.setResultTransformer(Criteria.ALIAS_TO_ENTITY_MAP);
  63.          List data = query.list();
  65.          for(Object object : data)
  66.          {
  67.             Map row = (Map)object;
  68.             System.out.print("First Name: " + row.get("first_name")); 
  69.             System.out.println(", Salary: " + row.get("salary")); 
  70.          }
  71.          tx.commit();
  72.       }catch (HibernateException e) {
  73.          if (tx!=null) tx.rollback();
  74.          e.printStackTrace(); 
  75.       }finally {
  76.          session.close(); 
  77.       }
  78.    }
  80.    /* Method to  READ all the employees using Entity Query */
  81.    public void listEmployeesEntity( ){
  82.       Session session = factory.openSession();
  83.       Transaction tx = null;
  84.       try{
  85.          tx = session.beginTransaction();
  86.          String sql = "SELECT * FROM EMPLOYEE";
  87.          SQLQuery query = session.createSQLQuery(sql);
  88.          query.addEntity(Employee.class);
  89.          List employees = query.list();
  91.          for (Iterator iterator = 
  92.                            employees.iterator(); iterator.hasNext();){
  93.             Employee employee = (Employee) iterator.next(); 
  94.             System.out.print("First Name: " + employee.getFirstName()); 
  95.             System.out.print("  Last Name: " + employee.getLastName()); 
  96.             System.out.println("  Salary: " + employee.getSalary()); 
  97.          }
  98.          tx.commit();
  99.       }catch (HibernateException e) {
  100.          if (tx!=null) tx.rollback();
  101.          e.printStackTrace(); 
  102.       }finally {
  103.          session.close(); 
  104.       }
  105.    }
  106. }

编译和执行

这是编译并运行上述应用程序的步骤。确保你有适当的 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: Zara, Salary: 2000
  5. First Name: Daisy, Salary: 5000
  6. First Name: John, Salary: 5000
  7. First Name: Mohd, Salary: 3000
  8. First Name: Zara  Last Name: Ali  Salary: 2000
  9. First Name: Daisy  Last Name: Das  Salary: 5000
  10. First Name: John  Last Name: Paul  Salary: 5000
  11. First Name: Mohd  Last Name: Yasee  Salary: 3000

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

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