详解Java的Hibernate框架中的注解与缓存

注解
hibernate注解是一个没有使用xml文件来定义映射的最新方法。可以在除或替换的xml映射元数据使用注解。

hibernate的注解是强大的方式来提供元数据对象和关系表的映射。所有的元数据被杵到一起的代码pojo java文件这可以帮助用户在开发过程中同时要了解表的结构和pojo。

如果打算让应用程序移植到其他ejb3规范的orm应用程序，必须使用注解来表示映射信息，但仍然如果想要更大的灵活性，那么应该使用基于xml的映射去。

环境设置hibernate注释
首先，必须确保使用的是jdk5.0，否则，需要jdk升级到jdk5.0带注解的原生支持的优势。

其次，需要安装hibernate的3.x注解分发包，可从sourceforge上： (download hibernate annotation) 并拷贝 hibernate-annotations.jar, lib/hibernate-comons-annotations.jar 和 lib/ejb3-persistence.jar 从hibernate注解分配到classpath

注释的类实例：
正如提到的，同时使用hibernate注释工作的所有元数据杵成随着代码的pojo java文件上面这可以帮助用户在开发过程中同时了解表结构和pojo。

考虑到将要使用下面的employee表来存储的对象：

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

下面是用注解来映射与定义的employee表的对象employee类的映射：

import javax.persistence.*;

@entity
@table(name = "employee")
public class employee {
  @id @generatedvalue
  @column(name = "id")
  private int id;

  @column(name = "first_name")
  private string firstname;

  @column(name = "last_name")
  private string lastname;

  @column(name = "salary")
  private int salary; 

  public employee() {}
  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;
  }
}

hibernate检测@id注释是对一个字段，并假设它应该直接通过在运行时域访问一个对象的属性。如果将@id注释getid（）方法，将通过getter和setter方法​​默认情况下允许访问属性。因此，所有其他注释也被放置在任一字段或getter方法​​，以下所选择的策略。下面的部分将解释在上面的类中使用的注释。

@entity 注解:
在ejb3规范说明都包含在javax.persistence包，所以我们导入这个包作为第一步。其次，我们使用了@entity注解来这标志着这个类作为一个实体bean employee类，因此它必须有一个无参数的构造函数，总算是有保护的范围可见。

@table 注解:
@table注释允许指定的表将被用于保存该实体在数据库中的详细信息。

@table注释提供了四个属性，允许覆盖表的名称，它的目录，它的架构，并执行对列的唯一约束在表中。现在，我们使用的是刚刚是employee表的名称。

@id 和 @generatedvalue 注解:
每个实体bean将有一个主键，注释在类的@id注解。主键可以是单个字段或根据表结构的多个字段的组合。

默认情况下，@id注解会自动确定要使用的最合适的主键生成策略，但可以通过应用@generatedvalue注释，它接受两个参数，strategy和generator，不打算在这里讨论，只使用默认的默认键生成策略。让hibernate确定要使用的generator类型使不同数据库之间代码的可移植性。

@column 注解:
@column批注用于指定的列到一个字段或属性将被映射的细节。可以使用列注释以下最常用的属性：

name属性允许将显式指定列的名称。

length 属性允许用于映射一个value尤其是对一个字符串值的列的大小。

nullable 属性允许该列被标记为not null生成架构时。

unique 属性允许被标记为只包含唯一值的列。

创建应用程序类：
最后，我们将创建应用程序类的main（）方法来运行应用程序。我们将使用这个应用程序，以节省一些员工的记录，然后我们将申请crud操作上的记录。

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.cfg.annotationconfiguration;
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 annotationconfiguration().
          configure().
          //addpackage("com.xyz") //add package if used.
          addannotatedclass(employee.class).
          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();
     employee.setfirstname(fname);
     employee.setlastname(lname);
     employee.setsalary(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(); 
   }
  }
}

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

<?xml version="1.0" encoding="utf-8"?>
<!doctype hibernate-configuration system 
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
  <session-factory>
  <property name="hibernate.dialect">
   org.hibernate.dialect.mysqldialect
  </property>
  <property name="hibernate.connection.driver_class">
   com.mysql.jdbc.driver
  </property>

  <!-- assume students is the database name -->
  <property name="hibernate.connection.url">
   jdbc:mysql://localhost/test
  </property>
  <property name="hibernate.connection.username">
   root
  </property>
  <property name="hibernate.connection.password">
   cohondob
  </property>

</session-factory>
</hibernate-configuration>

编译和执行：
下面是步骤来编译并运行上述应用程序。请确保已在进行的编译和执行之前，适当地设置path和classpath。

从路径中删除employee.hbm.xml映射文件。

创建employee.java源文件，如上图所示，并编译它。

创建manageemployee.java源文件，如上图所示，并编译它。

执行manageemployee二进制文件来运行程序。

会得到以下结果，并记录将在employee表中。

$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

如果检查employee表，它应该有以下记录：

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>

缓存
缓存是所有关于应用程序的性能优化和它位于应用程序和数据库之间，以避免数据库访问多次，让性能关键型应用程序有更好的表现。

缓存对hibernate很重要，它采用了多级缓存方案下文所述：

第一级缓存：
第一级缓存是session的缓存，是一个强制性的缓存，通过它所有的请求都必须通过。 session对象不断自身的动力的对象，提交到数据库之前。

