hibernate的查询缓存

冷不防 2022-08-02 10:58 130阅读 0赞

在hibernate的使用中，大家多数时间都在讨论一级缓存和二级缓存，而往往忽略了查询缓存。其实hibernate的查询缓存在使用过程中也起着同样重要的作用。hibernate的查询缓存是主要是针对普通属性结果集的缓存， 而对于实体对象的结果集只缓存id。在一级缓存,二级缓存和查询缓存都打开的情况下作查询操作时这样的：查询普通属性，会先到查询缓存中取，如果没有，则查询数据库；查询实体，会先到查询缓存中取id，如果有，则根据id到缓存(一级/二级)中取实体，如果缓存中取不到实体，再查询数据库。

和一级/二级缓存不同，查询缓存的生命周期 ，是不确定的，当前关联的表发生改变时，查询缓存的生命周期结束。

查询缓存的配置和使用也是很简单的：  
         1>查询缓存的启用不但要在配置文件中进行配置  
             <property name="hibernate.cache.use\_query\_cache">true</property>  
         2>还要在程序中显示的进行启用  
             query.setCacheable(true);  
  
1>查询缓存的启用不但要在配置文件中进行配置 -------换成spring配置  
<bean id="propertyConfigurer" class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">  
        <property name="locations">  
            <list>  
                <value>/WEB-INF/config/jdbc.properties</value>  
            </list>  
        </property>  
    </bean>  
    <bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">  
        <property name="driverClass" value="$\{jdbc.driverClassName\}" />  
        <property name="jdbcUrl" value="$\{jdbc.url\}" />  
        <property name="user" value="$\{jdbc.username\}" />  
        <property name="password" value="$\{jdbc.password\}" />  
        <property name="autoCommitOnClose" value="true"/>  
        <property name="checkoutTimeout" value="$\{cpool.checkoutTimeout\}"/>  
        <property name="initialPoolSize" value="$\{cpool.minPoolSize\}"/>  
        <property name="minPoolSize" value="$\{cpool.minPoolSize\}"/>  
        <property name="maxPoolSize" value="$\{cpool.maxPoolSize\}"/>  
        <property name="maxIdleTime" value="$\{cpool.maxIdleTime\}"/>  
        <property name="acquireIncrement" value="$\{cpool.acquireIncrement\}"/>  
        <property name="maxIdleTimeExcessConnections" value="$\{cpool.maxIdleTimeExcessConnections\}"/>  
    </bean>  
<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">  
        <property name="dataSource" ref="dataSource"/>      
        <property name="mappingLocations">  
            <list>  
                <value>classpath\*:/com/jeecms/core/entity/hbm/\*.hbm.xml</value>  
                <value>classpath\*:/com/jeecms/cms/entity/main/hbm/\*.hbm.xml</value>  
                <value>classpath\*:/com/jeecms/cms/entity/assist/hbm/\*.hbm.xml</value>  
            </list>  
        </property>  
        <property name="hibernateProperties">  
            <value>  
            hibernate.dialect=org.hibernate.dialect.MySQLInnoDBDialect  
            hibernate.show\_sql=false  
            hibernate.format\_sql=false  
            hibernate.query.substitutions=true 1, false 0  
            hibernate.jdbc.batch\_size=20  
            //查询缓存配置  
            hibernate.cache.use\_query\_cache=true  
            </value>  
        </property>  
        <property name="entityInterceptor">     
            <ref local="treeInterceptor"/>  
        </property>  
        <property name="cacheProvider">  
            <ref local="cacheProvider"/>  
        </property>  
        <property name="lobHandler">  
            <ref bean="lobHandler" />  
        </property>  
    </bean>  
  
2>还要在程序中显示的进行启用  
public List<CmsSite> getList(boolean cacheable) \{  
        String hql = "from CmsSite bean order by bean.id asc";  
        return getSession().createQuery(hql).setCacheable(cacheable).list();  
    \}

**1.实体类：**

**  Student.jsva**

public  class Student \{   
   private Integer id;   
   private String name;   
   //一系列的setter.getter方法   
\}

**2.映射文件**

**Student.hbm.xml**

