hibernate缓存

session的产生方式：<br> 

1.sessionFactory.openSession();

private SessionImpl openSession(Connection connection,                                                          

                                boolean   autoClose, 
                                long timestamp, 
                           Interceptor
                              sessionLocalInterceptor)
 { return new SessionImpl( connection,
                           this, 
                           autoClose, 
                           timestamp,                
                           sessionLocalInterceptor == null ? interceptor : sessionLocalInterceptor,   
                           settings.getDefaultEntityMode(), settings.isFlushBeforeCompletionEnabled(), 
                           settings.isAutoCloseSessionEnabled(), settings.getConnectionReleaseMode()); 

每次运行都产生一个新的session;

2.sessionFactory.getCurrentSession()--> 配置文件要加上 thread

          sessionFactory.getCurrentSession会查看当前线程是否存在session,如果存在，从当前线程把session取出，如果不存在，新建一个session 并把session放入threadlocal中供用户使用。

3.一级缓存（session缓存）

                    3.1、生命周期就是session的生命周期

                    3.2、一级缓存存放的数据都是私有数据 把session存放在threadlocal中，不同的线程是不能访问的，所以保证了数据的安全性

                    3.3、怎么样把数据存放到一级缓存中 利用session.save/update/load/get方法都可以存放在一级缓存中

                    3.4、利用session.get/load方法可以把数据从一级缓存中取出

                    3.5、session.evict方法可以把一个对象从一级缓存中清空

                    3.6、利用session.clear方法可以把session中的所有的数据清空

                    3.7、利用session.Refresh方法把数据库中的数据同步到缓存中

                    3.8、session.flush 在session的缓存内部，会去检查所有的持久化对象

                                   3.8.1、如果一个持久化对象没有ID值，则会发出insert语句

                                   3.8.2、如果一个持久化对象有ID值，则会去检查快照进行对比， 如果一样，则什么都不做，如果不一样，则发出update语句

                                   3.8.3、检查所有的持久化对象是否有关联对象 检查关联对象的级联操作 检查关联对象的关系操作

4. iterator查询对象存在一级缓存

 publicvoid quaryIterator() {

         Session session=sessionFactory.openSession();
         //发出sql语句 
         Iterator iter= session.createQuery("from Student s where s.sid<5").iterate();
         //这里不会清除缓存，因为iterator采用的是load()加载 
         //session.clear();
         while(iter.hasNext()){ 
            Student s=iter.next(); 
            System.out.println(s); 
         }
         //清除缓存数据 
         //session.clear(); 
         //如果不清除缓存则不会发出sql语句 
         iter= session.createQuery("from Student s where s.sid<5").iterate();
         while(iter.hasNext()){ 
           Student s=iter.next();
           System.out.println(s); 
         } 
         session.close();
 }

 

list查询也存在一级缓存，只是list采用get()加载 list和iterator查询普通属性不存在session缓存（之存储实体对象）

运行结果：
Hibernate: select student0_.sname as col_0_0_ from Student student0_ where student0_.sid<5 Hibernate: select student0_.sname as col_0_0_ from Student student0_ where student0_.sid<5
学生一
学生二
学生三
学生三四
Hibernate: select student0_.sname as col_0_0_ from Student student0_ where student0_.sid<5 Hibernate: select student0_.sname as col_0_0_ from Student student0_ where student0_.sid<5
学生一
学生二
学生三
学生三四

 

二级缓存：

         1、适用场合：

                       1、数据不能频繁更新

                       2、数据能公开，私密性不是很强

         2、hibernate本身并没有提供二级缓存的解决方案

         3、二级缓存的实现是依赖于第三方供应商完成的

                     ehcache

                     oscache

                     jbosscache

                     swamchache

        4、二级缓存的操作

                       1、二级缓存存在sessionFactory中

                       2、生命周期：与sessionFactory保持一致

                       3、使用二级缓存的步骤       

                               1、在hibernate.cfg.xml

                               <property name="cache.use_second_level_cache">true</property>

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

             2、让某一个对象进入到二级缓存中

                 * 在配置文件中

                   <class-cache usage="read-only" class="cn.itcast.hiberate.sh.domain.Classes"/>

                 *  在映射文件中

                    <cache usage="read-only"/>

             3、使用

                  session.get/session.load

                                    

 public void second_cache_Get(){

        Session session = sessionFactory.openSession(); 
        Classes classes = (Classes)session.get(Classes.class, 1L); 
        session.close(); 
        session = sessionFactory.openSession(); 
        //这里不会发出sql语句，直接从二级缓存里查找 
        classes = (Classes)session.get(Classes.class, 1L); 
        session.close();

}

  运行结果：

 Hibernate: select classes0_.cid as cid0_0_, classes0_.cname as cname0_0_, classes0_.description as descript3_0_0_ from Classes classes0_ where classes0_.cid=? 

 

load()存在二级缓存

public void second_cache_Load(){ 
          Session session=sessionFactory.openSession(); 
          Classes classes=(Classes)session.load(Classes.class, 1L);
          classes.getCname(); 
          session.close(); 
          session=sessionFactory.openSession();
          //这里不会发出sql语句，从缓存里查找 
         classes=(Classes)session.load(Classes.class, 1L); classes.getCid(); 

} 

 iterator和list查找对象时存在二级缓存

iterator和List查询普通属性时不存在二级缓存

一级和和二级缓存只存储实体对象 

 public void second_cache_Iterator(){ 

         Session session=sessionFactory.openSession(); 
         Iterator iter=session.createQuery("select c.cname from Classes c where c.cid<5").iterate(); 
         while(iter.hasNext()){ 
             String name=iter.next(); 
             System.out.println(name); 
         }
         session.close();
         session=sessionFactory.openSession(); 
         //这里依然会发出sql语句说明不存在二级缓存 
         iter=session.createQuery("select c.cname from Classes c where c.cid<5").iterate(); 
         while(iter.hasNext()){ 
               String classes=iter.next(); 
               System.out.println(classes); 
         } 
         session.close(); 
} 

运行结果：
Hibernate: select classes0_.cname as col_0_0_ from Classes classes0_ where classes0_.cid<5
西社小学 
西社小学 
西社初中 
西社初中 
Hibernate: select classes0_.cname as col_0_0_ from Classes classes0_ where classes0_.cid<5 
西社小学 
西社小学 
西社初中 
西社初中