ehcache

1、缓存：缓存是什么，解决什么问题？

位于速度相差较大的两种硬件/软件之间的，用于协调两者数据传输速度差异的结构，均可称之为 Cache。目的：让数据更接近于应用程序，协调速度不匹配，使访问速度更快

    高速缓存就是性能调优，不属于Hibernate等，属于独立产品或框架，可单独使用。

    常见缓存算法：

a)         LFU（Least Frequently Used）：最近不常被使用（命中率低），一定时间段内使用次数最少的

b)        LRU（Least Recently Used）：最近很少使用（LinkedHashMap），没有被使用时间最长的

c)        FIFO（First In First Out）：先进先出

2、缓存策略

1．对象缓存

2．查询缓存

3．页面缓存

1．动态页面缓存

2．Servlet缓存

3．页面片段缓存

3、缓存分类

1. Web缓存：
   1.                          i.              浏览器缓存：ajax（在客户端缓存）、HTTP协议
   2.                        ii.              代理服务器缓存
2. 操作系统缓存：如用于减少磁盘操作
3. 数据库缓存：
   1.                          i.              结果缓存：
   2.                        ii.              排序缓存
   3.                       iii.              插入缓存
   4.                      iv.              日志缓存
   5.                        v.              ………………
4. 应用程序缓存
   1.                          i.              对象缓存
   2.                        ii.              查询缓存
   3.                       iii.              页面缓存
      1. 动态页面静态化：网页静态化、独立图片服务器
      2. 页面局部缓存：
      3. 请求回应缓存：

4、常见Java缓存框架

• EHCache
• OSCache
• JBossCache
• SwarmCache
• Memcached：在大规模互联网应用下使用，可用于分布式环境，每秒支撑1.5万～2万次请求
• Tokyo Tyrant：兼容memcached协议，可以持久化存储，支持故障切换，对缓存服务器有高可靠性要求可以使用，每秒支撑0.5万～0.8万次请求
• Mongodb：nosql文档数据库，类似于缓存但持久化，适用于海量存储，读多写少。

5、通用缓存产品

 

6、基于Web应用的缓存应用场景：

 

7、Web应用系统存在哪些速度差异？

• 读文件系统      ->  读硬盘
• 读数据库内存    ->  读文件系统
• 读应用内存      ->  访问数据库服务器
• 读静态文件      ->  访问应用服务器
• 读浏览器缓存    ->  访问网站

 

   

8、缓存实战：

8.1、Web缓存

8.1.1、ajax缓存

8.1.2、HTTP协议

8.2、数据库缓存：

8.2.1、结果缓存

8.2.2、排序缓存

8.2.3、插入缓存

8.2.4、日志缓存

8.2.5、………………

8.3、应用程序缓存

8.3.1、对象缓存

8.3.2、查询缓存

8.3.3、页面缓存

8.3.3.1、动态页面静态化：网页静态化、独立图片服务器

8.3.3.2、页面局部缓存

8.3.3.3、请求回应缓存

8.4、ORM缓存

8.4.1、目的：

Hibernate缓存：使当前数据库状态的表示接近应用程序，要么在内存中，要么在应用程序服务器机器的磁盘上。高速缓存是数据的一个本地副本，处于应用程序和数据库之间，可用来避免数据库的命中。

8.4.2、避免数据库命中：

应用程序根据标识符到缓存查，有就返回，没有再去数据库.

8.4.3、ORM缓存分类

一级缓存、二级缓存

8.4.4、缓存范围

1、事务范围高速缓存，对应于一级缓存（单Session）

        2、过程（JVM）范围高速缓存，对应于二级缓存（单SessionFactory）

           3、集群范围高速缓存，对应于二级缓存（多SessionFactory）

8.4.5、缓存哪些数据

              1、很少改变的数据；

2、不重要的数据，如论坛帖子，无需实时的数据（站内信、邮件（如每隔15秒更新一次））；

              3、应用程序固有的而非共享的。

              4、读大于写有用

8.4.6、Hibernate缓存架构

   

 

• Hibernate中的二级缓存是可插拔的。
• Hibernate二级缓存支持对象缓存、集合缓存、查询结果集缓存，对于查询结果集缓存可选。
• 查询缓存：需要两个额外的物理高速缓存区域：一个用于存放查询的结果集；另一个用于存储表上次更新的时间戳

