Hibernate(十二)Session缓存与二级缓存

最新推荐文章于 2021-10-22 09:54:39 发布
最新推荐文章于 2021-10-22 09:54:39 发布
阅读量1.5k 收藏 2
点赞数
分类专栏： web
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lindonglian/article/details/46991115
版权
一级缓存主要作用是管理对象。
应用程序级别的缓存（SessionFactory级别的缓存），也叫二级缓存，默认是不开启的。

不管是一级缓存还是二级缓存，都需要根据OID获取对象才有效。

package test.hibernate.hbmSecondCache;

import java.util.HashSet;
import java.util.Set;

public class Department {

	private Integer id;
	private String name;
	private Set<Employee> employees = new HashSet<Employee>();

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Set<Employee> getEmployees() {
		return employees;
	}

	public void setEmployees(Set<Employee> employees) {
		this.employees = employees;
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "[employee:id=" + id + ",name=" + name + "]";
	}

}



package test.hibernate.hbmSecondCache;

public class Employee {

	private Integer id;
	private String name;
	private Department department = new Department();

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public Department getDepartment() {
		return department;
	}

	public void setDepartment(Department department) {
		this.department = department;
	}

	@Override
	public String toString() {
		// TODO Auto-generated method stub
		return "[Employee:id=" + id + ",name=" + name + "]";
	}
}



<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="test.hibernate.hbmSecondCache">
	<class name="Department" table="department">
		<id name="id" type="integer" column="id">
			<generator class="native" />
		</id>
		<property name="name" />
		<set name="employees" inverse="false" cascade="save-update" lazy="extra">
			<key column="departmentId"></key>
			<one-to-many class="Employee" />
		</set>
	</class>
</hibernate-mapping>


<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
        "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
        "http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">

<hibernate-mapping package="test.hibernate.hbmSecondCache">

	<class name="Employee" table="employee">
		<!-- 指定当前类使用二级缓存 -->
		<!-- <cache usage="read-write" /> -->
		<id name="id" type="integer" column="id">
			<generator class="native" />
		</id>
		<property name="name" />
		<many-to-one name="department" class="Department" column="departmentId"></many-to-one>

	</class>
</hibernate-mapping>



<!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 name="foo">
		<!-- 配置数据库信息 -->
		<property name="dialect">org.hibernate.dialect.MySQLDialect</property>
		<property name="connection.driver_class">com.mysql.jdbc.Driver</property>
		<property name="connection.url">jdbc:mysql://localhost:3306/hibernate_2015</property>
		<!-- 可简写为<property name="connection.url">jdbc:mysql:///hibernate_2015</property> -->
		<property name="connection.username">root</property>
		<property name="connection.password">686175</property>
		<!-- 显示生成的sql语句，不写的话默认是false -->
		<property name="show_sql">true</property>
		<property name="hbm2ddl.auto">update</property>
		<!-- 设置事务隔离级别 -->
		<property name="connection.isolation">2</property>

		<!-- c3p0连接池 -->
		<!-- 使用c3p0连接池，配置连接池提供的供应商 -->
		<property name="connection.provider_class">org.hibernate.connection.C3P0ConnectionProvider</property>
		<!-- 在连接池中可用的数据库连接的最小数目 -->
		<property name="c3p0.min_size">5</property>
		<!-- 在连接池中可用的数据库连接的最大数目 -->
		<property name="c3p0.max_size">10</property>
		<!-- 设定数据库连接的过期时间，以秒为单位，如果连接池中的某个 数据库连接处于空闲状态的时间超过timeout时间，就会从连接池中清除 -->
		<property name="c3p0.timeout">100</property>
		<!-- 以秒为单位，每idle_test_period秒检查所有连接池中的空闲连接 -->
		<property name="c3p0.idle_test_period">2000</property>

		<!-- 指定缓存提供商 -->
		<!-- <property name="cache.provider_class"> org.hibernate.cache.HashtableCacheProvider 
			</property> -->
		<property name="cache.provider_class">org.hibernate.cache.EhCacheProvider</property>
		<!-- 指定开启查询缓存 -->
		<property name="cache.use_query_cache">true</property>
		<!-- 指定使用二级缓存的实体类 -->
		<class-cache usage="read-only"
			class="test.hibernate.hbmSecondCache.Employee" />
		<class-cache usage="read-write"
			class="test.hibernate.hbmSecondCache.Department" />
		<!-- 表示Department类里的集合要进行缓存 -->
		<collection-cache usage="read-write"
			collection="test.hibernate.hbmSecondCache.Department.employees" />
	</session-factory>
</hibernate-configuration>

懒加载的类(Department)中的集合(Employee)要进行懒加载也需要另外进行设置,同时Employee类也要打开。 
package test.hibernate.hbmSecondCache;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
import org.junit.Test;

