Hibernate 使用ehcache配置二级缓存

向右看齐 2022-06-06 00:21 155阅读 0赞

**Hibernate 使用ehcache配置二级缓存**  
  
 Hibernate包括两个级别的缓存：  
 1、一级缓存：默认总是启用的session级别的。  
 2、二级缓存：可选的SessionFactory级别的。二级缓存默认情况下是关闭的，如果需要使用打开。使用二级缓存需要借助第三方工具：ehcache redis 等。  
  
  
什么样的数据适合存放到第二级缓存中？  
1 很少被修改的数据  
2 不是很重要的数据，允许出现偶尔并发的数据  
3 不会被并发访问的数据  
4 参考数据,指的是供应用参考的常量数据，它的实例数目有限，它的实例会被许多其他类的实例引用，实例极少或者从来不会被修改。  
  
  
不适合存放到第二级缓存的数据？  
1 经常被修改的数据  
2 财务数据，绝对不允许出现并发  
3 与其他应用共享的数据。  
  
  
  
**使用EhCache配置二级缓存：**

1、需要导入的jar包

![Center][]

2、需要在主配置文件中配置  
  
<property name="hibernate.cache.region.factory\_class">org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory</property>  
  
<class-cache usage="read-write" class="cn.sz.pojo.User" />  
  
<collection-cache usage="nonstrict-read-write" collection="cn.sz.pojo.User.orderss" />  
  
  
3、需要 ehcache.xml文件  
  
  
**下面是测试案例：**  
  
本案例使用的hibernate版本为 hibernate-release-5.2.10.Final 。 为了测试，本案例在mysql数据库中创建了一个db数据库。 示例描述一个案例，在网上购物系统中一个用户可以有多个订单，所以用户和订单属于一对多关系，下面进行测试：

项目结构：

![Center 1][]  
把ehcache.xml缓存文件放在src下面（本人忘记截图了）。

lib目录下则是hibernate5需要的jar包（注需要将jar加载到项目中：选中jar包右键 --》BuildPath--》Add to Build Path）

![Center 2][]

log4j.properties为日志配置文件（需要加载配置junit），此项目可以不需要日志，使用日志只是为了观察方便。  
注：junit配置可以参考 [http://blog.csdn.net/benxiaohai888/article/details/78231911][http_blog.csdn.net_benxiaohai888_article_details_78231911]

由于在主配置文件配置了字段创建数据表的配置，所以第一次加载时就会自动创建数据表

配置的代码：

<property name="hbm2ddl.auto">update</property>

示例代码：

1、主配置文件 hibernate.hbm.xml

<?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE hibernate-configuration PUBLIC
    	"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
    	"http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
    <hibernate-configuration>
    	<session-factory>
    		
    		
    		<property name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
    		
    		<property name="hibernate.connection.url">jdbc:mysql://localhost:3306/db?characterEncoding=utf8</property>
    		
    		<property name="hibernate.connection.username">root</property>
    		
    		<property name="hibernate.connection.password"></property>
    
    		
    		<property name="hibernate.dialect">org.hibernate.dialect.MySQL5Dialect</property>
    
    		
    
    		
    
    
    		
    		<property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory</property>
    
    		
    		<property name="hibernate.show_sql">true</property>
    		
    		<property name="hibernate.format_sql">true</property>
    		
    		<property name="hbm2ddl.auto">update</property>
    		
    		<property name="hibernate.current_session_context_class">thread</property>
    		
    		<property name="hibernate.connection.isolation">4</property>
    
    		
    		
    		<mapping class="cn.sz.pojo.User" />
    		<mapping class="cn.sz.pojo.Orders" />
    
    		
    		<class-cache usage="read-write" class="cn.sz.pojo.User" />
    		
    		<collection-cache usage="nonstrict-read-write"
    			collection="cn.sz.pojo.User.orderss" />
    	</session-factory>
    </hibernate-configuration>

2、ehcache.xml文件

<?xml version="1.0" encoding="UTF-8"?>
    <ehcache>
        <diskStore path="d:/hibernateCache"/>
        <defaultCache
            maxElementsInMemory="10"
            eternal="false"
            timeToIdleSeconds="120"
            timeToLiveSeconds="120"
            overflowToDisk="true"/>
            
        <cache name="cn.sz.pojo.User"
            maxElementsInMemory="10"
            eternal="false"
            timeToIdleSeconds="300"
            timeToLiveSeconds="600"
            overflowToDisk="true"/>
            
    </ehcache>

3、log4j.properties（日志文件）

log4j.rootLogger=DEBUG,console,FILE
    log4j.appender.console=org.apache.log4j.ConsoleAppender
    log4j.appender.console.threshold=INFO
    log4j.appender.console.layout=org.apache.log4j.PatternLayout
    log4j.appender.console.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n
    log4j.appender.FILE=org.apache.log4j.RollingFileAppender
    log4j.appender.FILE.maxBackupIndex=100
    ##log4j.appender.FILE=org.apache.log4j.DailyRollingFileAppender 
    log4j.appender.FILE.Append=true
    log4j.appender.FILE.File=c:/error1.log
    log4j.appender.FILE.Threshold=INFO
    log4j.appender.FILE.layout=org.apache.log4j.PatternLayout
    log4j.appender.FILE.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} [%5p] - %c -%F(%L) -%m%n
    log4j.appender.FILE.MaxFileSize=1MB

