eclipse学习（第三章：ssh中的Hibernate）——11.Hibernate的缓存（2级缓存，get和load）

这个我在操作的过程中遇到了很多知识点&＃xff0c;不只是一篇文章了&＃xff0c;我都看了一下然后外加自己研究操作做了一个实践纪录。

2.1 jar包拉取

2.2 数据库结构

SET FOREIGN_KEY_CHECKS&＃61;0;-- ----------------------------
-- Table structure for teacher
-- ----------------------------
DROP TABLE IF EXISTS &＃96;teacher&＃96;;
CREATE TABLE &＃96;teacher&＃96; (&＃96;id&＃96; int(11) NOT NULL,&＃96;name&＃96; varchar(255) NOT NULL,&＃96;subject&＃96; varchar(255) NOT NULL,&＃96;favorite_food&＃96; varchar(255) NOT NULL,&＃96;height&＃96; double(30,0) NOT NULL,PRIMARY KEY (&＃96;id&＃96;)
) ENGINE&＃61;InnoDB DEFAULT CHARSET&＃61;utf8;-- ----------------------------
-- Records of teacher
-- ----------------------------
INSERT INTO &＃96;teacher&＃96; VALUES (&＃39;2&＃39;, &＃39;li&＃39;, &＃39;chinese&＃39;, &＃39;apple&＃39;, &＃39;168&＃39;);
INSERT INTO &＃96;teacher&＃96; VALUES (&＃39;3&＃39;, &＃39;移动&＃39;, &＃39;电子科技&＃39;, &＃39;钢铁&＃39;, &＃39;1000000&＃39;);
INSERT INTO &＃96;teacher&＃96; VALUES (&＃39;10&＃39;, &＃39;老王&＃39;, &＃39;英文&＃39;, &＃39;桃子&＃39;, &＃39;175&＃39;);


2.3 创建配置文件hibernate.cfg.xml

hibernate.cfg.xml&＃xff0c;这里主要看缓存那里即可。这里的mapping我把class注释是为了先不使用注释的方法&＃xff0c;如果使用注释的方法实现2级缓存也可以&＃xff0c;不过到时候类上要加入&＃64;Cache注解


"-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
com.mysql.cj.jdbc.Driver
jdbc:mysql://localhost:3306/student?serverTimezone&＃61;UTC
root
root
10
true
org.hibernate.dialect.MySQLDialect




updatethreadtrue
true
true
ehcache


2.4 创建ehcache.xml

ehcache.xml&＃xff0c;这个文件可以不写&＃xff0c;不写就是使用我这里的default缓存。
这里可能会有人不理解为什么空闲时间跟生存时间不一致&＃xff0c;为什么要设置这两个&＃xff1f;因为你很有可能生存了9分钟&＃xff0c;然后被访问了一次&＃xff0c;空闲时间重置了&＃xff0c;这个时候就不需要挂掉被删掉&＃xff0c;还是要缓存。同时成立才要被删除这种设计挺不错的。






-->



2.5 创建Teacher类

Teacher&＃xff0c;
&＃64;org.hibernate.annotations.Cache标注的3个属性
usage&＃xff0c;设置二级缓存的并发策略&＃xff0c;并发策略后面单拎出来说
region&＃xff0c;设置二级缓存的区域&＃xff0c;自定义的cache名称
include&＃xff0c;设置是否缓存lazy的数据&＃xff0c;all表示缓存lazy的数据&＃xff0c;non-lazy表示只缓存非lazy的数据

package com.czx.cache.pojo;import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Id;
import javax.persistence.Table;import org.hibernate.annotations.Cache;
import org.hibernate.annotations.CacheConcurrencyStrategy;&＃64;Entity
&＃64;Table(name &＃61; "teacher")
//&＃64;Cache( usage&＃61;CacheConcurrencyStrategy.READ_WRITE,region&＃61;"sampleCache1")
public class Teacher {&＃64;Id&＃64;Column(name &＃61; "id")private Integer id;&＃64;Column(name &＃61; "name")private String name;&＃64;Column(name &＃61; "subject")private String subject;&＃64;Column(name &＃61; "favorite_food")private String favoriteFood;&＃64;Column(name &＃61; "height")private Double height;public Teacher(Integer id, String name, String subject, String favoriteFood, Double height) {super();this.id &＃61; id;this.name &＃61; name;this.subject &＃61; subject;this.favoriteFood &＃61; favoriteFood;this.height &＃61; height;}public Teacher() {super();}&＃64;Overridepublic String toString() {return "Teacher [id&＃61;" &＃43; id &＃43; ", name&＃61;" &＃43; name &＃43; ", subject&＃61;" &＃43; subject &＃43; ", favoriteFood&＃61;" &＃43; favoriteFood&＃43; ", height&＃61;" &＃43; height &＃43; "]";}public Integer getId() {return id;}public void setId(Integer id) {this.id &＃61; id;}public String getName() {return name;}public void setName(String name) {this.name &＃61; name;}public String getSubject() {return subject;}public void setSubject(String subject) {this.subject &＃61; subject;}public String getFavoriteFood() {return favoriteFood;}public void setFavoriteFood(String favoriteFood) {this.favoriteFood &＃61; favoriteFood;}public Double getHeight() {return height;}public void setHeight(Double height) {this.height &＃61; height;}}

