hibernate二级缓存的配置

最新推荐文章于 2023-08-10 09:00:47 发布
最新推荐文章于 2023-08-10 09:00:47 发布
阅读量101 收藏
点赞数
分类专栏： java技术 文章标签： Hibernate Cache XML SQL F#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chuan315/article/details/83282081
版权
[size=medium]Hibernate的二级缓存
hibernate.cfg.xml（src目录下）
(即可以配置到hibernate.cfg.xml也可以配置到hibernate.properties)
## enable the query cache

hibernate.cache.use_query_cache true


## choose a cache implementation

hibernate.cache.provider_class org.hibernate.cache.EhCacheProvider

ehcache.xml（src目录下） 
<?xml version="1.0" ?>
<!--cache name="org.itfuture.www.po.DeptPo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" /-->
<ehcache>
  <diskStore path="java.io.tmpdir" />
  <defaultCache name="org.hibernate.cache.StandardQueryCache" maxElementsInMemory="10000"  eternal="false" overflowToDisk="true" timeToIdleSeconds="300" timeToLiveSeconds="180" diskPersistent="false" diskExpiryThreadIntervalSeconds="120" />
  <cache name="org.hibernate.cache.StandardQueryCache" maxElementsInMemory="50" eternal="false" timeToIdleSeconds="3600" timeToLiveSeconds="7200" overflowToDisk="true"/>
  <cache name="org.hibernate.cache.UpdateTimestampsCache" maxElementsInMemory="5000" eternal="true" overflowToDisk="true"/>
  <cache name="org.itfuture.www.po.DeptPo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" />
  <cache name="org.itfuture.www.po.EmpPo" maxElementsInMemory="500" eternal="false" timeToLiveSeconds="7200" timeToIdleSeconds="3600" overflowToDisk="true" />
</ehcache>


Dept.hbm.xml 
<?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="org.itfuture.www.po">
   <class name="DeptPo" table="dept">
<!--cache usage="read-write"/-->
<!--cache usage="read-only"/-->

     <id name="deptid" column="deptid" type="java.lang.Integer">
       <generator class="assigned"></generator>
     </id>
     <property name="deptname" type="java.lang.String" column="deptname"></property>
     <property name="deptnum" type="java.lang.Integer" column="deptnum"></property>
     <property name="deptdesc" type="java.lang.String" column="deptdesc"></property>
     <set name="emps" cascade="all-delete-orphan" lazy="true" inverse="true">
       <key column="deptid"></key>
       <one-to-many class="EmpPo"/>
     </set>
   </class>
</hibernate-mapping>