< class  name ="com.sxt.hibernate.cache.entity.Student"  table ="sxt\_hibernate\_student" >   
           
       
       
     < id  name ="id"  length ="4" >   
       < generator  class ="native" > </ generator >   
     </ id >   
     < property  name ="name"  length ="10" > </ property >   
   </ class >

**3.hibernate配置文件：**

**  hibernate.cfg.xml**

< hibernate-configuration >   
   < session-factory >   
     < property  name ="hibernate.connection.url" >jdbc:oracle:thin:@localhost:1521:ORCL10 </ property >  
     < property  name ="hibernate.connection.driver\_class" >oracle.jdbc.driver.OracleDriver </ property >   
     < property  name ="hibernate.connection.username" >scott </ property >   
     < property  name ="hibernate.connection.password" >yf123 </ property >   
     < property  name ="hibernate.dialect" >org.hibernate.dialect.Oracle9Dialect </ property >   
     < property  name ="hibernate.show\_sql" >true </ property >   
       
       
     < property  name ="hibernate.cache.use\_second\_level\_cache" >true </ property >   
       
     < property  name ="hibernate.cache.provider\_class" >org.hibernate.cache.EhCacheProvider </ property >   
       
       
     < property  name ="hibernate.cache.use\_query\_cache" >true </ property >   
       
     < mapping  resource ="com/sxt/hibernate/cache/entity/Student.hbm.xml" />   
       
       
     < class-cache  usage ="read-only"  class ="com.sxt.hibernate.cache.entity.Student" />   
   </ session-factory >   
</ hibernate-configuration >

**4.测试方法：**