2.6 Teacher.hbm.xml

Teacher.hbm.xml&＃xff0c;
cache 的3个属性
usage&＃xff0c;设置二级缓存的并发策略&＃xff0c;并发策略后面单拎出来说
region&＃xff0c;设置二级缓存的区域&＃xff0c;自定义的cache名称
include&＃xff0c;设置是否缓存lazy的数据&＃xff0c;all表示缓存lazy的数据&＃xff0c;non-lazy表示只缓存非lazy的数据


一个teacher类的描述处理


2.7 创建测试CacheLearn

CacheLearn&＃xff0c;这里我加入线程休眠是为了测试2级缓存是否过期&＃xff0c;没啥问题的&＃xff0c;自己注释打开就能得到不一样的结果了

package com.czx.cache;import java.util.Date;import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;import com.czx.cache.pojo.Teacher;public class CacheLearn {
private static SessionFactory sessionFactory &＃61; new Configuration().configure().buildSessionFactory();public static void main(String[] args) {CacheLearn cacheLearn &＃61; new CacheLearn();cacheLearn.cache007();}public void cache007() {Session session &＃61; sessionFactory.openSession();Transaction transaction &＃61; session.beginTransaction();Teacher t &＃61; session.load(Teacher.class, 3);System.out.println(t.getFavoriteFood());Thread tt &＃61;new Thread();transaction.commit();
// System.out.println(new Date());//弄个线程处理休眠下&＃xff0c;这里毫秒单位来的
// try {
// tt.sleep(60000L);
// }catch (Exception e) {
// // TODO: handle exception
// }
// System.out.println(new Date());Session session2 &＃61; sessionFactory.openSession();Transaction transaction2 &＃61; session2.beginTransaction();Teacher t2 &＃61; session2.load(Teacher.class, 3);System.out.println(t2);transaction2.commit();session.close();}
}
3、1级2级缓存相关概念以及缓存策略

下面有个图我们客户端通过session进行查询操作&＃xff0c;这个时候我们会先去找一级缓存有没有&＃xff0c;如果有就直接返回&＃xff0c;如果没有就去找2级缓存有没有&＃xff0c;如果有也可以直接返回给客户端。都没有的情况下去找数据库做相关操作&＃xff0c;操作完成数据存到session1级缓存中去&＃xff0c;然后在存到2级缓存去&＃xff0c;最后返回给客户端。

3.1一级缓存

第一级缓存是 Session 缓存并且是一种强制性的缓存&＃xff0c;所有的要求都必须通过它。Session 对象在它自己的权利之下&＃xff0c;在将它提交给数据库之前保存一个对象。

如果你对一个对象发出多个更新&＃xff0c;Hibernate 会尝试尽可能长地延迟更新来减少发出的 SQL 更新语句的数目。如果你关闭 session,所有缓存的对象丢失&＃xff0c;或是存留&＃xff0c;或是在数据库中被更新。

3.2 二级缓存

第二级缓存是一种可选择的缓存并且第一级缓存在任何想要在第二级缓存中找到一个对象前将总是被询问。第二级缓存可以在每一个类和每一个集合的基础上被安装&＃xff0c;并且它主要负责跨会话缓存对象。

3.3 缓存的并发策略

并发策略
一个并发策略是一个中介&＃xff0c;它负责保存缓存中的数据项和从缓存中检索它们。如果你将使用一个二级缓存&＃xff0c;你必须决定&＃xff0c;对于每一个持久类和集合&＃xff0c;使用哪一个并发策略。
缓存并发策略&＃xff0c;可以得知这里面的级别是从高到低的&＃xff0c;Transactional最高最严谨&＃xff0c;阻止脏读不可重复读&＃xff0c;遇到下面就越不严谨&＃xff0c;根据项目的具体情况去选择合适的。

3.4 缓存提供者

下面这个其实主要看他能否集群&＃xff0c;支持什么集群就够了。

下面这个的话是不同的缓存提供者支持什么类型的缓存策略。每一个缓存提供者都不和每个并发策略兼容。以下的兼容性矩阵将帮助你选择一个合适的组合。

我先说一下1&＃43;n是什么问题吧。
网络上有的说是如果你查询一个集合&＃xff0c;但是呢&＃xff0c;由于你查询的只是一个集合&＃xff0c;返回的是一个id集合并没有真的去细查&＃xff0c;到了真正要使用的时候&＃xff0c;又会再去查一次数据库。
举例说明&＃xff1a;
如果你使用的是iterate这个方法&＃xff0c;那么就会出现这个问题&＃xff0c;结果如下&＃xff0c;你可以看看。&＃xff08;这个iterate已经过期了&＃xff0c;了解一下看看吧&＃xff09;

Iterator iterator &＃61; session.createQuery("from Teacher").iterate();for(;iterator.hasNext();) {System.out.println(iterator.next());}


但是&＃xff0c;当你使用查询的list方法不会有1&＃43;n问题&＃xff0c;所以我感觉没啥用&＃xff0c;而且iterate方法也已经过期。这个1&＃43;n问题也可以通过2级缓存解决。

4.1 list方法的缓存

list() 默认情况只会放入缓存&＃xff0c;不会从一级缓存中取&＃xff01;
使用查询缓存&＃xff0c;可以让list()查询从二级缓存中取&＃xff01;
1、开启查询缓存后查询的list()可以从二级缓存中拿数据(list()不能从一级缓存[session缓存]中拿数据)&＃xff0c;但是不主动去拿&＃xff0c;需要设置setCacheable(true)

get和load都是通过id获取到对应的数据。
关于这个get说法众说纷纭&＃xff0c;各有各的看法&＃xff0c;我自己操作看看才能知道结果。百度有的说get可以查2级&＃xff0c;有人说不行&＃xff0c;我自己测试不就知道了。
在我配置好了2级缓存的情况下&＃xff0c;执行以下代码&＃xff08;以下是方法&＃xff0c;调用一下即可&＃xff09;
这里我一开始使用get获取数据&＃xff0c;关闭session&＃xff0c;在获取一次数据看看&＃xff0c;结果如下&＃xff0c;显而易见&＃xff0c;这个get是可以查2级缓存的。

public void cacheTest() {Session session &＃61; sessionFactory.openSession();Transaction transaction &＃61; session.beginTransaction();Teacher t &＃61; session.get(Teacher.class, 3);System.out.println(t);transaction.commit();session.close();Session session2 &＃61; sessionFactory.openSession();Transaction transaction2 &＃61; session2.beginTransaction();Teacher t2 &＃61; session2.get(Teacher.class, 3);System.out.println(t2);transaction2.commit();session2.close();}


5.1 对于Hibernate的get方法。

这里说下其实本质就是如果要查数据&＃xff0c;先查看一下session一级缓存有没有数据&＃xff0c;如果没有就去2级缓存中找&＃xff0c;都没有再去查找数据库。其中每一个session是独立开来的&＃xff0c;如果你关闭了session&＃xff0c;那么里面的缓存也会丢失&＃xff0c;但是2级缓存的介质不一样所以还能存起来&＃xff0c;所以如果加入了2级缓存那么只要查一次就算清空session之后也还能查到数据。
这里有一个特例&＃xff0c;如果数据库没有数据&＃xff0c;那么就没法缓存&＃xff0c;每一次去查都要去到数据库查为null的数据&＃xff0c;这样就会造成缓存穿透。
看到这里如果你对上面概念还是不了解在建议看看下面我举得例子。
第一次查数据的情况&＃xff1a;
首先启动session---->
然后去session缓存&＃xff08;一级缓存&＃xff09;中找。第一次是没有的---->
所以去更下级缓存中找&＃xff0c;2级缓存有没有呢&＃xff1f;其实还能继续往下找更高级的缓存&＃xff0c;但是这里以2级缓存为例就够了。---->
缓存中找不到了&＃xff0c;那么查数据库去&＃xff0c;如果没有对应的数据&＃xff0c;那么也会返回null&＃xff0c;正常有数据就能返回对应的对象。然后将数据缓存到session缓存中。


连续二次查数据的情况下&＃xff08;没有关闭session&＃xff0c;在一个session中查数据&＃xff0c;这里2级缓存用不到&＃xff09;&＃xff1a;
第一次查询结束---->
接着查相同的hql/sql语句---->
去session缓存中找&＃xff0c;找到了---->
返回对应的对象即可


连读二次查数据的情况&＃xff08;在不同的session&＃xff09;
第一次查询数据结束---->
关闭session---->
新建一个新的sessionA---->
使用sessionA查数据---->
sessionA缓存中没有数据&＃xff0c;去查找数据库---->
将数据库数据返回


连读二次查数据的情况&＃xff08;在不同的session&＃xff0c;启用了2级缓存&＃xff09;
第一次查询数据结束---->
关闭session–>
新建一个新的sessionA---->
使用sessionA查数据----->
sessionA中没有数据&＃xff0c;去2级缓存中找&＃xff0c;找到了---->
将2级缓存中内容返回

5.2 对于Hibernate的load方法。

如果你使用了get方法返回数据那么必定会有是数据库的查询语句&＃xff0c;但是如果你使用的是load方法&＃xff0c;那么就未必是了。
当我们使用session.load()方法来加载一个对象时&＃xff0c;此时并不会发出SQL语句&＃xff0c;当前得到的这个对象其实是一个代理对象&＃xff0c;这个代理对象只保存了实体对象的id值&＃xff0c;只有当我们要使用这个对象&＃xff08;例如要打印这个数据&＃xff09;&＃xff0c;得到其它属性时&＃xff0c;这个时候才会发出SQL语句&＃xff0c;从数据库中去查询对象。如果你只是要获取id值&＃xff0c;那么也并不会访问数据库。
实际上工作流程是这样的&＃xff0c;这类似懒加载&＃xff0c;我们一开始加载数据都去缓存中找&＃xff0c;先一级后2级&＃xff0c;找不到了&＃xff0c;那么也先会返回一个代理对象&＃xff0c;里面只带有对象id。到了我们要使用该对象&＃xff08;不是id的其他属性&＃xff09;的时候&＃xff0c;那么才会真正去向数据库发请求&＃xff0c;然后将数据缓存到session中去。第二次查找如果缓存没了那么跟第一次查找一样。缓存还在进行第二次查找&＃xff0c;加载数据去缓存中找&＃xff0c;返回一个对象的引用&＃xff0c;到了要使用该对象的时候可以直接从缓存中获取了

第一次查找数据
使用load方法获取数据----->
去缓存中找数据&＃xff0c;没有就返回一个代理对象---->
该代理对象带id&＃xff0c;如果你要使用该对象除了id以外的属性那么就要去查询数据库------>
数据库获取到了数据&＃xff0c;返回并将数据存到session缓存中去

第二次查找数据&＃xff0c;缓存在
使用load方法获取数据------>
去缓存中找数据&＃xff0c;发现有数据&＃xff0c;于是就返回该对象的引用----->
然后获取属性可以去缓存中拿了。

5.3 说完它们的不同工作流程&＃xff0c;那么来说一下它们如果出错会报什么异常吧

上面流程说过了&＃xff0c;get是会从数据库获取对象的&＃xff0c;那么如果数据库没有这个对象&＃xff0c;我还要调用这个对象的属性&＃xff0c;那么会报什么异常呢&＃xff1f;java.lang.NullPointerException&＃xff0c;空指针异常&＃xff0c;是null的。
load方法会返回一个代理对象&＃xff0c;那么如果数据库没有&＃xff0c;我还要调用这个对象的属性会报什么异常&＃xff1f;org.hibernate.ObjectNotFoundException&＃xff0c;因为我们的代理对象只有id&＃xff0c;其他属性都是没有的呀。

这篇不是很建议看项目&＃xff0c;因为我在里面不停的做不同情况下的测试&＃xff0c;不过如果你想要看&＃xff0c;那也行吧。
https://gitee.com/mrchen13427566118/ssh_hibernate_learn.git里面的ssh_hibernate_cache。
打开方式可以看这篇
https://blog.csdn.net/weixin_43987277/article/details/116936221里面的第三点。