注释

到现在为止，你已经看到 Hibernate 如何使用 XML 映射文件来完成从 POJO 到数据库表的数据转换的，反之亦然。Hibernate 注释是无需使用 XML 文件来定义映射的最新方法。你可以额外使用注释或直接代替 XML 映射元数据。

Hibernate 注释是一种强大的来给对象和关系映射表提供元数据的方法。所有的元数据被添加到 POJO java 文件代码中，这有利于用户在开发时更好的理解表的结构和 POJO。

如果你想让你的应用程序移植到其它 EJB 3 的 ORM 应用程序中,您必须使用注释来表示映射信息，但是如果想要得到更大的灵活性,那么你应该使用基于 XML 的映射。

Hibernate 注释的环境设置

首先你必须确定你使用的是 JDK 5.0，否则你需要升级你的 JDK 至 JDK 5.0，来使你的主机能够支持注释。

其次，你需要安装 Hibernate 3.x 注释包，可以从 sourceforge 行下载：（下载 Hibernate 注释） 并且从 Hibernate 注释发布中拷贝 hibernate-annotations.jar, lib/hibernate-comons-annotations.jar 和 lib/ejb3-persistence.jar 到你的 CLASSPATH。

注释类示例

正如我上面所提到的，所有的元数据被添加到 POJO java 文件代码中，这有利于用户在开发时更好的理解表的结构和 POJO。

下面我们将使用 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. );

以下是用带有注释的 Employee 类来映射使用定义好的 Employee 表的对象:

  1. import javax.persistence.*;
  3. @Entity
  4. @Table(name = "EMPLOYEE")
  5. public class Employee {
  6.    @Id @GeneratedValue
  7.    @Column(name = "id")
  8.    private int id;
  10.    @Column(name = "first_name")
  11.    private String firstName;
  13.    @Column(name = "last_name")
  14.    private String lastName;
  16.    @Column(name = "salary")
  17.    private int salary;  
  19.    public Employee() {}
  20.    public int getId() {
  21.       return id;
  22.    }
  23.    public void setId( int id ) {
  24.       this.id = id;
  25.    }
  26.    public String getFirstName() {
  27.       return firstName;
  28.    }
  29.    public void setFirstName( String first_name ) {
  30.       this.firstName = first_name;
  31.    }
  32.    public String getLastName() {
  33.       return lastName;
  34.    }
  35.    public void setLastName( String last_name ) {
  36.       this.lastName = last_name;
  37.    }
  38.    public int getSalary() {
  39.       return salary;
  40.    }
  41.    public void setSalary( int salary ) {
  42.       this.salary = salary;
  43.    }
  44. }

Hibernate 检测到 @Id 注释字段并且认定它应该在运行时通过字段直接访问一个对象上的属性。如果你将 @Id 注释放在 getId() 方法中，你可以通过默认的 getter 和 setter 方法来访问属性。因此，所有其它注释也放在字段或是 getter 方法中，决定于选择的策略。下一节将解释上面的类中使用的注释。

@Entity 注释

EJB 3 标准的注释包含在 javax.persistence 包，所以我们第一步需要导入这个包。第二步我们对 Employee 类使用 @Entity 注释，标志着这个类为一个实体 bean，所以它必须含有一个没有参数的构造函数并且在可保护范围是可见的。

@Table 注释

@table 注释允许您明确表的详细信息保证实体在数据库中持续存在。

@table 注释提供了四个属性，允许您覆盖的表的名称，目录及其模式,在表中可以对列制定独特的约束。现在我们使用的是表名为 EMPLOYEE。

@Id 和 @GeneratedValue 注释

每一个实体 bean 都有一个主键，你在类中可以用 @Id 来进行注释。主键可以是一个字段或者是多个字段的组合，这取决于你的表的结构。

默认情况下，@Id 注释将自动确定最合适的主键生成策略，但是你可以通过使用 @GeneratedValue 注释来覆盖掉它。strategy 和 generator 这两个参数我不打算在这里讨论，所以我们只使用默认键生成策略。让 Hibernate 确定使用哪些生成器类型来使代码移植于不同的数据库之间。

@Column Annotation

@Column 注释用于指定某一列与某一个字段或是属性映射的细节信息。您可以使用下列注释的最常用的属性:

  • name 属性允许显式地指定列的名称。
  • length 属性为用于映射一个值，特别为一个字符串值的列的大小。
  • nullable 属性允许当生成模式时，一个列可以被标记为非空。
  • unique 属性允许列中只能含有唯一的内容

创建应用类