运用二级缓存
//二级缓存的具体应用 
 public static void querycache()
    {
          //加载配置文件(hibernate.propertis,hibernate.cfg.xml)
          Configuration conf=new Configuration();  
            conf.configure();
          SessionFactory f=conf.buildSessionFactory();
          Session session =f.openSession();
          //Query q=session.createQuery("from java.lang.Object");
          Query q=session.createQuery("select A from DeptPo A where A.deptid<20");
          q.setCacheable(true);
          List list=q.list();
          for(Iterator iter=list.iterator();iter.hasNext();)
          {
           Object obj=iter.next();
           System.out.println(obj);
           //DeptPo po=(DeptPo)iter.next();
           //System.out.println(po.getDeptid()+"---"+po.getDeptname()+"---"+po.getDeptnum()+"---"+po.getDeptdesc());
          }
          session.close();
          System.out.println("*****************************************************");
          session =f.openSession();
          q=session.createQuery("select A from DeptPo A where A.deptid<20");
          q.setCacheable(true);
          list=q.list();
          for(Iterator iter=list.iterator();iter.hasNext();)
          {
           Object obj=iter.next();
           System.out.println(obj);
           //DeptPo po=(DeptPo)iter.next();
           //System.out.println(po.getDeptid()+"---"+po.getDeptname()+"---"+po.getDeptnum()+"---"+po.getDeptdesc());
          }

          f.close();
          //java.sql.Connection conn=session.connection();
    }
    public static void Criteriacache()
    {
          //加载配置文件(hibernate.propertis,hibernate.cfg.xml)
          Configuration conf=new Configuration();  
            conf.configure();
          SessionFactory f=conf.buildSessionFactory();
          Session session =f.openSession();
          //Query q=session.createQuery("from java.lang.Object");
          Criteria c=session.createCriteria(DeptPo.class).add(Expression.lt("deptid",20));
          c.setCacheable(true);
          List list=c.list();
          for(Iterator iter=list.iterator();iter.hasNext();)
          {
           Object obj=iter.next();
           System.out.println(obj);
           //DeptPo po=(DeptPo)iter.next();
           //System.out.println(po.getDeptid()+"---"+po.getDeptname()+"---"+po.getDeptnum()+"---"+po.getDeptdesc());
          }
          session.close();
          System.out.println("*****************************************************");
          session =f.openSession();
          c=session.createCriteria(DeptPo.class).add(Expression.lt("deptid",20));
          c.setCacheable(true);
          list=c.list();
          for(Iterator iter=list.iterator();iter.hasNext();)
          {
           Object obj=iter.next();
           System.out.println(obj);
           //DeptPo po=(DeptPo)iter.next();
           //System.out.println(po.getDeptid()+"---"+po.getDeptname()+"---"+po.getDeptnum()+"---"+po.getDeptdesc());
          }

          f.close();
          //java.sql.Connection conn=session.connection();
    }
    public static void loadcache()
    {
          //加载配置文件(hibernate.propertis,hibernate.cfg.xml)
          Configuration conf=new Configuration();  
            conf.configure();
          SessionFactory f=conf.buildSessionFactory();
          Session session =f.openSession();
          //Query q=session.createQuery("from java.lang.Object");
          Object obj=session.load(DeptPo.class,1);

          System.out.println(obj);
          session.close();

          System.out.println("*****************************************************");

          session =f.openSession();
          obj=session.load(DeptPo.class,1);
          System.out.println(obj);
          session.close();

          f.close();
          //java.sql.Connection conn=session.connection();
    }
    public static void writecache()
    {
          //加载配置文件(hibernate.propertis,hibernate.cfg.xml)
          Configuration conf=new Configuration();  
            conf.configure();
          SessionFactory f=conf.buildSessionFactory();
          Session session =f.openSession();
          DeptPo po=new DeptPo(800,"aaac",20,"asdfasd");
          Transaction tran=session.beginTransaction();
          session.save(po);
          tran.commit();
          session.close();

          System.out.println("*****************************************************");

          session =f.openSession();
          Object obj=session.load(DeptPo.class,800);
          System.out.println(obj);
          session.close();

          f.close();
          //java.sql.Connection conn=session.connection();
    }
    //缓存更新
    public static void updatecache()
    {
          //加载配置文件(hibernate.propertis,hibernate.cfg.xml)
          Configuration conf=new Configuration();  
            conf.configure();
          SessionFactory f=conf.buildSessionFactory();
          Session session =f.openSession();
          DeptPo po=(DeptPo)session.load(DeptPo.class,800);//放到二级缓存中
          po.setDeptname("策划部2");

          Transaction tran=session.beginTransaction();
          session.update(po);
          tran.commit();
          session.close();

          System.out.println("*****************************************************");

          session =f.openSession();
          po=(DeptPo)session.load(DeptPo.class,800);
          System.out.println(po.getDeptname());
          session.close();
          f.close();
          //java.sql.Connection conn=session.connection();
    }







配置解释
＜!-- 设置Hibernate的缓存接口类，这个类在Hibernate包中 --＞＜property name="cache.provider_class"＞org.hibernate.cache.EhCacheProvider＜/property＞　＜!-- 是否使用查询缓存 --＞　＜property name="hibernate.cache.use_query_cache"＞true＜/property＞


