Hibernate一级缓存：
(1) 一级缓存很短和session的生命周期一致，一级缓存又叫session级缓存或者
事务级缓存
(2) 支持一级缓存的方法：
get();
load();
iterator();只缓存实体对象
(3) 如何管理一级缓存
session.clear() session.evict(); session.flush();
(4) 如何避免大量数据入库导致内存溢出
先sessionflush()
在clear（）
(5) 如果数据量特别大可以 可以考虑JDBC实现 如果Jdbc也不能满足要求可以考虑 采用数据库提供 的特定数据导入工具
下面的实例中我们会一一验证以上的各条：
有这样的2个类
public class Clazz {
private Integer id;
private String name;
private Set<Student> students=new HashSet<Student>();
}
public class Student {
private Integer id;
private String name;
private Clazz clazz;
}
他们的映射文件分别是：
<class name="com.june.hibernate.Student" table="t_student">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name"></property>
<many-to-one name="clazz" cascade="save-update"></many-to-one>
</class>
<class name="com.june.hibernate.Clazz" table="t_clazz">
<id name="id">
<generator class="native"></generator>
</id>
<property name="name"></property>
<set name="students" inverse="true">
<key column="clazz"/>
<one-to-many class="com.june.hibernate.Student"/>
</set>
</class>
请运行以下的所有的测试方法：
package com.june.hibernate;
import java.io.Serializable;
import junit.framework.TestCase;
import org.hibernate.Session;
import org.hibernate.Transaction;
public class CacheLevel1Test extends TestCase{
/**
* 在同一个session中2次执行load()查询
*/
public void testLoad(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Student student1=(Student)session.load(Student.class,1);
System.out.println("student1.name="+student1.getName());
System.out.println("stuent1.clazz.name"+student1.getClazz().getName());
//不会发出sql语句，因为load使用缓存
Student student2=(Student)session.load(Student.class,1);
System.out.println("student1.name="+student1.getName());
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
/**
* 在同一个session中2次执行get()查询
*/
public void testGet(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Student student1=(Student)session.get(Student.class,1);
System.out.println("student1.name="+student1.getName());
System.out.println("stuent1.clazz.name"+student1.getClazz().getName());
//不会发出sql语句，因为get使用缓存
Student student2=(Student)session.get(Student.class,1);
System.out.println("student1.name="+student1.getName());
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
/**
* 查询实体
*/
public void testIteratorEntity(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Student student1=(Student)session.createQuery("from Student s where s.clazz.id=1").iterate().next();
System.out.println("student1.name="+student1.getName());
/** Hibernate: select student0_.id as col_0_0_ from t_student student0_ where student0_.clazz=1
Hibernate: select student0_.id as id1_0_, student0_.name as name1_0_, student0_.clazz as clazz1_0_ from t_student student0_ where student0_.id=?
student1.name=Student_**0Of_Clazz000
Hibernate: select student0_.id as col_0_0_ from t_student student0_ where student0_.clazz=1
student2.name=Student_**0Of_Clazz000
*/
//缓存中已经存在id=1的student 所以第二次查询 只是发出查询id 的sql 不会发出查询实体的sql
//因为Iterator使用缓存
Student student2=(Student)session.createQuery("from Student s where s.clazz.id=1").iterate().next();
System.out.println("student2.name="+student2.getName());
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
/**
* 查询普通属性
*/
public void testIteratorProperty(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
String sname=(String)session.createQuery("select s.name from Student s where s.clazz.id=1").iterate().next();
System.out.println("student1.name="+sname);
//iterator查询普通属性，一级缓存不会缓存，所以不会发出sql语句
String sname2=(String)session.createQuery("select s.name from Student s where s.clazz.id=1").iterate().next();
System.out.println("student1.name="+sname2);
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
/**
* 在2个session中使用load
*/
public void testTwoSessionLoad(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Student student1=(Student)session.load(Student.class,1);
System.out.println("student1.name="+student1.getName());
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
//会发出sql语句 session间不会共享一级缓存
//他会伴随这session生命周期的存在和消亡
Student student1=(Student)session.load(Student.class,1);
System.out.println("student1.name="+student1.getName());
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
/**
* 在同一个session中load()查询save()过的数据
*/
public void testLoadSaved(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Student student=new Student();
student.setName("mary");
Serializable id=session.save(student);
//不会发出sql,因为save使用缓存
Student student1=(Student)session.load(Student.class,id);
System.out.println(student1.getName());
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
/**
* 在同一个session 先调用load查询 然后执行session.clear()或执行session.evict();
* 在调用load查询
* clear()清理缓存,驱除全部
* evict(Object object)从缓存中驱逐指定的对象
*/
public void testLoadEvictLoad(){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
Student student1=(Student)session.load(Student.class,1);
//发出sql语句
System.out.println("student1.name="+student1.getName());
//一级缓存无法取消但是可以管理，如session.clear() session.evict()
//清理缓存
session.clear();
//session.evict(student1); //从缓存中逐出id=1的student
Student student2=(Student)session.load(Student.class,1);
//会发出sql语句
System.out.println("student1.name="+student1.getName());
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
/**
* 向数据库中添加10000条数据
*/
public void testCache7(){
Session session=null;
Transaction tx=null;
long beginTime=System.currentTimeMillis();
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
for(int i=0;i<1000;i++){
Student student=new Student();
student.setName("student_"+i);
session.save(student);
//每插入20条数据 就强制数据持久化
//同时清楚缓存，避免大量数据造成内存溢出
if(i % 20==0){
session.flush();
session.clear();
}
}
System.out.println();
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
long endTime=System.currentTimeMillis();
System.out.println(endTime-beginTime);
}
}
下面这是初始化数据类：
在运行单元测试之前先要建立数据库 并且运行下面这个类
初始化数据
ublic class InitialData {
public static void main(String args[]){
Session session=null;
Transaction tx=null;
try{
session=HibernateUtil.getSession();
tx=session.beginTransaction();
for(int j=0;j<6;j++){
Clazz clazz=new Clazz();
clazz.setName("Clazz00"+j);
session.save(clazz);
for(int i=0;i<10;i++){
Student student=new Student();
student.setName("Student_**"+i+"Of_Clazz00"+j);
student.setClazz(clazz);
session.save(student);
}
}
for(int k=0;k<5;k++){
Clazz clazz=new Clazz();
clazz.setName("Empty_Clazz00"+k);
session.save(clazz);
}
for(int m=0;m<5;m++){
Student student=new Student();
student.setName("no_class_student00"+m);
session.save(student);
}
tx.commit();
}catch(Exception e){
e.printStackTrace();
tx.rollback();
}finally{
HibernateUtil.colseSession(session);
}
}
}
----------------------------------------------------------------------
通过以上的测试我们可以对Hibernate的一级缓存有个基本的认识
分享到：
相关推荐
**hibernate一级缓存详解** 在Java的持久化框架Hibernate中，一级缓存是其核心特性之一，它为提高数据库操作效率、减少对数据库的访问提供了重要支持。一级缓存，也称为session缓存，是每个Hibernate Session内部...
**hibernate一级缓存、二级缓存和查询缓存** 在Java的持久化框架Hibernate中，缓存机制是提高应用程序性能的关键要素。缓存能够减少数据库的访问次数，提高数据读取速度，并且在一定程度上降低了系统的负载。本文将...
标题“Hibernate一级缓存和二级缓存”指的是Hibernate框架中的两种缓存机制，它们是提高数据访问性能的关键要素。一级缓存是Session级别的，而二级缓存是SessionFactory级别的，两者在数据库操作中起到了重要的作用...
它是一个事务范围的缓存，也就是说，每个 Hibernate Session 对应一个一级缓存，仅在当前事务中有效。一级缓存主要存储了 Session 在当前事务中加载和修改的对象实例。当 Session 执行 CRUD 操作时，对象会自动放入...
本文将深入探讨Hibernate的一级缓存、二级缓存以及查询缓存，通过具体的实例来阐述它们的工作原理和使用方法。 首先，我们从一级缓存开始。一级缓存是Hibernate默认提供的缓存，它是每个Session级别的，也被称为...
Hibernate 一级缓存和二级缓存的区别
在 Hibernate 中，一级缓存是默认开启的一种缓存机制，对于提高应用程序性能有着重要作用。一级缓存位于 Session 对象中，是每个 Session 的私有缓存，它存储了从数据库中读取的对象实例。 一级缓存的工作原理： 1....
这显示了Hibernate一级缓存如何提高性能，避免重复的数据库访问。 总结起来，Hibernate的一级缓存是一个关键特性，它提高了数据访问的效率并降低了数据库的负载。正确理解和使用一级缓存，以及学会管理缓存，是优化...
《深入理解Hibernate的一级缓存与二级缓存》 Hibernate作为一款强大的ORM框架，其缓存机制是优化数据库操作性能的关键之一。缓存主要分为一级缓存和二级缓存，它们各自承担着不同的职责，共同提升了数据访问的效率...
一级缓存是Hibernate默认提供的缓存，每个SessionFactory实例都有一个一级缓存。当对象被加载到内存中时，它们会被存储在一级缓存中。一级缓存是事务级的，意味着它只存在于当前事务内，一旦事务提交或回滚，一级...
用以介绍hibernate 框架的缓存机制
其中，一级缓存是Hibernate的核心特性之一，它是一个session级别的缓存，用于存储当前Session中的持久化对象。在这个示例中，我们将通过纯Java代码来模拟Hibernate的一级缓存机制。 首先，我们来看一下一级缓存的...
hibernate 一级缓存、 持久化对象状态和转换、 多表映射操作
首先，一级缓存是Hibernate默认提供的缓存，每个Session都有一个独立的一级缓存。当我们在操作数据库时，例如查询或更新记录，这些操作实际上是在与一级缓存交互。一级缓存的作用在于减少对数据库的直接访问，提高...
Hibernate一级缓存是指Session级别的缓存，它是默认开启的，每个Session都会维护一个对象缓存，用来存放该Session加载的实体对象。一级缓存的生命周期与Session相同，当Session关闭时，一级缓存中的数据也会被清除。...
一级缓存是Session级别的，每个Session都有自己的一级缓存，用于存储当前Session操作的对象。而二级缓存则是SessionFactory级别的，它跨越了多个Session，是全局共享的，可以被多个并发的Session共同使用。 二级...
一级缓存是Hibernate默认提供的缓存，它是Session级别的，每个Hibernate Session都有一个私有的、本地的一级缓存。当我们在Session中对对象进行 CRUD（创建、读取、更新、删除）操作时，这些对象会被自动放入一级...
本文将深入探讨Hibernate性能优化中的一个重要概念——一级缓存，并结合给出的压缩包文件“hibernate_cache_level1”，来详细解析一级缓存的工作原理及其优化策略。 一级缓存是Hibernate内置的一种缓存机制，它存在...
Hibernate一级缓存和二级缓存详解 Hibernate是一种流行的基于Java的持久化框架，它提供了两种缓存机制：一级缓存和二级缓存。了解这两种缓存机制是非常重要的，因为它们可以极大地提高应用程序的性能。 一级缓存 ...
这与一级缓存（Session级别）不同，一级缓存仅存在于单个Session生命周期内，当Session关闭时，一级缓存中的数据会丢失。二级缓存的存在减少了对数据库的直接访问，从而提高了数据读取速度。 为了启用Hibernate的二...