8.4.6.1、Hibernate二级缓存

  1、高速缓存策略和高速缓存提供程序

2、高速缓存策略

2.1、二级高速缓存是否启用

        2.2、高速缓存过期策略(LRU、LFU、FIFO)

        2.3、高速缓存的物理格式(内存、文件、集群)

2.4、并发策略

3、内建的并发策略

3.1、只读缓存：适用于从不改变的数据，只用于引用数据。如果你的应用程序只需读取一个持久化类的实例，而无需对其修改， 那么就可以对其进行只读缓存。这是最简单，也是实用性最好的方法。甚至在集群中，它也能完美地运作。

Ehcache：缓存那些只读的数据。

如果要修改一个只读缓存的数据，抛出Can't write to a readonly object。但允许新增。

 

3.2、读/写缓存：利用时间戳机制，维护读取提交隔离，并且只在非集群环境中可用。还是给主要用于读取的数据使用这种策略，因为在这种数据中防止并发事务中的废弃数据最为关键，极少情况用于更新。（内部通过锁保证顺序）

如果应用程序需要更新数据，那么使用读/写缓存 比较合适。 如果应用程序要求“序列化事务”的隔离级别（serializable transaction isolation level），那么就决不能使用这种缓存策略。 如果在JTA环境中使用缓存，你必须指定hibernate.transaction.manager_lookup_class属性的值， 通过它，Hibernate才能知道该应用程序中JTA的TransactionManager的具体策略。 在其它环境中，你必须保证在Session.close()、或Session.disconnect()调用前， 整个事务已经结束。 如果你想在集群环境中使用此策略，你必须保证底层的缓存实现支持锁定(locking)。Hibernate内置的缓存策略并不支持锁定功能。

Ehcache：缓存那些有时候更新的数据，维护读取提交隔离语义。如果数据库是可重复读取隔离级别，该并发策略也能维护这个语义。可重复读取隔离级别是并发更新的折中解决方案。内部通过锁实现，可能发生线程堵塞。一个异步的并发策略

 

    3.3、非严格读/写缓存：不提供高速缓存和数据库之间的一致性保证。如果有可能并发访问相同的实体，你应该配置一个足够短的超时时限。否则，则可能从高速缓存中读取废弃的数据。如果数据几乎不变（几小时、几天），并且废弃的数据不可能是关键的关注点，那就使用这种策略。（内部不通过锁保证顺序），

如果应用程序只偶尔需要更新数据（也就是说，两个事务同时更新同一记录的情况很不常见），也不需要十分严格的事务隔离， 那么比较适合使用非严格读/写缓存策略。如果在JTA环境中使用该策略， 你必须为其指定hibernate.transaction.manager_lookup_class属性的值， 在其它环境中，你必须保证在Session.close()、或Session.disconnect()调用前， 整个事务已经结束。

Ehcache：缓存那些有时候更新的数据，内部将不通过锁实现，如果并发访问一个条目不保证返回数据库中最新版本的数据，因此请配置超时时间。只依赖于缓存过期（超时）。一个异步的并发策略

 

    3.4、事务缓存：只可用于托管环境，如有必要，它还保证完全的事务隔离级别直到可重复读。给主要用于读取的数据使用这种策略，因为在这种数据中防止并发事务中的废弃数据最为关键，极少情况用于更新。

Hibernate的事务缓存策略提供了全事务的缓存支持， 例如对JBoss TreeCache的支持。这样的缓存只能用于JTA环境中，你必须指定 为其hibernate.transaction.manager_lookup_class属性。

一个异步的并发策略，需要底层支持。

 

 

4、选择高速缓存提供程序

 

 

8.4.6.2、高速缓存实战(ehcache)

8.4.6.2.1、全局配置(hibernate.cfg.xml)