＜defaultCache
maxElementsInMemory="10000" ＜!-- 缓存最大元素数目 --＞
eternal="false" ＜!-- 缓存是否持久保存 --＞
overflowToDisk="true" ＜!-- 是否保存到磁盘 -＞
timeToIdleSeconds="3600" ＜!-- 当缓存闲置n秒后销毁 --＞
timeToLiveSeconds="7200" ＜!-- 当缓存存活n秒后销毁--＞
diskPersistent="false" <!?是否磁盘持久化-->
diskExpiryThreadIntervalSeconds= "120"/＞ <!?运行磁盘终结的时间间隔-->
＜/ehcache＞




session
可以session进行增删改查功能实现

1、一个session中放过多的po，在执行flush和transaction时，会影响性能
2、一个session会对应一个一级缓存,另一个session不能使用其它session一级缓存中的数据
3、由以上必须要使用二级缓存
(1)、二级缓存是基于 SessionFactory工厂，一个SessionFactory的二级缓存中存的数据，凡是基于该SessionFactory 创建的session,都可以使用该二级缓存中存的数据(共享)
(2)、在具体session的执行flush或transaction提交时，不会把二级缓存中存的数据同步到数据库,提高了session的执行flush或transaction提交时 效率


4、什么时候会使用二级缓存
基于SessionFactory的二级缓存,会存通过SessionFactory创建的session查询时的数据，如果通过 session查数据时，先到session一级缓存中查找（根据po的标示符identifier）如果查不到的话，而且该查询 setCachable(true)，那么会到二级缓存中去找,如果 二级缓存还找不到话，会生成sql到库中查
5、一般一个po需要一个二级缓存配置,当然可以配置一个缺省的二级缓存配置，所有po都使用该配置

二级缓存对当前查询的对象进行缓存，如果该对象有Set容器（盛放是相关的PO对象），不对set容器中对象缓存，但对set容器当中每个对象的标示符 (identifier)进行缓存（二级缓存）,如果想在查容器中的对象， hibernate会以identifier为条件配一sql到数据库查询。[/size]
chuan315
关注
专栏目录
springboot+jpa(hibernate配置redis为二级缓存) springboot2.1.4
04-23
通过以上步骤，我们就成功地在Spring Boot 2.1.4.RELEASE项目中配置了使用Redis作为Hibernate二级缓存的环境。这将显著提升数据库查询效率，减少对数据库的压力，尤其在高并发场景下，效果尤为明显。记得在实际生产...
Hibernate一级缓存和二级缓存详解
08-26
管理二级缓存主要包括两个方面：选择需要使用第二级缓存的持久类，设置合适的并发访问策略：选择缓存适配器，设置合适的数据过期策略。 一级缓存和二级缓存的比较 | | 一级缓存 | 二级缓存 | | --- | --- | --- | ...
hibernate二级缓存攻略
wenchangren的专栏
04-21 1318
转载:javaeye很多人对二级缓存都不太了解，或者是有错误的认识，我一直想写一篇文章介绍一下hibernate的二级缓存的，今天终于忍不住了。 我的经验主要来自hibernate2.1版本，基本原理和3.0、3.1是一样的，请原谅我的顽固不化。 hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的
二级缓存
雁过寒潭
11-07 213
      与Session相对的是，SessionFactory也提供了相应的缓存机制。SessionFactory缓存可以依据功能和目的的不同而划分为内置缓存和外置缓存。        SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句，映射元数据是映射文件中数据的副本，而预定义SQL语句是在 Hibernate初始化阶段根据映射元数据推导出来的。SessionFact...