public class App {

	private static SessionFactory sessionFactory = new Configuration()//
			.configure()//
			.addClass(Department.class)// 添加Hibernate实体类（加载对应的映射文件）
			.addClass(Employee.class)//
			.buildSessionFactory();

	// 获取到部门关联的员工
	@Test
	public void testSessionCache1() throws Exception {
		// ----------------测试第二个Session-------------------
		Session session1 = sessionFactory.openSession();
		session1.beginTransaction();

		Employee employee1 = (Employee) session1.get(Employee.class, 1);

		session1.getTransaction().commit();
		session1.close();
		// ----------------测试第二个Session-------------------
		Session session2 = sessionFactory.openSession();
		session2.beginTransaction();

		Employee employee2 = (Employee) session2.get(Employee.class, 1);
		// employee2.setName("力普");
		session2.getTransaction().commit();
		session2.close();
	}

	@Test
	public void testSessionCache2() throws Exception {
		// ----------------测试第二个Session-------------------
		Session session1 = sessionFactory.openSession();
		session1.beginTransaction();

		Department department1 = (Department) session1.get(Department.class, 1);
		System.out.println(department1.getEmployees());

		session1.getTransaction().commit();
		session1.close();
		// ----------------测试第二个Session-------------------
		Session session2 = sessionFactory.openSession();
		session2.beginTransaction();

		Department department2 = (Department) session2.get(Department.class, 1);
		// department2.setName("研发部");
		System.out.println(department2.getEmployees());

		session2.getTransaction().commit();
		session2.close();
	}

	// Query.list()默认不会使用二级缓存
	@Test
	public void testQueryCache() throws Exception {
		// -----------------------------------
		Session session1 = sessionFactory.openSession();
		session1.beginTransaction();

		List<Employee> list = session1.createQuery(
				"From Employee e WHERE e.id<5").list();
		System.out.println(list);

		session1.getTransaction().commit();
		session1.close();
		// ---------------------------------------------------
		Session session2 = sessionFactory.openSession();
		session2.beginTransaction();

		List<Employee> list2 = session2.createQuery(
				"From Employee e WHERE e.id<5").list();
		System.out.println(list2);

		session2.getTransaction().commit();
		session2.close();
	}

	/*
	 * 在使用HQL方式查询时，如果用iterator()方法，就会使用缓存。 这个方法先查询所有符合条件的id集合，再一个一个地按id查找数据。
	 * 但这个方法会有n+1次查询的问题，提高性能有限，不太常用。
	 */
	@Test
	public void testQueryCache2() throws Exception {
		// -----------------------------------
		Session session1 = sessionFactory.openSession();
		session1.beginTransaction();

		Iterator<Employee> iterator1 = session1.createQuery(
				"FROM Employee WHERE id <5").iterate();
		while (iterator1.hasNext()) {
			System.out.println(iterator1.next());
		}
		session1.getTransaction().commit();
		session1.close();
		// ---------------------------------------------------
		Session session2 = sessionFactory.openSession();
		session2.beginTransaction();

		Iterator<Employee> iterator2 = session2.createQuery(
				"FROM Employee WHERE id <5").iterate();
		while (iterator2.hasNext()) {
			System.out.println(iterator2.next());
		}

		session2.getTransaction().commit();
		session2.close();
	}

	// 使用二级缓存需在主配置文件开启查询缓存
	@Test
	public void testQueryCache3() throws Exception {
		// -----------------------------------
		Session session1 = sessionFactory.openSession();
		session1.beginTransaction();

		List<Employee> list = session1
				.createQuery("From Employee e WHERE e.id<5")//
				.setCacheable(true)//
				.list();
		System.out.println(list);

		session1.getTransaction().commit();
		session1.close();
		// ---------------------------------------------------
		Session session2 = sessionFactory.openSession();
		session2.beginTransaction();
		// 两次查询条件需相同二级缓存才有用
		List<Employee> list2 = session2.createQuery(//
				"From Employee e WHERE e.id<5")//
				.setCacheable(true)//
				.list();
		System.out.println(list2);

		session2.getTransaction().commit();
		session2.close();
	}