4、HibernateUtil.java （获取session工具类）

package cn.sz.utils;
    
    import org.hibernate.Session;
    import org.hibernate.SessionFactory;
    import org.hibernate.cfg.Configuration;
    
    public class HibernateUtil {
    	public static Session getSession() {
    		Session session = null;
    		// 创建一个读取主配置文件的对象
    		Configuration cfg = new Configuration();
    		// 读取主配置文件
    		// cfg.configure("hibernate.cfg.xml");如果读取的主配置文件时默认的名字则可以省略参数
    		cfg.configure();
    		// 创建SessionFactory
    		SessionFactory factory = cfg.buildSessionFactory();
    		// 打开session
    		// 我们在主配置中已经将session绑定到线程中，所以可以从线程中取出session
    		// 不从线程中取出session，则可以使用 factory.openSession(); 方式获得session
    		session = factory.getCurrentSession();
    		return session;
    
    	}
    
    }

5、订单实体类 Orders.java

package cn.sz.pojo;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.JoinColumn;
    import javax.persistence.ManyToOne;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "h_orders")
    public class Orders {
    	@Id
    	@GeneratedValue(strategy = GenerationType.IDENTITY)
    	private Integer ordersId;
    	private String ordersName;
    
    	// 一对多关系(用户和订单)
    	@ManyToOne(cascade = CascadeType.ALL)
    	@JoinColumn(name = "userId")
    	private User user;
    
    	public Integer getOrdersId() {
    		return ordersId;
    	}
    
    	public void setOrdersId(Integer ordersId) {
    		this.ordersId = ordersId;
    	}
    
    	public String getOrdersName() {
    		return ordersName;
    	}
    
    	public void setOrdersName(String ordersName) {
    		this.ordersName = ordersName;
    	}
    
    	public User getUser() {
    		return user;
    	}
    
    	public void setUser(User user) {
    		this.user = user;
    	}
    
    	@Override
    	public String toString() {
    		return "Orders [ordersId=" + ordersId + ", ordersName=" + ordersName + "]";
    	}
    
    }

6、用户实体类 User.java

package cn.sz.pojo;
    
    import java.util.Date;
    import java.util.Set;
    
    import javax.persistence.CascadeType;
    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.GenerationType;
    import javax.persistence.Id;
    import javax.persistence.OneToMany;
    import javax.persistence.Table;
    
    @Entity
    @Table(name = "h_user")
    public class User {
    	// 基于外键的方式时，使用的配置(一对一关系)
    
    	@Id
    	@GeneratedValue(strategy = GenerationType.IDENTITY)
    	private Integer userId;
    
    	private String userName;
    	private Date birthday;
    
    	// 一对多关系(用户和订单),添加cascade配置并不能实现一的一方维护关系
    	@OneToMany(targetEntity = Orders.class, mappedBy = "user", cascade = CascadeType.ALL)
    	private Set<Orders> orderss;
    
    	public User() {
    	}
    
    	public User(String userName, Date birthday) {
    		this.userName = userName;
    		this.birthday = birthday;
    	}
    
    	public Integer getUserId() {
    		return userId;
    	}
    
    	public void setUserId(Integer userId) {
    		this.userId = userId;
    	}
    
    	public String getUserName() {
    		return userName;
    	}
    
    	public void setUserName(String userName) {
    		this.userName = userName;
    	}
    
    	public Date getBirthday() {
    		return birthday;
    	}
    
    	public void setBirthday(Date birthday) {
    		this.birthday = birthday;
    	}
    
    	public Set<Orders> getOrderss() {
    		return orderss;
    	}
    
    	public void setOrderss(Set<Orders> orderss) {
    		this.orderss = orderss;
    	}
    
    	@Override
    	public String toString() {
    		return "User [userId=" + userId + ", userName=" + userName + ", birthday=" + birthday + "]";
    	}
    
    }