Hibernate+EHCache配置二级缓存
u014746965的专栏
11-08 753
1.前言 这篇博客再前几篇博客的基础上来讲解一下，Hibernate中的二级缓存，二级缓存是属于SessionFactory级别的缓存机制。第一级别的缓存是Session级别的缓存，是属于事务范围的缓存，由Hibernate管理，一般无需进行干预。第二级别的缓存是SessionFactory级别的缓存，是属于进程范围的缓存。  2.Hibernate二级缓存
hibernate二级缓存攻略 Ehcache（from javaEyes）
soleghost的专栏
03-27 4583
很多人对二级缓存都不太了解，或者是有错误的认识，我一直想写一篇文章介绍一下hibernate的二级缓存的，今天终于忍不住了。 我的经验主要来自hibernate2.1版本，基本原理和3.0、3.1是一样的，请原谅我的顽固不化。 hibernate的session提供了一级缓存，每个session，对同一个id进行两次load，不会发送两条sql给数据库，但是session关闭的时候，一级缓存就失效
hibernate二级缓存
蕃薯耀
08-24 129
  hibernate二级缓存     第一步：添加二级缓存配置文件ehcache.xml到项目的src目录     ehcache.xml文件可以在hibernate-release-4.2.4.Final\project\etc目录下找到   第二步：配置hibernate.cfg.xml文件 1、首先添加二级缓存支持： &lt;property name="cache.u...
day37 05-HIbernate二级缓存：一级缓存更新同步到二级缓存及二级缓存配置文件
04-26
以下是一个简单的二级缓存配置示例： ```xml <hibernate-configuration> <!-- 配置缓存插件 --> <property name="hibernate.cache.region.factory_class">org.hibernate.cache.ehcache.EhCacheRegionFactory ...
Hibernate EhCache 二级缓存配置.docx
最新发布
09-18
Hibernate EhCache 二级缓存配置 Hibernate EhCache 二级缓存配置是 Hibernate 框架中的一种缓存机制，它可以提高应用程序的性能和效率。下面是关于 Hibernate EhCache 二级缓存配置的详细知识点： 一、简介 ...
Hibernate二级缓存
11-03
Hibernate二级缓存是一种提高应用程序性能的技术，它将数据存储在SessionFactory级别的缓存中，使得数据可以在不同的Session之间共享。这与一级缓存（Session级别）不同，一级缓存仅存在于单个Session生命周期内，当...
hibernate二级缓存jar包
12-15
这是补充的hibernate框架的二级缓存jar包，里面有1.2.3和3.0.2版本
Hibernate 二级缓存
10-30
Hibernate 二级缓存
Hibernate的二级缓存
unber的博客
08-10 559
提供了一级缓存和二级缓存两种缓存。一级缓存是 Session 级别的缓存，它是属于事务范围的缓存，这一级别的缓存由 Hibernate 管理，一般情况下无须进行干预。二级缓存是 SessionFactory 级别的缓存，它是属于进程范围的缓存，这一级别的缓存可以进行配置和更改，以及动态地加载和卸载，它是由 SessionFactory 负责管理的。二级缓存与一级缓存一样，也是根据对象的 ID 加载和缓存数据的。
hibernate 二级缓存
silentJesse
11-12 235
转载自 http://hi.baidu.com/xusuofei/blog/item/609468d0bc374e8ba0ec9c88.html Hibernate的Session在事务级别进行持久化数据的缓存操作。 当然，也有可能分别为每个类（或集合)，配置集群、或JVM级别(SessionFactory级别)的缓存。 你甚至可以为之插入一个集群的缓存。注意，缓存永远不知道其他应用程序...
hibernate的二级缓存
ruanliang的专栏
11-28 303
        如果开启了二级缓存，hibernate在执行任何一次查询的之后，都会把得到的结果集放到缓存中，缓存结构可以看作是一个hash table，key是数据库记录的id，value是id对应的pojo对象。当用户根据id查询对象的时候（load、iterator方法），会首先在缓存中查找，如果没有找到再发起数据库查询。但是如果使用hql发起查询（find, query方法）则不会利用二级
Hibernate二级缓存配置详解
"Hibernate二级缓存配置" 在Java应用程序中，Hibernate是一个流行的ORM（对象关系映射）框架，它允许开发者以面向对象的方式操作数据库。而二级缓存是Hibernate提供的一种优化策略，用于提高数据访问速度和减少对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值