Hibernate二级缓存

休眠二级缓存将通用缓存用于会话工厂的所有会话对象。如果你有一个会话工厂中的多个会话对象, 这将很有用。

SessionFactory保存第二级缓存数据。它对于所有会话对象都是全局的, 默认情况下未启用。

不同的供应商提供了二级缓存的实现。

1. EH快取
2. 操作系统缓存
3. 群缓存
4. JBoss缓存

每个实现提供不同的缓存使用功能。有两种使用二级缓存的方法。

1. 只读：缓存将适用于只读操作。
2. nonstrict-read-write：缓存可用于读写, 但一次只能缓存一次。
3. 读写：缓存适用于读写, 可以同时使用。
4. 事务性的：缓存将适用于事务。

可以将cache-usage属性应用于hbm.xml文件中的类或集合级别。下面给出了定义缓存使用情况的示例：

<cache usage="read-only" />

让我们看看第二级缓存实现和缓存使用情况。

休眠二级缓存示例

要通过示例了解二级缓存, 我们需要执行以下步骤：

1. 使用Maven创建持久类
2. 在pom.xml文件中添加项目信息和配置
3. 创建配置文件
4. 创建检索持久对象的类。

在这里, 我们假设oracle数据库中有emp1012表, 其中包含一些记录。

1）使用Maven创建持久类。

package com.srcmini;  
import javax.persistence.*;
import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;
@Entity
@Table(name="emp1012")
@Cacheable
@Cache(usage=CacheConcurrencyStrategy.READ_ONLY)
public class Employee {  
	@Id
private int id;  
private String name;  
private float salary;  
  
public Employee() {}  
public Employee(String name, float salary) {  
    super();  
    this.name = name;  
    this.salary = salary;  
}
public int getId() {
	return id;
}
public void setId(int id) {
	this.id = id;
}
public String getName() {
	return name;
}
public void setName(String name) {
	this.name = name;
}
public float getSalary() {
	return salary;
}
public void setSalary(float salary) {
	this.salary = salary;
}  
}

2）在pom.xml文件中添加项目信息和配置。

打开pom.xml文件, 然后单击源。现在, 在<dependencies> …. </ dependencies>标记之间添加以下依赖关系。

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-core</artifactId>
    <version>5.2.16.Final</version>
</dependency>
	
<dependency>
    <groupId>com.oracle</groupId>
    <artifactId>ojdbc14</artifactId>
    <version>10.2.0.4.0</version>
</dependency>
    
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.3</version>
</dependency>
    
   
<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-ehcache</artifactId>
    <version>5.2.16.Final</version>
</dependency>

3）创建配置文件

<?xml version='1.0' encoding='UTF-8'?>  
<!DOCTYPE hibernate-configuration PUBLIC  
          "-//Hibernate/Hibernate Configuration DTD 5.2.0//EN"  
          "http://hibernate.sourceforge.net/hibernate-configuration-5.2.0.dtd">  
  
<hibernate-configuration>  
  
    <session-factory>  
        <property name="show_sql">true</property>  
        <property name="hbm2ddl.auto">update</property>  
        <property name="dialect">org.hibernate.dialect.Oracle9Dialect</property>  
        <property name="connection.url">jdbc:oracle:thin:@localhost:1521:xe</property>  
        <property name="connection.username">system</property>  
        <property name="connection.password">jtp</property>  
        <property name="connection.driver_class">oracle.jdbc.driver.OracleDriver</property>  
       
         <property name="cache.use_second_level_cache">true</property> 
         <property name="cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory</property>
         <mapping class="com.srcmini.Employee"/>
    </session-factory>  
</hibernate-configuration>

要实现二级缓存, 我们需要在配置文件中定义cache.provider_class属性。

4）创建检索持久对象的类。

package com.srcmini;  
  
import org.hibernate.Session;  
import org.hibernate.SessionFactory;
import org.hibernate.boot.Metadata;
import org.hibernate.boot.MetadataSources;
import org.hibernate.boot.registry.StandardServiceRegistry;
import org.hibernate.boot.registry.StandardServiceRegistryBuilder;
  
public class FetchTest {  
public static void main(String[] args) {  
	StandardServiceRegistry ssr=new StandardServiceRegistryBuilder().configure("hibernate.cfg.xml").build();
	Metadata meta=new MetadataSources(ssr).getMetadataBuilder().build();
	
	SessionFactory factory=meta.getSessionFactoryBuilder().build();
      
    Session session1=factory.openSession();  
    Employee emp1=(Employee)session1.load(Employee.class, 121);  
    System.out.println(emp1.getId()+" "+emp1.getName()+" "+emp1.getSalary());  
    session1.close();  
      
    Session session2=factory.openSession();  
    Employee emp2=(Employee)session2.load(Employee.class, 121);  
    System.out.println(emp2.getId()+" "+emp2.getName()+" "+emp2.getSalary());  
    session2.close();  
      
}  
}

输出：

正如我们在这里看到的, 休眠不会触发两次查询。如果你不使用二级缓存, 则由于两个查询使用不同的会话对象, 因此休眠将触发两次查询。