<!-- 开启二级缓存 --> <property name="hibernate.cache.use_second_level_cache">true</property> <!-- 开启查询缓存 --> <property name="hibernate.cache.use_query_cache">true</property> <!-- 二级缓存区域名的前缀 --> <!--<property name="hibernate.cache.region_prefix">h3test</property>--> <!-- 高速缓存提供程序 --> <property name="hibernate.cache.region.factory_class"> net.sf.ehcache.hibernate.EhCacheRegionFactory </property> <!-- 指定缓存配置文件位置 --> <property name="hibernate.cache.provider_configuration_file_resource_path"> ehcache.xml </property> <!-- 强制Hibernate以更人性化的格式将数据存入二级缓存 --> <property name="hibernate.cache.use_structured_entries">true</property>   <!-- Hibernate将收集有助于性能调节的统计数据 --> <property name="hibernate.generate_statistics">true</property>

 

 

 

 

8.4.6.2.2、ehcache配置（ehcache.xml）

<?xml version="1.0" encoding="UTF-8"?> <ehcache name="h3test">    <defaultCache       maxElementsInMemory="100"       eternal="false"       timeToIdleSeconds="1200"       timeToLiveSeconds="1200"       overflowToDisk="false">     </defaultCache> </ehcache>

 

 

 

 

8.4.6.2.3、实体只读缓存

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并只读

<hibernate-mapping>     <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">         <cache usage="read-only"/>     …… </hibernate-mapping>

 

 

2、测试代码

