缓存
今天我们就来讲一下hibernate中实体状态和hibernate缓存。
1）首先我们先来看一下实体状态：
实体状态主要分三种：transient，persitent，detached。
看英文应该就大概明白了吧。
transient：是指数据还没跟数据库中的数据相对应。
persistent：是指数据跟数据库中的数据相对应，它的任何改变都会反映到数据库中。
detached：是指数据跟数据库中的数据相对应，但由于session被关闭，它所做的修改不会对数据库的记录造成影响。
下面我们直接代码来：
我要评论
transaction tx = session.begintransaction();
user user = new user();
user.setname("shun");
//这里的user还未保存到数据库，数据库表中并没有与之对应的记录，它为transient状态
session.save(user);
tx.commit();
//提交之后user变为persistent状态
session.close();
//由于session关闭，此时的user为detached状态，它的所有修改都不会反映到数据库中。
session session2 = sessionfactory.opensession();
tx = session2.begintransaction();
user.setname("shun123");
session2.saveorupdate(user);
tx.commit();
//当我们调用了saveorupdate之后，user重新变为persistent状态，它的所有修改都会反映到数据库中。
session2.close();
我们看到代码，首先我们定义了一个对象user，在未保存之前，它就是transient状态，在数据库中并没有与它相应的记录。而当我们进行保存并提交修改后，user成为persistent状态，在数据库中有相应的一条记录。而当我们把session关闭后，user就变成了detached状态了，它的更改并不会反映到数据库中，除非我们手动调用saveorupdate等相应的更新和添加方法。而当我们直接想让它从persistent到transient状态，怎么办呢？直接删除就可以了，删除后对象就在数据库中没有对应的记录，也就成transient状态了。
hibernate的状态转换还是比较简单的，当是transient状态时，数据库没有记录对应，而persistent和detached时都有对应的记录，但唯一的区别是detached是在session关闭之后才有的状态。那么transient和detached的区别又是什么呢？就是有没有数据库表记录对应的问题。
2）看完了状态我们来看一下hibernate的缓存
hibernate的缓存分两种，一级缓存和二级缓存。
一级缓存：所谓的一级缓存也就是内部缓存。
二级缓存：它包括应用级缓存，在hibernate就是所谓的sessionfactory缓存，另外一个是分布式缓存，这个是最安全的缓存方式。
直接来看程序：
public static void main(string[] args) {
configuration cfg = new configuration().configure();
sessionfactory sessionfactory = cfg.buildsessionfactory();
session session = sessionfactory.opensession();
user user = (user)session.load(user.class,new long(29));
system.out.println(user.getname());
user user2 = (user)session.load(user.class,new long(29));
system.out.println(user2.getname());
session.close();
}
看结果：
hibernate: select user0_.user_id as user1_0_0_, user0_.user_name as user2_0_0_, user0_.age as age0_0_ from user user0_ where user0_.user_id=? shun123123 shun123123
例子中我们用了两次load，但结果中只有一句sql语句，这表明它只查询了一次。
为什么呢？这也就是hibernate的缓存起作用了。第一次查询完毕后，hibernate后把查出来的实体放在缓存中，下一次查的时候首先会查缓存，看有没有对应id的实体存在，如果有则直接取出，否则则进行数据库的查询。
下面我们把代码修改成：
user user = (user)session.load(user.class,new long(29));
system.out.println(user.getname());
session.evict(user);//把user从缓存中删掉
user user2 = (user)session.load(user.class,new long(29));
system.out.println(user2.getname());
session.close();
看到结果：
hibernate: select user0_.user_id as user1_0_0_, user0_.user_name as user2_0_0_, user0_.age as age0_0_ from user user0_ where user0_.user_id=? shun123123 hibernate: select user0_.user_id as user1_0_0_, user0_.user_name as user2_0_0_, user0_.age as age0_0_ from user user0_ where user0_.user_id=? shun123123
自己我们把user从缓存中删除后，第二次的查询也直接从数据库中取出。
二级缓存小谈
先看实体类：
public class user implements serializable{
public long id;
private string name;
private int age;
}
映射文件就省略啦，大家应该都会写的。
再来看看hibernate配置文件：
<property name="hibernate.cache.provider_class">org.hibernate.cache.ehcacheprovider</property> <property name="hibernate.cache.use_second_level_cache">true</property> <property name="hibernate.cache.use_query_cache">true</property>
我们看到provider_class中我们指定了ehcache这个提供类，所以我们也需要ehcache.xml放在classpath中：
<?xml version="1.0" encoding="utf-8"?>
<ehcache>
<diskstore path="java.io.path"/>
<defaultcache
maxelementsinmemory="10000"
eternal="false"
timetoidleseconds="120"
timetoliveseconds="120"
overflowtodisk="true"
/>
</ehcache>
接下来，我们直接看一下测试方法：
public static void main(string[] args) {
configuration cfg = new configuration().configure();
sessionfactory sessionfactory = cfg.buildsessionfactory();
session session = sessionfactory.opensession();
query query = session.createquery("from user user where name = 'shun123'");
iterator iter = query.iterate();
while(iter.hasnext()) {
system.out.println(((user)iter.next()).getname());
}
session.close();
session session2 = sessionfactory.opensession();
query query2 = session2.createquery("from user user where name='shun123'");
iterator iter2 = query2.iterate();
while(iter2.hasnext()) {
system.out.println(((user)iter2.next()).getname());
}
session2.close();
}
运行后可以看到：
hibernate: select user0_.user_id as col_0_0_ from user user0_ where user0_.user_name='shun123' hibernate: select user0_.user_id as user1_0_0_, user0_.user_name as user2_0_0_, user0_.age as age0_0_ from user user0_ where user0_.user_id=? shun123 hibernate: select user0_.user_id as col_0_0_ from user user0_ where user0_.user_name='shun123' shun123
我们可以看到它只执行了一句搜索，而在第二次查询时并没有取出id进行搜索，这主要归功于二级缓存。
下面我们先分析一下测试方法中的代码。测试方法中我们分别打开了两个session并且分别创建两个query进行相同的查询。但两次session可以共用缓存，这也就是二级缓存，sessionfactory级的缓存。只要我们的session由同一个sessionfactory创建，那么我们就可以共用二级缓存减少与数据库的交互。
我们再来看一下配置文件中的意思：
<property name="hibernate.cache.provider_class">org.hibernate.cache.ehcacheprovider</property> <property name="hibernate.cache.use_second_level_cache">true</property> <property name="hibernate.cache.use_query_cache">true</property>
如果我们需要使用二级缓存，首先需要配置：
<property name="hibernate.cache.use_second_level_cache">true</property>
进行开户二级缓存，然后通过：
<property name="hibernate.cache.provider_class">org.hibernate.cache.ehcacheprovider</property>
指定二级缓存的提供类，一般情况下我们都用ehcache，其他我的暂时没用到，也不太清楚，所以暂时不讲了。
像我们刚才的例子，我们只需要配置上面两个，完全可以正常运行，利用二级缓存。
那么第三句是干什么用的呢？
<property name="hibernate.cache.use_query_cache">true</property>
这个配置指明了我们在查询时需要利用缓存，如果我们需要用到这个要事先调用query.setcacheable(true)这个方法来进行启用。
我们一起来看代码（我们先不启用缓存）：
public static void main(string[] args) {
configuration cfg = new configuration().configure();
sessionfactory sessionfactory = cfg.buildsessionfactory();
session session = sessionfactory.opensession();
query query = session.createquery("from user user where name = 'shun123'");
list list = query.list();
for (int i = 0; i < list.size(); i++){
system.out.println(((user)list.get(i)).getname());
}
session.close();
session session2 = sessionfactory.opensession();
query query2 = session2.createquery("from user user where name='shun123'");
list list2 = query2.list();
for (int i = 0; i < list2.size(); i++){
system.out.println(((user)list.get(i)).getname());
}
session2.close();
}
这里输出的结果是：
hibernate: select user0_.user_id as user1_0_, user0_.user_name as user2_0_, user0_.age as age0_ from user user0_ where user0_.user_name='shun123' shun123 hibernate: select user0_.user_id as user1_0_, user0_.user_name as user2_0_, user0_.age as age0_ from user user0_ where user0_.user_name='shun123' shun123
我们看到，它并没有利用缓存，因为我们这里用了list，而list对缓存是只写不读的。所以这里会进行两次查询。
那么我们来修改一下：
public static void main(string[] args) {
configuration cfg = new configuration().configure();
sessionfactory sessionfactory = cfg.buildsessionfactory();
session session = sessionfactory.opensession();
query query = session.createquery("from user user where name = 'shun123'");
<span style="background-color: #ffffff;"><span style="color: #ff0000;">query.setcacheable(true);</span></span>
list list = query.list();
for (int i = 0; i < list.size(); i++){
system.out.println(((user)list.get(i)).getname());
}
session.close();
session session2 = sessionfactory.opensession();
query query2 = session2.createquery("from user user where name='shun123'");
<span style="color: #ff0000;">query2.setcacheable(true);</span>
list list2 = query2.list();
for (int i = 0; i < list2.size(); i++){
system.out.println(((user)list.get(i)).getname());
}
session2.close();
}
看到红色的两句代码，这是我们进行添加的两个开启查询缓存的代码，现在我们看到结果：
hibernate: select user0_.user_id as user1_0_, user0_.user_name as user2_0_, user0_.age as age0_ from user user0_ where user0_.user_name='shun123' shun123 shun123
只剩一次查询了，为什么呢？就在那两句红色代码处，我们开启了缓存，记住，需要使用两次。把两个query都设成可缓存的才能使用查询缓存。
criteria也是类似的做法，为免有些童鞋忘记了criteria怎么写了，我还是放一下代码：
public static void main(string[] args) {
configuration cfg = new configuration().configure();
sessionfactory sessionfactory = cfg.buildsessionfactory();
session session = sessionfactory.opensession();
criteria criteria1 = session.createcriteria(user.class);
criteria1.setcacheable(true);
criteria1.add(restrictions.eq("name","shun123"));
list list = criteria1.list();
for (int i = 0; i < list.size(); i++){
system.out.println(((user)list.get(i)).getname());
}
session.close();
session session2 = sessionfactory.opensession();
criteria criteria2 = session2.createcriteria(user.class);
criteria2.setcacheable(true);
criteria2.add(restrictions.eq("name","shun123"));
list list2 = criteria2.list();
for (int i = 0; i < list2.size(); i++){
system.out.println(((user)list.get(i)).getname());
}
session2.close();
}
我们看结果：
hibernate: select this_.user_id as user1_0_0_, this_.user_name as user2_0_0_, this_.age as age0_0_ from user this_ where this_.user_name=? shun123 shun123
如对本文有疑问， 点击进行留言回复！！
Algebra:Chapter 0 - 预备知识: 集合论和categories
springboot + vue上传图片在服务器并实现在线预览
请谨慎使用增强for循环，刚接触Java值得一看（手动狗头）
【Nginx】还不会使用Nginx解决跨域问题？肝这一篇就够了！！
网友评论