如果发出多个更新一个对象，hibernate试图拖延尽可能长的时间做了更新，以减少发出的更新sql语句的数量。如果您关闭会话，所有被缓存的对象都将丢失，要么持久，或在数据库中更新。

二级缓存：
二级缓存是可选的缓存和一级缓存，总是会征询任何试图找到一个对象的二级缓存之前。第二级缓存可以在每个类和每个集合基础上进行配置，主要负责在会话缓存的对象。

任何第三方缓存可以使用hibernate。org.hibernate.cache.cacheprovider接口提供，必须实施提供hibernate一个句柄缓存实现。

查询级别缓存：
hibernate也实现了查询结果集缓存与二级缓存的紧密集成在一起。

这是一个可选功能，需要两个额外的物理缓存中保存缓存的查询结果和地区当一个表的最后更新的时间戳。这只是针对那些使用相同的参数经常运行的查询非常有用。

二级缓存：
hibernate使用一级缓存，默认情况下，你什么都没有做使用第一级缓存。让我们直接进入可选的第二级缓存。并不是所有的类受益于缓存，这样一来就能禁用二级缓存是很重要的

hibernate二级缓存被设置为两个步骤。首先，必须决定要使用的并发策略。在此之后，可以配置缓存过期和使用缓存提供物理缓存属性。

并发策略：
并发策略是一个中介的负责存储数据项在缓存并从缓存中检索它们。如果要启用二级缓存，将必须决定，为每个持久化类和集合，要使用的缓存并发策略。

transactional: 使用这种策略的主要读取数据的地方，以防止过时的数据的并发事务，在更新的罕见情况下是至关重要的。

read-write: 再次使用这种策略的主要读取数据的地方，以防止并发事务陈旧的数据是至关重要的，在更新的罕见情况。

nonstrict-read-write: 这种策略不保证缓存与数据库之间的一致性。使用此策略，如果数据很少改变和陈旧数据的可能性很小关键是不关注。

read-only: 并发策略适用于数据，永远不会改变。使用数据仅供参考。

如果我们要使用第二级缓存为我们的employee类，让我们添加告诉hibernate使用可读写的高速缓存策略employee实例所需的映射元素。

<?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>
   <cache usage="read-write"/>
   <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>

 usage="read-write" 属性告诉hibernate使用一个可读写的并发策略定义的缓存。

缓存提供者：
考虑到会用你的缓存候选类的并发策略后，下一步就是选择一个缓存提供程序。hibernate迫使选择一个缓存提供整个应用程序。

在指定hibernate.cfg.xml配置文件中的缓存提供。选择ehcache作为第二级缓存提供程序：

<?xml version="1.0" encoding="utf-8"?>
<!doctype hibernate-configuration system 
"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">

<hibernate-configuration>
  <session-factory>
  <property name="hibernate.dialect">
   org.hibernate.dialect.mysqldialect
  </property>
  <property name="hibernate.connection.driver_class">
   com.mysql.jdbc.driver
  </property>

  <!-- assume students is the database name -->
  <property name="hibernate.connection.url">
   jdbc:mysql://localhost/test
  </property>
  <property name="hibernate.connection.username">
   root
  </property>
  <property name="hibernate.connection.password">
   root123
  </property>
  <property name="hibernate.cache.provider_class">
   org.hibernate.cache.ehcacheprovider
  </property>

  <!-- list of xml mapping files -->
  <mapping resource="employee.hbm.xml"/>

</session-factory>
</hibernate-configuration>

现在，需要指定缓存区域的属性。ehcache都有自己的配置文件ehcache.xml，在应用程序在classpath中。在ehcache.xml中employee类高速缓存配置可能看起来像这样：

<diskstore path="java.io.tmpdir"/>
<defaultcache
maxelementsinmemory="1000"
eternal="false"
timetoidleseconds="120"
timetoliveseconds="120"
overflowtodisk="true"
/>

<cache name="employee"
maxelementsinmemory="500"
eternal="true"
timetoidleseconds="0"
timetoliveseconds="0"
overflowtodisk="false"
/>

就这样，现在启用employee类的二级缓存和hibernate现在二级缓存，每当浏览到一个雇员或当通过标识符加载雇员。

应该分析你所有的类，并选择适当的缓存策略为每个类。有时，二级缓存可能降级的应用程序的性能。所以建议到基准应用程序第一次没有启用缓存，非常适合缓存和检查性能。如果缓存不提高系统性能再有就是在使任何类型的缓存是没有意义的。

查询级别缓存：
使用查询缓存，必须先使用 hibernate.cache.use_query_cache="true"属性配置文件中激活它。如果将此属性设置为true，让hibernate的在内存中创建所需的高速缓存来保存查询和标识符集。

接下来，使用查询缓存，可以使用query类的setcacheable（boolean）方法。例如：

• session session = sessionfactory.opensession();
• query query = session.createquery("from employee");
• query.setcacheable(true);
• list users = query.list();
• sessionfactory.closesession();

hibernate也支持通过一个缓存区域的概念非常细粒度的缓存支持。缓存区是这是给定一个名称缓存的一部分。

• session session = sessionfactory.opensession();
• query query = session.createquery("from employee");
• query.setcacheable(true);
• query.setcacheregion("employee");
• list users = query.list();
• sessionfactory.closesession();

此代码使用方法告诉hibernate来存储和查找在缓存中的员工方面的查询。