最后,我们将创建应用程序类，并使用 main() 方法来运行应用程序。我们将使用此应用程序来保存一些员工的记录,然后我们对这些记录进行 CRUD 操作。

  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.cfg.AnnotationConfiguration;
  9. import org.hibernate.SessionFactory;
  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 AnnotationConfiguration().
  17.                    configure().
  18.                    //addPackage("com.xyz") //add package if used.
  19.                    addAnnotatedClass(Employee.class).
  20.                    buildSessionFactory();
  21.       }catch (Throwable ex) { 
  22.          System.err.println("Failed to create sessionFactory object." + ex);
  23.          throw new ExceptionInInitializerError(ex); 
  24.       }
  25.       ManageEmployee ME = new ManageEmployee();
  27.       /* Add few employee records in database */
  28.       Integer empID1 = ME.addEmployee("Zara", "Ali", 1000);
  29.       Integer empID2 = ME.addEmployee("Daisy", "Das", 5000);
  30.       Integer empID3 = ME.addEmployee("John", "Paul", 10000);
  32.       /* List down all the employees */
  33.       ME.listEmployees();
  35.       /* Update employee's records */
  36.       ME.updateEmployee(empID1, 5000);
  38.       /* Delete an employee from the database */
  39.       ME.deleteEmployee(empID2);
  41.       /* List down new list of the employees */
  42.       ME.listEmployees();
  43.    }
  44.    /* Method to CREATE an employee in the database */
  45.    public Integer addEmployee(String fname, String lname, int salary){
  46.       Session session = factory.openSession();
  47.       Transaction tx = null;
  48.       Integer employeeID = null;
  49.       try{
  50.          tx = session.beginTransaction();
  51.          Employee employee = new Employee();
  52.          employee.setFirstName(fname);
  53.          employee.setLastName(lname);
  54.          employee.setSalary(salary);
  55.          employeeID = (Integer) session.save(employee); 
  56.          tx.commit();
  57.       }catch (HibernateException e) {
  58.          if (tx!=null) tx.rollback();
  59.          e.printStackTrace(); 
  60.       }finally {
  61.          session.close(); 
  62.       }
  63.       return employeeID;
  64.    }
  65.    /* Method to  READ all the employees */
  66.    public void listEmployees( ){
  67.       Session session = factory.openSession();
  68.       Transaction tx = null;
  69.       try{
  70.          tx = session.beginTransaction();
  71.          List employees = session.createQuery("FROM Employee").list(); 
  72.          for (Iterator iterator = 
  73.                            employees.iterator(); iterator.hasNext();){
  74.             Employee employee = (Employee) iterator.next(); 
  75.             System.out.print("First Name: " + employee.getFirstName()); 
  76.             System.out.print("  Last Name: " + employee.getLastName()); 
  77.             System.out.println("  Salary: " + employee.getSalary()); 
  78.          }
  79.          tx.commit();
  80.       }catch (HibernateException e) {
  81.          if (tx!=null) tx.rollback();
  82.          e.printStackTrace(); 
  83.       }finally {
  84.          session.close(); 
  85.       }
  86.    }
  87.    /* Method to UPDATE salary for an employee */
  88.    public void updateEmployee(Integer EmployeeID, int salary ){
  89.       Session session = factory.openSession();
  90.       Transaction tx = null;
  91.       try{
  92.          tx = session.beginTransaction();
  93.          Employee employee = 
  94.                     (Employee)session.get(Employee.class, EmployeeID); 
  95.          employee.setSalary( salary );
  96.          session.update(employee); 
  97.          tx.commit();
  98.       }catch (HibernateException e) {
  99.          if (tx!=null) tx.rollback();
  100.          e.printStackTrace(); 
  101.       }finally {
  102.          session.close(); 
  103.       }
  104.    }
  105.    /* Method to DELETE an employee from the records */
  106.    public void deleteEmployee(Integer EmployeeID){
  107.       Session session = factory.openSession();
  108.       Transaction tx = null;
  109.       try{
  110.          tx = session.beginTransaction();
  111.          Employee employee = 
  112.                    (Employee)session.get(Employee.class, EmployeeID); 
  113.          session.delete(employee); 
  114.          tx.commit();
  115.       }catch (HibernateException e) {
  116.          if (tx!=null) tx.rollback();
  117.          e.printStackTrace(); 
  118.       }finally {
  119.          session.close(); 
  120.       }
  121.    }
  122. }

数据库配置

现在，让我们创建 hibernate.cfg.xml 配置文件来定义数据库相关参数。

  1. <?xml version="1.0" encoding="utf-8"?>
  2. <!DOCTYPE hibernate-configuration SYSTEM 
  3. "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
  5. <hibernate-configuration>
  6.    <session-factory>
  7.    <property name="hibernate.dialect">
  8.       org.hibernate.dialect.MySQLDialect
  9.    </property>
  10.    <property name="hibernate.connection.driver_class">
  11.       com.mysql.jdbc.Driver
  12.    </property>
  14.    <!-- Assume students is the database name -->
  15.    <property name="hibernate.connection.url">
  16.       jdbc:mysql://localhost/test
  17.    </property>
  18.    <property name="hibernate.connection.username">
  19.       root
  20.    </property>
  21.    <property name="hibernate.connection.password">
  22.       cohondob
  23.    </property>
  25. </session-factory>
  26. </hibernate-configuration>

编译和执行

这里是编译并运行以上提到的应用程序的步骤。再继续编译和运行之前需要确保你正确设置路径和类路径。

  • 从目录中删除 Employee.hbm.xml 映射文件。
  • 创建上述 Employee.java 源文件并编译。
  • 创建上述 ManageEmployee.java 源文件并编译。
  • 执行 ManageEmployee 二进制程序。

你将得到如下结果，并且会在 EMPLOYEE 表中记录。

  1. $java ManageEmployee
  2. .......VARIOUS LOG MESSAGES WILL DISPLAY HERE........
  4. First Name: Zara  Last Name: Ali  Salary: 1000
  5. First Name: Daisy  Last Name: Das  Salary: 5000
  6. First Name: John  Last Name: Paul  Salary: 10000
  7. First Name: Zara  Last Name: Ali  Salary: 5000
  8. First Name: John  Last Name: Paul  Salary: 10000

如果你查看 EMPLOYEE 表，它将有如下记录：

  1. mysql> select * from EMPLOYEE;
  2. +----+------------+-----------+--------+
  3. | id | first_name | last_name | salary |
  4. +----+------------+-----------+--------+
  5. | 29 | Zara       | Ali       |   5000 |
  6. | 31 | John       | Paul      |  10000 |
  7. +----+------------+-----------+--------+
  8. 2 rows in set (0.00 sec
  10. mysql>