7、测试类

package cn.sz.test;
    
    import org.hibernate.Session;
    import org.junit.Test;
    
    import cn.sz.pojo.User;
    import cn.sz.utils.HibernateUtil;
    
    public class EhcacheTest {
    	@Test
    	public void test1() {
    		// 查询id为1的用户
    		Session session1 = HibernateUtil.getSession();
    		session1.beginTransaction();
    		User u1 = session1.get(User.class, 1);
    		System.out.println(u1);
    		session1.getTransaction().commit();
    		session1.close();
    
    		// 查询id为1的用户
    		Session session2 = HibernateUtil.getSession();
    		session2.beginTransaction();
    		User u2 = session2.get(User.class, 1);
    		System.out.println(u2);
    		session2.getTransaction().commit();
    		session2.close();
    	}
    }

测试结果：

![Center 3][]![Center 4][]

我们发现我们用session1查询id为1的用户信息，查询完成之后我们关闭session1，当我们使用session2 查询id为1 用户时，并没有向数据库发送查询语句，而是直接输出信息。

总结：当session1进行查询操作时，当开启了二级缓存时，首先到二级缓存中查找，如果没有找到，才会向数据库发送sql语句，将结果返回保存在二级缓存，放入一级缓存；当session2 再次进行相同的查询时，先从二级缓存找，此时能找到，所以就不会向数据库发送sql，而是直接 由二级缓存返回数据 。

**补充知识点：**

ehcache.xml文件配置详解：

name:缓存名称。  
maxElementsInMemory：缓存最大个数。  
eternal:对象是否永久有效，一但设置了，timeout将不起作用。  
timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。  
timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。  
overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。  
diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。  
maxElementsOnDisk：硬盘最大缓存个数。  
diskPersistent：是否缓存虚拟机重启期数据  
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。  
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。  
clearOnFlush：内存数量最大时是否清除。  
注： <diskStore path="d:/hibernateCache" /> 就是在缓存存储在 d盘下的hibernateCache目录。

缓存usage事务隔离机制：  
  
Usage提供缓存对象的事务隔离机制有如下几种：  
(NONE, READ\_ONLY, NONSTRICT\_READ\_WRITE, READ\_WRITE, TRANSACTIONAL)  
ehcache不支持transaction事务机制，但其他三种可以使用：  
read-only:：  
无需修改， 那么就可以对其进行只读 缓存，注意，在此策略下，如果直接修改数据库，即使能够看到前台显示效果，  
但是将对象修改至cache中会报error，cache不会发生作用。另：删除记录会报错，因为不能在read-only模式的对象从cache中删除。  
read-write:  
需要更新数据，那么使用读/写缓存 比较合适，前提：数据库不可以为serializable transaction isolation level（序列化事务隔离级别）  
nonstrice-read-write:  
只偶尔需要更新数据（也就是说，两个事务同时更新同一记录的情况很不常见），也不需要十分严格的事务隔离，那么比较适合使用非严格读/写缓存策略。

[Center]: /images/20220606/459df0257df24da788557ac9df708344.png
[Center 1]: /images/20220606/785d7924057e40d9ac8ee8aa9b49e18f.png
[Center 2]: /images/20220606/703e4503508546dbb8e5eb851a1958f2.png
[http_blog.csdn.net_benxiaohai888_article_details_78231911]: http://blog.csdn.net/benxiaohai888/article/details/78231911
[Center 3]: https://img-blog.csdn.net/20171025105729292?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQvYmVueGlhb2hhaTg4OA==/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center
[Center 4]: /images/20220606/f3b183b1c97642dca6da4d1b8c19d576.png