public  static  void main(String\[\] args) \{   
    Session session =  null;   
    Transaction t =  null;   
  
    \* //\*\*   
     \* 开启查询缓存,关闭二级缓存, 开启一个session,分别调用query.list   
     \*/   
  //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况.   
  /\*   
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s.name from Student s");   
      //启用查询缓存      
      query.setCacheable(true);   
      List<String> names = query.list();   
      for (Iterator<String> it = names.iterator(); it.hasNext();) \{   
        String name = it.next();   
        System.out.println(name);   
      \}   
      System.out.println("================================");   
      query = session.createQuery("select s.name from Student s");   
      //启用查询缓存   
      query.setCacheable(true);   
      //没有发出查询语句,因为这里使用的查询缓存   
      names = query.list();   
      for (Iterator<String> it = names.iterator(); it.hasNext();) \{   
        String name = it.next();   
        System.out.println(name);   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
  \}\*/   
      
/\*  @SuppressWarnings("unchecked")   
  public static void main(String\[\] args) \{   
    Session session = null;   
    Transaction t = null;   
  
    \*//\*\*   
     \* 开启查询缓存,关闭二级缓存, 开启两个session,分别调用query.list   
     \*//\*   
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况.   
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s.name from Student s");   
      //启用查询缓存      
      //query.setCacheable(true);   
      List<String> names = query.list();   
      for (Iterator<String> it = names.iterator(); it.hasNext();) \{   
        String name = it.next();   
        System.out.println(name);   
      \}   
  
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
       
    System.out.println("================================");   
       
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s.name from Student s");   
      //启用查询缓存      
      //query.setCacheable(true);   
      //不会发出查询语句,因为查询缓存和session无关.   
      List<String> names = query.list();   
      for (Iterator<String> it = names.iterator(); it.hasNext();) \{   
        String name = it.next();   
        System.out.println(name);   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
  \}\*/   
      
/\*  @SuppressWarnings("unchecked")   
  public static void main(String\[\] args) \{   
    Session session = null;   
    Transaction t = null;   
  
    \*//\*\*   
     \* 开启查询缓存,关闭二级缓存, 开启两个session,分别调用query.iterate   
     \*//\*   
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况.   
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s.name from Student s");   
      //启用查询缓存      
      query.setCacheable(true);   
      for (Iterator<String> it = query.iterate(); it.hasNext();) \{   
        String name = it.next();   
        System.out.println(name);   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
       
    System.out.println("================================");   
       
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s.name from Student s");   
      //启用查询缓存      
      query.setCacheable(true);   
      //会发出查询语句,因为query.iterate不使用查询缓存   
      for (Iterator<String> it = query.iterate(); it.hasNext();) \{   
        String name = it.next();   
        System.out.println(name);   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
  \}\*/   
      
/\*    @SuppressWarnings("unchecked")   
  public static void main(String\[\] args) \{   
    Session session = null;   
    Transaction t = null;   
  
    \*//\*\*   
     \* 关闭查询缓存,关闭二级缓存, 开启两个session,分别调用query.list查询实体对象   
     \*//\*   
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况.   
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s from Student s");   
      //启用查询缓存      
      //query.setCacheable(true);   
      List<Student> students = query.list();   
      for (Iterator<Student> it = students.iterator(); it.hasNext();) \{   
        Student s = it.next();   
        System.out.println(s.getName());   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
       
    System.out.println("================================");   
       
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s from Student s");   
      //启用查询缓存      
      //query.setCacheable(true);   
      //会发出查询语句,因为list默认每次都会发出sql语句   
      List<Student> students = query.list();   
      for (Iterator<Student> it = students.iterator(); it.hasNext();) \{   
        Student s = it.next();   
        System.out.println(s.getName());   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
  \}\*/   
      
/\*  @SuppressWarnings("unchecked")   
  public static void main(String\[\] args) \{   
    Session session = null;   
    Transaction t = null;   
  
    \*//\*\*   
     \* 开启查询缓存,关闭二级缓存, 开启两个session,分别调用query.list查询实体对象   
     \*//\*   
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况.   
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s from Student s");   
      //启用查询缓存      
      query.setCacheable(true);   
      List<Student> students = query.list();   
      for (Iterator<Student> it = students.iterator(); it.hasNext();) \{   
        Student s = it.next();   
        System.out.println(s.getName());   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
       
    System.out.println("================================");   
       
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s from Student s");   
      //启用查询缓存      
      query.setCacheable(true);   
      //会发出根据id查询实体的n条查询语句,因为这种情况下,查询过程是这样的：   
      // 在第一次执行list时,会把查询对象的id缓存到查询缓存里   
      // 第二次执行list时, 会遍历查询缓存里的id到缓存里去找实体对象,由于这里没找到实体对象,   
      //所以就发出n条查询语句到数据库中查询.   
      List<Student> students = query.list();   
      for (Iterator<Student> it = students.iterator(); it.hasNext();) \{   
        Student s = it.next();   
        System.out.println(s.getName());   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
  \}\*/   
      
  @SuppressWarnings("unchecked")   
  public static void main(String\[\] args) \{   
    Session session = null;   
    Transaction t = null;   
  
    /\*\*   
     \* 开启查询缓存,开启二级缓存, 开启两个session,分别调用query.list查询实体对象   
     \*/   
    //如果不用查询缓存的话,那两个都发出查询语句,这也是默认的情况.   
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s from Student s");   
      //启用查询缓存      
      query.setCacheable(true);   
      List<Student> students = query.list();   
      for (Iterator<Student> it = students.iterator(); it.hasNext();) \{   
        Student s = it.next();   
        System.out.println(s.getName());   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
       
    System.out.println("================================");   
       
    try \{   
      session = HibernateUtils.getSession();   
      t = session.beginTransaction();   
      Query query = session.createQuery("select s from Student s");   
      //启用查询缓存      
      query.setCacheable(true);   
      //不会发出查询语句,因为这种情况下,查询过程是这样的：   
      // 在第一次执行list时,会把查询对象的id缓存到查询缓存里   
      // 第二次执行list时, 会遍历查询缓存里的id到缓存里去找实体对象,由于这里开启了二级缓存,可以找到目标实体对象,   
      //所以就不会再发出n条查询语句.   
      List<Student> students = query.list();   
      for (Iterator<Student> it = students.iterator(); it.hasNext();) \{   
        Student s = it.next();   
        System.out.println(s.getName());   
      \}   
      t.commit();   
    \} catch (Exception e) \{   
      e.printStackTrace();   
      t.rollback();   
    \} finally \{   
      HibernateUtils.closeSession(session);   
    \}   
  \}