public static void readonlyTest() {       SessionFactory sf = new Configuration().configure().buildSessionFactory();               Session session1 = sf.openSession();       Transaction t1 = session1.beginTransaction();       //确保数据库中有标识符为1的FarmModel       FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);       //如果修改将报错，只读缓存不允许修改       //farm.setName("aaa");       t1.commit();      session1.close();                       Session session2 = sf.openSession();       Transaction t2 = session2.beginTransaction();               farm = (FarmModel) session2.get(FarmModel.class, 1);               t2.commit();       session2.close();       sf.close(); }

 

 

 

• 只读缓存不允许更新，将报错Can't write to a readonly object。
• 允许新增，新增记录不自动加到二级缓存中，需要再查询一次。

8.4.6.2.4、实体非严格读/写缓存

 

 

 

 

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并非严格读/写

<hibernate-mapping>     <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">         <cache usage="nonstrict-read-write"/>     …… </hibernate-mapping>

 

 

 

2、测试代码

public static void nonstrictReadWriteTest () {       SessionFactory sf = new Configuration().configure().buildSessionFactory();               Session session1 = sf.openSession();       Transaction t1 = session1.beginTransaction();       //确保数据库中有标识符为1的FarmModel       FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);       t1.commit();      session1.close();                       Session session2 = sf.openSession();       Transaction t2 = session2.beginTransaction();               farm = (FarmModel) session2.get(FarmModel.class, 1);               t2.commit();       session2.close();       sf.close(); }

 

• 允许更新，更新后缓存失效，需再查询一次。
• 允许新增，新增记录自动加到二级缓存中。
• 整个过程不加锁，不保证。

 

 

8.4.6.2.5、实体读/写缓存

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并读/写

<hibernate-mapping>     <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">         <cache usage="read-write"/>     …… </hibernate-mapping>

 

 

 

2、测试代码

public static void readWriteTest() {     SessionFactory sf = new Configuration().configure().buildSessionFactory();             Session session1 = sf.openSession();     Transaction t1 = session1.beginTransaction();     //确保数据库中有标识符为1的FarmModel     FarmModel farm = (FarmModel) session1.get(FarmModel.class, 1);     farm.setName("as");     t1.commit();     session1.close();                 Session session2 = sf.openSession();     Transaction t2 = session2.beginTransaction();     farm = (FarmModel) session2.get(FarmModel.class, 1);     t2.commit();     session2.close();     sf.close(); }

 

• 允许更新，更新后自动同步到缓存。
• 允许新增，新增记录后自动同步到缓存。
• 保证read committed隔离级别及可重复读隔离级别（通过时间戳实现）
• 整个过程加锁，如果当前事务的时间戳早于二级缓存中的条目的时间戳，说明该条目已经被别的事务修改了，此时重新查询一次数据库，否则才使用缓存数据，因此保证可重复读隔离级别。

8.4.6.2.6、实体事务缓存

需要特定缓存的支持和JTA事务支持，此处不演示。

 

8.4.6.2.7、集合缓存

此处演示读/写缓存示例，其他自测

1、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并读/写

<hibernate-mapping>     <class name="cn.javass.h3test.model.UserModel" table="TBL_USER">         <cache usage="read-write" />         <set name="farms" cascade="all" inverse="true" lazy="false">             <cache usage="read-write"/>             <key column="fk_user_id"/>             <one-to-many class="cn.javass.h3test.model.FarmModel"/>         </set>     </class> </hibernate-mapping>

 

 

2、测试代码

public static void collectionReadWriteTest() { SessionFactory sf = new Configuration().configure().buildSessionFactory();             Session session1 = sf.openSession();     Transaction t1 = session1.beginTransaction();     //确保数据库中有标识符为118的UserModel     UserModel user = (UserModel) session1.get(UserModel.class, 118);     user.getFarms();     t1.commit();     session1.close();             Session session2 = sf.openSession();     Transaction t2 = session2.beginTransaction();     user = (UserModel) session2.get(UserModel.class, 118);     user.getFarms();     t2.commit();     session2.close();     sf.close(); }

 

• 和实体并发策略有相同含义；
• 但集合缓存只缓存集合元素的标识符，在二级缓存中只存放相应实体的标识符，然后再通过标识符去二级缓存查找相应的实体最后组合为集合返回。

 

8.4.6.2.8、查询缓存

1、保证全局配置中有开启了查询缓存。

2、修改FarmModel.hbm.xml,添加如下红色部分配置，表示实体缓存并读/写

<hibernate-mapping>     <class name="cn.javass.h3test.model.FarmModel" table="TBL_FARM">         <cache usage="read-write"/>     …… </hibernate-mapping>

 

 

3、测试代码

public static void queryCacheTest() { SessionFactory sf = new Configuration().configure().buildSessionFactory();      Session session1 = sf.openSession();     Transaction t1 = session1.beginTransaction();     Query query = session1.createQuery("from FarmModel");     //即使全局打开了查询缓存，此处也是必须的     query.setCacheable(true);     List<FarmModel> farmList = query.list();     t1.commit();     session1.close();         Session session2 = sf.openSession();     Transaction t2 = session2.beginTransaction();     query = session2.createQuery("from FarmModel");     //即使全局打开了查询缓存，此处也是必须的     query.setCacheable(true);     farmList = query.list();     t2.commit();     session2.close();         sf.close(); }

 

 

 

• 和实体并发策略有相同含义；
• 和集合缓存类似，只缓存集合元素的标识符，在二级缓存中只存放相应实体的标识符，然后再通过标识符去二级缓存查找相应的实体最后组合为集合返回。

 

 

8.4.6.2.9、高速缓存区域

Hibernate在不同的高速缓存区域保存不同的类（实体）/集合，如果不配置区域默认都保存到“默认缓存”（defaultCache）中。

  每一个区域可以设置过期策略、缓存条目大小等等。

  对于类缓存，默认区域名是全限定类名，如cn.javass.h3test.model.UserModel。

  对于集合而言，默认区域名是全限定类名+属性名，如cn.javass.….UserModel.farms。

  可通过hibernate.cache.region_prefix指定特定SessionFactory的区域前缀，如前缀是h3test，则如类缓存的区域名就是h3test. cn.javass.h3test.model.UserModel。如果应用程序使用多个SessionFactory 这可能是必须的。

 

    可通过<cache usage="read-write" region="区域名"/>自定义区域名，不过默认其实就可以了。

 

8.4.6.2.10、ehcache配置详解：

1、默认cache：如果没有对应的特定区域的缓存，就使用默认缓存。

	<defaultCache       maxElementsInMemory="100"       eternal="false"       timeToIdleSeconds="1200"       timeToLiveSeconds="1200"       overflowToDisk="false">     </defaultCache>

 

 

 

 

 

 

 

 

 

 

 

	2、指定区域cache：通过name指定，name对应到Hibernate中的区域名即可。    <cache name="cn.javass.h3test.model.UserModel"       maxElementsInMemory="100"       eternal="false"       timeToIdleSeconds="1200"       timeToLiveSeconds="1200"       overflowToDisk="false">     </cache>

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

3、cache参数详解：

• name:指定区域名
  • maxElementsInMemory ：缓存在内存中的最大数目
  • maxElementsOnDisk：缓存在磁盘上的最大数目

§           eternal ：缓存是否持久

§           overflowToDisk ： 硬盘溢出数目

§           timeToIdleSeconds ：当缓存条目闲置n秒后销毁

§           timeToLiveSeconds ：当缓存条目存活n秒后销毁

§           memoryStoreEvictionPolicy:缓存算法，有LRU（默认）、LFU、FIFO

4、StandardQueryCache

        用于查询缓存使用，如果指定了该缓存，那么查询缓存将放在该缓存中。

	<cache     name="org.hibernate.cache.StandardQueryCache"     maxElementsInMemory="5"     eternal="false"     timeToLiveSeconds="120" overflowToDisk="true"/>

 

如果不给查询设置区域名默认缓存到这，可以通过“query.setCacheRegion("区域名");”来设置查询的区域名。

 

5、UpdateTimestampsCache

    时间戳缓存，内部使用，用于保存最近更新的表的时间戳，这是非常重要的，无需失效，关闭时间戳缓存区域的过期时间。

<cache     name="org.hibernate.cache.UpdateTimestampsCache"     maxElementsInMemory="5000"     eternal="true"     overflowToDisk="true"/>

 

 

 

    Hibernate使用时间戳区域来决定被高速缓存的查询结果集是否是失效的。当你重新执行了一个启用了高速缓存的查询时，Hibernate就在时间戳缓存中查找对被查询的（几张）表所做的最近插入、更新或删除的时间戳。如果找到的时间戳晚于高速缓存查询结果的时间戳，那么缓存结果将被丢弃，重新执行一次查询。

 

8.4.6.2.11、什么时候需要查询缓存

  大多数时候无法从结果集高速缓存获益。必须知道:每隔多久重复执行同一查询。

  对于那些查询非常多但插入、删除、更新非常少的应用程序来说，查询缓存可提升性能。但写入到查询少的没有用，总失效。

 

8.4.6.2.12、管理一级缓存

无论何时，当你给save()、update()或 saveOrUpdate()方法传递一个对象时，或使用load()、 get()、list()、iterate() 或scroll()方法获得一个对象时, 该对象都将被加入到Session的内部缓存中。

当随后flush()方法被调用时，对象的状态会和数据库取得同步。 如果你不希望此同步操作发生，或者你正处理大量对象、需要对有效管理内存时，你可以调用evict() 方法，从一级缓存中去掉这些对象及其集合。

ScrollableResult cats = sess.createQuery("from Cat as cat").scroll(); //a huge result set

while ( cats.next() ) {

    Cat cat = (Cat) cats.get(0);

    doSomethingWithACat(cat);

    sess.evict(cat);

}

Session还提供了一个contains()方法，用来判断某个实例是否处于当前session的缓存中。

如若要把所有的对象从session缓存中彻底清除，则需要调用Session.clear()。

 

CacheMode参数用于控制具体的Session如何与二级缓存进行交互。

CacheMode.NORMAL - 从二级缓存中读、写数据。

CacheMode.GET - 从二级缓存中读取数据，仅在数据更新时对二级缓存写数据。

CacheMode.PUT - 仅向二级缓存写数据，但不从二级缓存中读数据。

CacheMode.REFRESH - 仅向二级缓存写数据，但不从二级缓存中读数据。通过 hibernate.cache.use_minimal_puts的设置，强制二级缓存从数据库中读取数据，刷新缓存内容。

 

8.4.6.2.12、管理二级缓存

对于二级缓存来说，在SessionFactory中定义了许多方法， 清除缓存中实例、整个类、集合实例或者整个集合。

sessionFactory.evict(Cat.class, catId); //evict a particular Cat

sessionFactory.evict(Cat.class);  //evict all Cats

sessionFactory.evictCollection("Cat.kittens", catId); //evict a particular collection of kittens

sessionFactory.evictCollection("Cat.kittens"); //evict all kitten collections

sessionFactory.evictQueries()//evict all queries

8.4.6.2.13、监控二级缓存

如若需要查看二级缓存或查询缓存区域的内容，你可以使用统计（Statistics） API。

通过sessionFactory.getStatistics()；获取Hibernate统计信息。

此时，你必须手工打开统计选项。

hibernate.generate_statistics true

hibernate.cache.use_structured_entries true

 

 

注：部分缓存概念摘自Javaeye Robbin Fan。