	@Test
	public void testUpdateTimeStampCache() throws Exception {
		// -----------------------------------
		Session session1 = sessionFactory.openSession();
		session1.beginTransaction();

		List<Employee> list = session1
				.createQuery("From Employee e WHERE e.id<2")//
				.setCacheable(true)//
				.list();

		session1.createQuery("UPDATE Employee SET name=? WHERE id=?")
				.setParameter(0, "漫画")//
				.setParameter(1, 3)//
				.executeUpdate();

		System.out.println(list);

		session1.getTransaction().commit();
		session1.close();
		// ---------------------------------------------
		System.out.println("=============================");

		Session session2 = sessionFactory.openSession();
		session2.beginTransaction();
		// 两次查询条件需相同二级缓存才有用
		List<Employee> list2 = session2.createQuery(//
				"From Employee e WHERE e.id<7")//
				.setCacheable(true)//
				.list();// 打断点->debug，可以看到E:/cache/下缓存生成的文件
		// 此时employees[3]已失效，会输出session1更新后的结果
		System.out.println(list2);

		session2.getTransaction().commit();
		session2.close();
	}
}
使用EnCache缓存需配置ehcache.xml。导入一些jar包：ehcache-1.5.0.jar、backport-util-concurrent.jar、commons-logging-1.0.4.jar 

<ehcache>

    <!--缓存文件存放的位置-->
    <diskStore path="E:/cache/"/>


    <!--Default Cache configuration. These will applied to caches programmatically created through
        the CacheManager.

        The following attributes are required for defaultCache:

        maxInMemory       - Sets the maximum number of objects that will be created in memory
        eternal           - Sets whether elements are eternal. If eternal,  timeouts are ignored and the element
                            is never expired.
        timeToIdleSeconds - Sets the time to idle for an element before it expires. Is only used
                            if the element is not eternal. Idle time is now - last accessed time
        timeToLiveSeconds - Sets the time to live for an element before it expires. Is only used
                            if the element is not eternal. TTL is now - creation time
        overflowToDisk    - Sets whether elements can overflow to disk when the in-memory cache
                            has reached the maxInMemory limit.

        -->
    <defaultCache
        maxElementsInMemory="1"
        eternal="false"
        timeToIdleSeconds="120"
        timeToLiveSeconds="120"
        overflowToDisk="true"
        />

</ehcache>

testSessionCache



testQueryCache2


testUpdateTimeStampCache


使用EhCache在D:/cache/生成的缓存文件



