`
haijuanliang
  • 浏览: 1299 次
  • 性别: Icon_minigender_2
  • 来自: 济南
最近访客 更多访客>>
文章分类
社区版块
存档分类
最新评论

hibernate二级缓存

HibernateXMLCache 
阅读更多
Java代码 
public class User implements Serializable{  
 
    public Long id;  
    private String name;  
    private int age;  
      
} 

public class User implements Serializable{

public Long id;
private String name;
private int age;

}
映射文件就省略啦，大家应该都会写的。

再来看看hibernate配置文件：

Xml代码 
<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.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代码 
<?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> 

<?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> 接下来，我们直接看一下测试方法：

Java代码 
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();  
 
} 

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();

} 运行后可以看到：

Java代码 
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 

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创建，那么我们就可以共用二级缓存减少与数据库的交互。

我们再来看一下配置文件中的意思：

Xml代码 
<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.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> 如果我们需要使用二级缓存，首先需要配置：

Xml代码 
<property name="hibernate.cache.use_second_level_cache">true</property> 

<property name="hibernate.cache.use_second_level_cache">true</property> 进行开户二级缓存，然后通过：

Xml代码 
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property> 

<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property> 指定二级缓存的提供类，一般情况下我们都用ehcache，其他我的暂时没用到，也不太清楚，所以暂时不讲了。

像我们刚才的例子，我们只需要配置上面两个，完全可以正常运行，利用二级缓存。

那么第三句是干什么用的呢？

Xml代码 
<property name="hibernate.cache.use_query_cache">true</property> 

<property name="hibernate.cache.use_query_cache">true</property> 这个配置指明了我们在查询时需要利用缓存，如果我们需要用到这个要事先调用query.setCacheable(true)这个方法来进行启用。



我们一起来看代码（我们先不启用缓存）：

Java代码 
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();  
 
} 

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();

} 这里输出的结果是：

Java代码 
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 

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对缓存是只写不读的。所以这里会进行两次查询。

那么我们来修改一下：

Java代码 
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();  
 
} 

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'");
query.setCacheable(true);
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'");
query2.setCacheable(true);
List list2 = query2.list();
for (int i = 0; i < list2.size(); i++){
System.out.println(((User)list.get(i)).getName());
}

session2.close();

} 看到红色的两句代码，这是我们进行添加的两个开启查询缓存的代码，现在我们看到结果：

Java代码 
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 

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怎么写了，我还是放一下代码：

Java代码 
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();  
 
} 

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();

} 我们看结果：

Java代码 
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
分享到：
struts
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    Hibernate二级缓存

    Hibernate二级缓存是一种提高应用程序性能的技术，它将数据存储在SessionFactory级别的缓存中，使得数据可以在不同的Session之间共享。这与一级缓存（Session级别）不同，一级缓存仅存在于单个Session生命周期内，当...

    hibernate 二级缓存详解

    Hibernate 二级缓存是针对SessionFactory级别的全局缓存，与一级缓存（Session级别）不同，一级缓存只在单个Session生命周期内有效。二级缓存则允许不同Session之间共享数据，提高了数据访问效率，减少了对数据库的...

    Hibernate 二级缓存

    Hibernate 二级缓存

    hibernate二级缓存实例

    在这个"hibernate二级缓存实例"中，我们将深入探讨二级缓存的原理、配置以及在实际项目中的应用。 首先，我们需要了解一级缓存和二级缓存的区别。一级缓存是Session级别的，每个Session都有自己的一级缓存，用于...

    hibernate二级缓存示例源码

    **hibernate二级缓存详解** Hibernate作为Java领域中广泛使用的对象关系映射（ORM）框架，极大地简化了数据库操作。然而，在处理大量数据时，性能优化显得尤为重要，这就是二级缓存的作用。本文将深入探讨Hibernate...

    Hibernate 二级缓存 总结整理

    **Hibernate 二级缓存总结整理** 在Java的持久化框架中，Hibernate是一个广泛使用的ORM（对象关系映射）工具，它极大地简化了数据库操作。在处理大数据量或高并发的场景下，为了提高性能和减少数据库负载，...

    hibernate二级缓存包

    Hibernate二级缓存是Java开发中使用Hibernate框架进行数据持久化时优化性能的一种重要技术。它在一级缓存（Session级别的缓存）的基础上，提供了一个全局的、跨会话的数据存储层，可以显著减少对数据库的访问，从而...

    hibernate二级缓存java包下载

    二级缓存是 Hibernate 缓存策略的一部分，它在应用程序的多个会话之间共享数据，进一步优化了数据库访问效率。 二级缓存分为以下关键知识点： 1. **一级缓存与二级缓存的区别**： - 一级缓存：每个 Hibernate ...

    hibernate 二级缓存

    本篇文章将深入探讨Hibernate二级缓存的概念、工作原理以及如何在实际项目中设置和使用。 **一、二级缓存概念** 一级缓存是每个Hibernate Session内部的一个内存区域，用于存储Session期间的操作对象。当Session...

    hibernate二级缓存所需要的 jar包

    本篇将详细介绍Hibernate二级缓存的概念、作用以及所需jar包的作用。 一、Hibernate二级缓存概念 Hibernate的一级缓存是指Session级别的缓存，每个Session内部都有一个一级缓存，用于存储实体对象，当Session关闭时...

    Hibernate二级缓存（Ehcache）

    【标题】：“Hibernate二级缓存（Ehcache）” 【正文】： Hibernate是一个流行的Java对象关系映射（ORM）框架，它允许开发者用面向对象的方式来处理数据库操作。然而，随着应用规模的扩大，性能优化变得至关重要，...

    day37 05-HIbernate二级缓存：一级缓存更新同步到二级缓存及二级缓存配置文件

    本篇文章将深入探讨Hibernate的二级缓存机制，以及如何进行一级缓存与二级缓存的同步，同时还会介绍二级缓存的配置文件设置。 一级缓存是Hibernate默认提供的缓存，每个SessionFactory实例都有一个一级缓存。当对象...

Magicbox
Global site tag (gtag.js) - Google Analytics