hibernate的缓存级别
首先，我们都知道，在使用hibernate的时候，数据都是将书卷转化为二进制流放在缓存中，然后再将缓存中的数据放入数据库的，这样一方面减少了数据库的压力，另一方面也提高了应用的效率。
首先提出问题：
缓存
1、缓存的生命周期
2、数据库的数据是怎么样放入到缓存中的
3、缓存中的数据是怎么样放入到数据库中的
4、客户端怎么样从缓存中把数据取出来
5、客户端怎么样把一个数据放入到缓存中
6、怎么样把一个对象从缓存中取出
7、把缓存中所有的数据清空
页面缓存：这个是一个题外话？也是遇到的问题？加入有一天客户端浏览网站，连续不断的在该网站上进行长达一段时间的数据交互，这个时候你就会发现网站就会变得非常非常的卡？只有关掉浏览器重来，或者刷新网页才可以继续使用。那原因在哪里呢？因为那些数据缓存都在内存上的，之所以卡，是因为缓存没清理，所以这个时候就提出了页面缓存，至于怎么用，请查阅资料。
案例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">package cn.itcast.hibernate.test;
import java.util.Set;
import org.hibernate.Session;
import org.hibernate.Transaction;
import org.junit.Test;
import cn.itcast.hibernate.domain.Classes;
import cn.itcast.hibernate.domain.Student;
import cn.itcast.hibernate.util.HibernateUtil;
public class FirstCache extends HibernateUtil {
static{
url="hibernate.cfg.xml";
}
/**
* session.get方法把数据存放在一级缓存中了
*/
@Test
public void sessionfac_crate(){
Session session=sessionfactory.getCurrentSession();
Transaction transaction=session.beginTransaction();
session.get(Classes.class, 1L);
transaction.commit();
}
/**
* session.load方法把数据存放在一级缓存中
*/
@Test
public void testLoad(){
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
Classes classes = (Classes)session.load(Classes.class, 1L);
classes.getCname();
classes = (Classes)session.load(Classes.class,1L);
classes.getCname();
transaction.commit();
}
/**
* session.save方法把数据保存在一级缓存中
*/
@Test
public void testSave(){
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
Classes classes = new Classes();
classes.setCname("aaa");
classes.setDescription("asfd");
session.save(classes);
classes = (Classes)session.get(Classes.class, classes.getCid());
transaction.commit();
}
/**
* session.update讲述放入缓存中
*/
@Test
public void testUpdate(){
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
Classes classes = (Classes)session.get(Classes.class, 1L);
session.evict(classes);//classes对象从session中清空了
session.update(classes);//把classes对象放入到了session缓存中
classes = (Classes)session.get(Classes.class, 1L);
transaction.commit();
}
/**
* session.clear classes对象从session中清空了
*/
@Test
public void testClear(){
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
Classes classes = (Classes)session.get(Classes.class, 1L);
session.clear();//classes对象从session中清空了
classes = (Classes)session.get(Classes.class, 1L);
transaction.commit();
}
@Test
public void testClearTest(){
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
Classes classes = (Classes)session.get(Classes.class, 1L);
session.clear();//如果不加这句话，两个不同的对象，相同的ID值，所以得把其中的一个清空
Classes classes2 = new Classes();
classes2.setCid(1L);
classes2.setCname("asfd");
session.update(classes2);
transaction.commit();
}
/**
* 把数据库中的数据刷新到缓存中
*/
@Test
public void testRefresh(){
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
Classes classes = (Classes)session.get(Classes.class, 1L);
classes.setCname("66");
session.refresh(classes);//把cid为1的值从数据库刷到了缓存中（DB同步到缓存）
System.out.println(classes.getCname());
transaction.commit();
}
/**
* session.flush//将缓存中的数据刷到数据库了。(缓存同步到DB)
*/
@Test
public void testFlush(){
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
Classes classes =(Classes)session.get(Classes.class, 1L);
classes.setCname("afdsasdf");
Set<Student> students = classes.getStudent();
for(Student student:students){
student.setDescription("asdf");
}
session.flush();
transaction.commit();
}
@Test
public void testSaveBatch(){//这个例子是假设向数据库插入100万条数据，当然不能全部放在缓存中了，下面提出了解决办法
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
for(int i=6;i<1000000;i++){
Classes classes = new Classes();
classes.setCname("aaa");
classes.setDescription("afds");
session.save(classes);
if(i%50==0){
session.flush();
session.clear();
}
}
transaction.commit();
}
/**
* session.flush只是发出SQL语句了，并没有清空session缓存
*/
@Test
public void testFlush2(){
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
Classes classes = (Classes)session.get(Classes.class, 1L);
session.flush();
classes = (Classes)session.get(Classes.class, 1L);
transaction.commit();
}
}
</span></span>session缓存：
1、生命周期就是session的生命周期
2、一级缓存存放的数据都是私有数据
把session存放在threadlocal中，不同的线程是不能访问的，所以保证了数据的安全性
3、怎么样把数据存放到一级缓存中
利用session.save/update/load/get方法都可以存放在一级缓存中
4、利用session.get/load方法可以把数据从一级缓存中取出
5、session.evict方法可以把一个对象从一级缓存中清空
6、利用session.clear方法可以把session中的所有的数据清空
7、利用session.Refresh方法把数据库中的数据同步到缓存中
8、session.flus:只是发出SQL语句了，并没有清空session缓存
在session的缓存内部，会去检查所有的持久化对象
1、如果一个持久化对象没有ID值，则会发出insert语句
2、如果一个持久化对象有ID值，则会去检查快照进行对比，如果一样，则什么都不做，如果不一样，则发出update语句
3、检查所有的持久化对象是否有关联对象
检查关联对象的级联操作
检查关联对象的关系操作
9、批量操作：大家想想批量操作，上面案例也写过。当缓存中的数据大到一定时候就会内存溢出，我们又改怎么解决呢？
@Test
public void testSaveBatch(){
Session session = sessionfactory.getCurrentSession();
Transaction transaction = session.beginTransaction();
for(int i=6;i<1000000;i++){
Classes classes = new Classes();
classes.setCname("aaa");
classes.setDescription("afds");
session.save(classes);
if(i%50==0){
session.flush();
session.clear();
}
}
transaction.commit();
}
缓存到数据库了，就不会发生溢出了。MySql数据库一百万条数据还行，单上千万就不行了。上亿就瘫痪了
内除溢出的状况：
所以解决办法有，就是在跟数据库提交数据库的时候，对内存的数据进行清除。
二、二级缓存和查询缓存
二级缓存：存放公有数据
1、适用场合：
1、数据不能频繁更新（电脑已启动，数据就加载到缓存中了，所以相对一级缓存来说，查询和提取数据就快多了）
2、数据能公开，私密性不是很强，不想一级缓存那样，每一个session对象都在ThreadLocal线程上的，各自独立，线程就是 安全的。
2、hibernate本身并没有提供二级缓存的解决方案
3、二级缓存的实现是依赖于第三方供应商完成的
ehcache
oscache
jbosscache
swamchache
4、二级缓存的操作
1、二级缓存存在sessionFactory中
2、生命周期：与sessionFactory保持一致
3、使用二级缓存的步骤(添加配置代码)
1、在hibernate.cfg.xml(这个是开启二级缓存)
<propertyname="cache.use_second_level_cache">true</property>
<propertyname="cache.provider_class">
org.hibernate.cache.EhCacheProvider
</property>
2、让某一个对象进入到二级缓存中
* 在配置文件中(第一种方式，在配置文件中修改，不建议使用这种。)
<class-cacheusage="read-write"class="cn.itcast.hiberate.sh.domain.Classes"/>
* 在映射文件中(第二种方式，建议使用这种，分得清楚，在哪个映射文件中，使用的就是哪个对象)
<cacheusage="read-write"/>
3、使用
session.get/session.load
案例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">package cn.itcast.hibernate.test;
import java.util.List;
import org.hibernate.Query;
import org.hibernate.Session;
import org.junit.Test;
import cn.itcast.hibernate.domain.Classes;
import cn.itcast.hibernate.util.HibernateUtil;
public class SecondLevalCache extends HibernateUtil {
static{
url="hibernate.cfg.xml";
}
/**
* session.get
* 把数据存在一级缓存和二级缓存(当然前提是这个持久化类是开启二级缓存的，不然就是在一级缓存)
*/
@Test
public void testGet(){
Session session = sessionfactory.openSession();
Classes classes = (Classes)session.get(Classes.class, 1L);
session.close();//一级缓存就没了
session = sessionfactory.openSession();
classes = (Classes)session.get(Classes.class, 1L);
session.close();
//找数据--找一级缓存---找二级缓存---找数据库----最后才报错
}
/**
* session.load
* 同上
*/
@Test
public void testLoad(){
Session session = sessionfactory.openSession();
Classes classes = (Classes)session.load(Classes.class, 1L);
classes.getCname();
session.close();
session = sessionfactory.openSession();
classes = (Classes)session.load(Classes.class, 1L);
classes.getCname();
session.close();
}
/**
* session.update
*/
@Test
public void testUpdate(){
Session session = sessionfactory.openSession();
//session.beginTransaction();
Classes classes = new Classes();
classes.setCid(1L);
classes.setCname("aaa");
session.update(classes);
session.close();
session = sessionfactory.openSession();
classes = (Classes)session.get(Classes.class, 1L);//如果有sql语句说明就加载到一级缓存中了
session.close();
}
}
</span></span>5、查询缓存：提出这个缓存的原因是：如果遇到查询大量的数据（如几百万条数据）放在内存中肯定不行，因为查询出来的数据都得先放在内存中，然后才开始进行取出，但是全部放在里面就会出现溢出错误！这是一个大错误。这个时候我们又该咋做？
第一种方式：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;">/**
* 查询缓存:必须建立在二级缓存之上,当查询数据大的时候就需要查询缓存来优化了
* 首先在配置文件中配置：<!-- cache.use_query_cache:查询缓存的设置 -->
* <property name="cache.use_query_cache">true</property>
*/
@Test
public void testQuery(){
Session session = sessionfactory.openSession();
Query query = session.createQuery("from Classes");
query.setCacheable(true);//classes里的所有的数据要往查询缓存中存放了
List<Classes> classesList = query.list();
query = session.createQuery("from Classes");
query.setCacheable(true);
classesList = query.list();
session.close();
}</span></span>
这种方式，保证查询条件都相同
等二种方法：利用ehcache.xml文件在磁盘存储缓存，文件配置指：用来指定缓存在磁盘上的存储位置。
ehcache.xml内容
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;"><ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">
<diskStore path="C:\\TEMP1"/>
<defaultCache
maxElementsInMemory="5"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="false"
maxElementsOnDisk="10000000"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU"
/>
<Cache
name="cn.itcast.hibernate.domain.Classes"
maxElementsInMemory="3"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
maxElementsOnDisk="10000000"
diskPersistent="false"
diskExpiryThreadIntervalSeconds="120"
memoryStoreEvictionPolicy="LRU"
/>
</ehcache>
</span></span>文件解析：
name:缓存名称。
maxElementsInMemory：缓存最大个数。
eternal:对象是否永久有效，一但设置了，timeout将不起作用。
timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属 性，默认值是0，也就是可闲置时间无穷大。
timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当 eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一 个缓冲区。
maxElementsOnDisk：硬盘最大缓存个数。
diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略 是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
clearOnFlush：内存数量最大时是否清除。
更加详细的解析:点击打开链接
案例：
<span style="font-family:Microsoft YaHei;font-size:14px;"><span style="font-family:Microsoft YaHei;font-size:14px;"> /**
* 查询缓存利用ehcache.xml文件来在当地磁盘上写缓存。
*/
@Test
public void testAllClasses(){
Session session = sessionfactory.openSession();
List<Classes> classesList = session.createQuery("from Classes").list();
session.close();
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}</span></span>
2132
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