Linda L
关注
专栏目录
【Hibernate】二级缓存（Hibernate默认使用的二级缓存）
LFSenior
09-02 6656
一、Hibernate提供的缓存 有一级缓存、二级缓存。 目的是为了减少对数据库的访问次数，提升程序执行效率！   二、一级缓存 基于Session的缓存，缓存内容只在当前session有效，session关闭，缓存内容失效！ 特点： 作用范围较小！ 缓存的事件短。 缓存效果不明显。   三、二级缓存 Hibernate提供了基于应用程序级别的缓存， 可以跨多个session
Hibernate的一级缓存Session和二级缓存SessionFactory
qq_19925065的博客
09-19 1844
Hibernate的一级缓存是指Session，它是一块内存空间，用来存放相互管理的java对象，有了一级缓存，应用程序可以减少访问数据库的次数，提高了性能。在使用Hibernate查询对象的时候，首先会使用对象属性的OID值（对应表中的主键）在Hibernate的一级缓存进行查找，如果找到，则取出返回，不会再查询数据库，如果没有找到，再到数据库中进行查询操作。然后将查询结果存放到Session一级
Hibernate之二 一级缓存（session）、二级缓存（sessionFactory）
你今天的日积月累，早晚会成为别人的望尘莫及。
03-17 5089
一、操作Session缓存 （1）flush：Session 按照缓存中对象的属性变化来同步更新数据库 默认情况下 Session 在以下时间点刷新缓存： 显式调用 Session 的 flush() 方法 当应用程序调用 Transaction 的 commit（）方法的时, 该方法先 flush ，然后在向数据库提交事务 当应用程序执行一些查询
二级缓存
明天，我想带你去看海……
12-21 308
二级缓存也称进程级的缓存或SessionFactory级的缓存，二级缓存可以被所有的session共享二级缓存的生命周期和SessionFactory的生命周期一致，SessionFactory可以管理二级缓存   二级缓存的配置和使用：  * 将echcache.xml(在etc目录下有模板文件)文件拷贝到src下  * 开启二级缓存，修改hibernate.cfg.xml文件   &lt;p...
Hibernate之二级缓存
zxy15974062965的博客
10-22 741
（一）、缓存：缓存是什么，解决什么问题？ 位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为缓存Cache，缓存也被称为非关系型数据库。缓存目的：让数据更接近于应用程序，协调速度不匹配，使访问速度更快。 （二）、数据库类型：数据库分为两种类型，其中每一个类型都有一个典型的数据库 关系型数据库：数据与数据之间存在关系（联系）的数据库：sql、mysql、oracle 非关系型数据库：数据与数据之间是不存在关系的：...
hibernate之二级缓存
Zhangrunhong的博客
07-21 127
1. 为什么需要缓存 可以拉高程序的性能 2. 什么样的数据需要缓存 很少被修改或根本不改的数据 数据字典 业务场景比如：耗时较高的统计分析sql、电话账单查询sql等 3. ehcache是什么 Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大 注1：本章介绍的是2.X版本，3.x的版本和2.x的版本API差异比较大 4. ehcache的特点 4.1 够快 E...
Hibernate一级缓存和二级缓存详解
08-26
当应用程序调用Session的save()、update()、savaeOrUpdate()、get()或load()，以及调用查询接口的list()、iterate()或filter()方法时，如果在Session缓存中还不存在相应的对象，Hibernate就会把该对象加入到一级缓存...
hibernate一级缓存、二级缓存和查询缓存
04-22
**hibernate一级缓存、二级缓存和查询缓存** 在Java的持久化框架Hibernate中，缓存机制是提高应用程序性能的关键要素。缓存能够减少数据库的访问次数，提高数据读取速度，并且在一定程度上降低了系统的负载。本文将...
springboot+jpa(hibernate配置redis为二级缓存) springboot2.1.4
04-23
通常，一级缓存由Hibernate Session管理，而二级缓存则可以跨越多个Session进行共享。 在Spring Boot项目中配置Redis作为Hibernate的二级缓存，我们需要以下步骤： 1. **添加依赖**： 首先，在`pom.xml`文件中...
Hibernate一级缓存和二级缓存
03-19
标题“Hibernate一级缓存和二级缓存”指的是Hibernate框架中的两种缓存机制，它们是提高数据访问性能的关键要素。一级缓存是Session级别的，而二级缓存是SessionFactory级别的，两者在数据库操作中起到了重要的作用...
day37 05-HIbernate二级缓存：一级缓存更新同步到二级缓存及二级缓存配置文件
04-26
本篇文章将深入探讨Hibernate的二级缓存机制，以及如何进行一级缓存与二级缓存的同步，同时还会介绍二级缓存的配置文件设置。 一级缓存是Hibernate默认提供的缓存，每个SessionFactory实例都有一个一级缓存。当对象...
Hibernate中Session的get方法使用二级缓存问题
孙宁振的专栏
12-27 279
网上很多言论都说load会使用二级缓存而get不会，包括一些hibernate的教材上也这么写的，但是以前在测试中发现，其实get也会使用二级缓存。 很久以前就发现了这个问题，一直没腾出时间研究，今天特意看了下源码（3.2.6.ga），确实如此 先看一下Session的默认实现SessionImpl get方法会转到fireLoad，loadType的值是LoadEventListener.GE...
20. 二级缓存(SessionFactory级缓存)
八荒六合唯我独尊
03-05 1051
hibernate二级缓存的重要知识点 二级缓存也称进程级的缓存或SessionFactory级的缓存，二级缓存可以被所有的session共享二级缓存的生命周期和SessionFactory的生命周期一致，SessionFactory可以管理二级缓存 hibernate提供了基于Hashtable的二级缓存实现，但建议只用于开发阶段，生产环境中应使用第三方提供的缓存产品
Hibernate一级缓存(session)与二级缓存(sessionFactory)的知识点。
qq_42401622的博客
07-17 252
        一级缓存：session级别的缓存，当我们用session调用  get() / load() / find() / Query()等查询出来的数据，默认在session中就会有一份缓存数据，缓存数据就是从数据库中将一些数据拷贝一份放到对应的地方。每次获取数据时候，会先从缓存中查找，如果没有再去数据库查询。提高了查询效率，减少了对数据库的直接操作。若不想使用一级缓存，则需要手动封装...
Hibernate Session level Cache (一级缓存)
敏于行
12-05 964
当调用session.save,update,saveOrUpdate 保存对象或者调用get,load,list,iterate,scroll获取对象时，Hibernate会自动将查询到的数据放到内部的缓存中，也就是Session中，调用以上方法在查询时，Hibernate的查询顺序依次是Session级的缓存、SessionFactory二级缓存，若以上缓存中都没有相应的对象查询到，则将从数据
【JPA】使用hibernate的jpa的二级缓存配置
zwan0518的专栏
03-14 3847
首先是配置文件中配置正确，META-INF中加上二级缓存的配置： 注意如果你的项目开始的时候可能没使用二级缓存，那个时候可能会有一行配置文件： 千万要注意看是否有这行文件，否则的话就会一直报错 Caused by: org.hibernate.cache.NoCachingEnabledException: Second-level cache is not ena
用jsp写注册页面
热门推荐
独立开发者 | 跨境电商
10-18 1万+
包括单选框、多选框、session的应用，页面自动跳转，中文乱码的处理，入门级
Hibernate二级缓存机制与配置解析
"这篇文档详细解释了Hibernate框架中的二级缓存机制，并提到了不同类型的缓存提供商，包括HashtableCache、EhCache、OSCache、SwarmCache和TreeCache。" 在Java开发中，Hibernate是一个非常流行的对象关系映射（ORM...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值