一级缓存和二级缓存--mybatis|hibernate

一级缓存和二级缓存的区别：

主要的不同是它们的作用范围不同。

一级缓存是session级别的。

也就是只有在同一个session里缓存才起作用，当这个session关闭后这个缓存就不存在了。

而二级缓存是sessionFactory级别的。

其缓存对同一个sessionFactory生产出来的session都有效，二级缓存我们通常使用其他的一些开源组件，比如hibernate经常使用的就是ECache，这个缓存在整个应用服务器中都会有效的。

首先要明白缓存是干什么的，缓存就是要将一些经常使用的数据缓存到内存或者各种储存介质中，当再次使用时可以不用去数据库中查询，减少与数据库的交互，提高性能。

再说明一级与二级缓存的作用：一级缓存是Session级别的，也就是说在一个事务中才会启作用。比如在一个事务中同时查询同一个对象，则不会两次去数据库中查询。

而二级缓存是sessionFactory级别的，不同的事务之间是可以共享的，有些权限，当用户首次登陆后便将关联的权限放到二级缓存中，这样每次需要权限时就无需再查询数据库了。

最后再说明为什么这样设计：一般情况下，我们查询的数据一般是实时的，使用二级缓存肯定不行，使用一级缓存既利用了缓存又不会影响实时。

使用二级缓存是为了存储一些比较稳定的数据，如权限，只有在用户修改了权限且重新登录时才能生效

cpu中的一级缓存和二级缓存和三级缓存

一级缓存是什么：

一级缓存都内置在CPU内部并与CPU同速运行，可以有效的提高CPU的运行效率。一级缓存越大，CPU的运行效率越高，但受到CPU内部结构的限制，一级缓存的容量都很小。

CPU缓存（Cache Memory）是位于CPU与内存之间的临时存储器，它的容量比内存小的多但是交换速度却比内存要快得多。缓存的出现主要是为了解决CPU运算速度与内存读写速度不匹配的矛盾，因为CPU运算速度要比内存读写速度快很多，这样会使CPU花费很长时间等待数据到来或把数据写入内存。在缓存中的数据是内存中的一小部分，但这一小部分是短时间内CPU即将访问的，当CPU调用大量数据时，就可避开内存直接从缓存中调用，从而加快读取速度。由此可见，在CPU中加入缓存是一种高效的解决方案，这样整个内存储器（缓存+内存）就变成了既有缓存的高速度，又有内存的大容量的存储系统了。缓存对CPU的性能影响很大，主要是因为CPU的数据交换顺序和CPU与缓存间的带宽引起的。

分类

一级缓存可以分为一级数据缓存（Data Cache，D-Cache）和一级指令缓存（InstrucTIon Cache，I-Cache）。二者分别用来存放数据以及对执行这些数据的指令进行即时解码，而且两者可以同时被CPU访问，减少了争用Cache所造成的冲突，提高了处理器效能。目前大多数CPU的一级数据缓存和一级指令缓存具有相同的容量，例如AMD的Athlon XP就具有64KB的一级数据缓存和64KB的一级指令缓存，其一级缓存就以64KB+64KB来表示，其余的CPU的一级缓存表示方法以此类推。

二级缓存是什么：

CPU缓存（Cache Memory）位于CPU与内存之间的临时存储器，它的容量比内存小但交换速度快。在缓存中的数据是内存中的一小部分，但这一小部分是短时间内CPU即将访问的，当CPU调用大量数据时，就可避开内存直接从缓存中调用，从而加快读取速度。最初缓存只有一级，二级缓存（L2 CACHE）出现是为了协调一级缓存与内存之间的速度。二级缓存比一级缓存速度更慢，容量更大，主要就是做一级缓存和内存之间数据临时交换的地方用。实际上，现在Intel和AMD处理器在一级缓存的逻辑结构设计上有所不同，所以二级缓存对CPU性能的影响也不尽相同。

工作原理

缓存的工作原理是当CPU要读取一个数据时，首先从缓存中查找，如果找到就立即读取并送给CPU处理;如果没有找到，就用相对慢的速度从内存中读取并送给CPU处理，同时把这个数据所在的数据块调入缓存中，可以使得以后对整块数据的读取都从缓存中进行，不必再调用内存。

三级缓存是什么：

三级缓存是为读取二级缓存后未命中的数据设计的—种缓存，在拥有三级缓存的CPU中，只有约5%的数据需要从内存中调用，这进一步提高了CPU的效率。其运作原理在于使用较快速的储存装置保留一份从慢速储存装置中所读取数据且进行拷贝，当有需要再从较慢的储存体中读写数据时，缓存（cache）能够使得读写的动作先在快速的装置上完成，如此会使系统的响应较为快速。

注意：只有一级缓存是在CPU中的，一级缓存的读取需要2-4个时钟周期；二级缓存的读取需要10个左右的时钟周期；而三级缓存需要30-40个时钟周期，但是容量一次增大。

内存与缓存的区别

CPU缓存（Cache Memoney）位于CPU与内存之间的临时存储器，它的容量比内存小但交换速度快。在缓存中的数据是内存中的一小部分，但这一小部分是短时间内CPU即将访问的，当CPU调用大量数据时，就可避开内存直接从缓存中调用，从而加快读取速度。由此可见，在CPU中加入缓存是一种高效的解决方案，这样整个内存储器（缓存+内存）就变成了既有缓存的高速度，又有内存的大容量的存储系统了。缓存对CPU的性能影响很大，主要是因为CPU的数据交换顺序和CPU与缓存间的带宽引起的。

缓存的工作原理是当CPU要读取一个数据时，首先从缓存中查找，如果找到就立即读取并送给CPU处理；如果没有找到，就用相对慢的速度从内存中读取并送给CPU处理，同时把这个数据所在的数据块调入缓存中，可以使得以后对整块数据的读取都从缓存中进行，不必再调用内存。

正是这样的读取机制使CPU读取缓存的命中率非常高（大多数CPU可达90%左右），也就是说CPU下一次要读取的数据90%都在缓存中，只有大约10%需要从内存读取。这大大节省了CPU直接读取内存的时间，也使CPU读取数据时基本无需等待。总的来说，CPU读取数据的顺序是先缓存后内存。

最早先的CPU缓存是个整体的，而且容量很低，英特尔公司从Pentium时代开始把缓存进行了分类。当时集成在CPU内核中的缓存已不足以满足CPU的需求，而制造工艺上的限制又不能大幅度提高缓存的容量。因此出现了集成在与CPU同一块电路板上或主板上的缓存，此时就把 CPU内核集成的缓存称为一级缓存，而外部的称为二级缓存。一级缓存中还分数据缓存（Data Cache，D-Cache）和指令缓存（Instruction Cache，I-Cache）。二者分别用来存放数据和执行这些数据的指令，而且两者可以同时被CPU访问，减少了争用Cache所造成的冲突，提高了处理器效能。英特尔公司在推出Pentium 4处理器时，还新增了一种一级追踪缓存，容量为12KB.

随着CPU制造工艺的发展，二级缓存也能轻易的集成在CPU内核中，容量也在逐年提升。现在再用集成在CPU内部与否来定义一、二级缓存，已不确切。而且随着二级缓存被集成入CPU内核中，以往二级缓存与CPU大差距分频的情况也被改变，此时其以相同于主频的速度工作，可以为CPU提供更高的传输速度。

二级缓存是CPU性能表现的关键之一，在CPU核心不变化的情况下，增加二级缓存容量能使性能大幅度提高。而同一核心的CPU高低端之分往往也是在二级缓存上有差异，由此可见二级缓存对于CPU的重要性。

CPU在缓存中找到有用的数据被称为命中，当缓存中没有CPU所需的数据时（这时称为未命中），CPU才访问内存。从理论上讲，在一颗拥有二级缓存的CPU中，读取一级缓存的命中率为80%。也就是说CPU一级缓存中找到的有用数据占数据总量的80%，剩下的20%从二级缓存中读取。由于不能准确预测将要执行的数据，读取二级缓存的命中率也在80%左右（从二级缓存读到有用的数据占总数据的16%）。那么还有的数据就不得不从内存调用，但这已经是一个相当小的比例了。目前的较高端的CPU中，还会带有三级缓存，它是为读取二级缓存后未命中的数据设计的—种缓存，在拥有三级缓存的CPU中，只有约5%的数据需要从内存中调用，这进一步提高了CPU的效率。

为了保证CPU访问时有较高的命中率，缓存中的内容应该按一定的算法替换。一种较常用的算法是“最近最少使用算法”（LRU算法），它是将最近一段时间内最少被访问过的行淘汰出局。因此需要为每行设置一个计数器，LRU算法是把命中行的计数器清零，其他各行计数器加1。当需要替换时淘汰行计数器计数值最大的数据行出局。这是一种高效、科学的算法，其计数器清零过程可以把一些频繁调用后再不需要的数据淘汰出缓存，提高缓存的利用率。

CPU产品中，一级缓存的容量基本在4KB到64KB之间，二级缓存的容量则分为128KB、256KB、512KB、1MB、2MB等。一级缓存容量各产品之间相差不大，而二级缓存容量则是提高CPU性能的关键。二级缓存容量的提升是由CPU制造工艺所决定的，容量增大必然导致CPU内部晶体管数的增加，要在有限的CPU面积上集成更大的缓存，对制造工艺的要求也就越高。

什么是内存呢？在计算机的组成结构中，有一个很重要的部分，就是存储器。存储器是用来存储程序和数据的部件，对于计算机来说，有了存储器，才有记忆功能，才能保证正常工作。存储器的种类很多，按其用途可分为主存储器和辅助存储器，主存储器又称内存储器（简称内存），辅助存储器又称外存储器（简称外存）。外存通常是磁性介质或光盘，像硬盘，软盘，磁带，CD等，能长期保存信息，并且不依赖于电来保存信息，但是由机械部件带动，速度与CPU相比就显得慢的多。内存指的就是主板上的存储部件，是CPU直接与之沟通，并用其存储数据的部件，存放当前正在使用的（即执行中）的数据和程序，它的物理实质就是一组或多组具备数据输入输出和数据存储功能的集成电路，内存只用于暂时存放程序和数据，一旦关闭电源或发生断电，其中的程序和数据就会丢失。

既然内存是用来存放当前正在使用的（即执行中）的数据和程序，那么它是怎么工作的呢？我们平常所提到的计算机的内存指的是动态内存（即DRAM），动态内存中所谓的“动态”，指的是当我们将数据写入DRAM后，经过一段时间，数据会丢失，因此需要一个额外设电路进行内存刷新操作。具体的工作过程是这样的：一个DRAM的存储单元存储的是0还是1取决于电容是否有电荷，有电荷代表1，无电荷代表0。但时间一长，代表1的电容会放电，代表0的电容会吸收电荷，这就是数据丢失的原因；刷新操作定期对电容进行检查，若电量大于满电量的1／2，则认为其代表1，并把电容充满电；若电量小于1／2，则认为其代表0，并把电容放电，藉此来保持数据的连续性。

从一有计算机开始，就有内存。内存发展到今天也经历了很多次的技术改进，从最早的DRAM一直到FPMDRAM、EDODRAM、SDRAM等，内存的速度一直在提高且容量也在不断的增加。今天，服务器主要使用的是什么样的内存呢？目前，IA架构的服务器普遍使用的是REG ISTEREDECCSDRAM，下一期我们将详细介绍这一全新的内存技术及它给服务器带来的独特的技术优势。

mybatis缓存

1 查询缓存

1.1 什么是查询缓存
mybatis提供查询缓存，用于减轻数据压力，提高数据库性能。

mybaits提供一级缓存，和二级缓存。

一级缓存（默认开启）：

SqlSession级的缓存：在同一个SqlSession 查询同一个数据，不需要再通过数据库查询

二级缓存：

SqlSessionFactory级的缓存：在所有的SqlSession 查询同一个数据，不需要再通过数据库查询在mybatis的mapper.xml文件中加入标签：

---- 默认本地缓存复制代码

二级缓存实现原理：

mybatis的二级缓存主要在Executor对象上进行操作，当mybatis发现在mybatis.xml配置文件中设置了cacheEnabled=true时，mybatis在创建sqlsession时创建Executor对象，同时会对Executor加上装饰者【CacheExecutor】。 CacheExecutor对于查询请求，会判断application级别的二级缓存是否有缓存结果，如果有查询结果则直接返回，如果没有

2. 利用mybatis自身本地缓存结合redis实现分布式缓存

mybatis中应用二级缓存默认PepreCache SqlSessionFactory级别的缓存所有SqlSession会话共享如何开启（二级缓存） ---- 本地缓存默认是使用了

mybatis整合分布式缓存ehcache

整合方法：mybatis提供了一个cache接口，如果要实现自己的缓存逻辑，实现cache接口开发即可。mybatis本身默认实现了一个，但是这个缓存的实现无法实现分布式缓存，所以我们要自己来实现。

hcache分布式缓存就可以，mybatis提供了一个针对cache接口的ehcache实现类，这个类在mybatis和ehcache的整合包中。

然后配置一下开启二级缓存：

首先加入ehcache的jar包

上图为jar包。

在User.xml中加入一行代码

配置缓存

<cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
开启全局缓存配置
<settings>
<setting name="cacheEnabled" value="true"/>

</settings>

————————————————

一级缓存

一级缓存是SqlSession级别的缓存。在操作数据库时需要构造 sqlSession对象，在对象中有一个(内存区域)数据结构（HashMap）用于存储缓存数据。不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。

一级缓存的作用域是同一个SqlSession，在同一个sqlSession中两次执行相同的sql语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次会从缓存中获取数据将不再从数据库查询，从而提高查询效率。当一个sqlSession结束后该sqlSession中的一级缓存也就不存在了。Mybatis默认开启一级缓存。

一级缓存只是相对于同一个SqlSession而言。所以在参数和SQL完全一样的情况下，我们使用同一个SqlSession对象调用一个Mapper方法，往往只执行一次SQL，因为使用SelSession第一次查询后，MyBatis会将其放在缓存中，以后再查询的时候，如果没有声明需要刷新，并且缓存没有超时的情况下，SqlSession都会取出当前缓存的数据，而不会再次发送SQL到数据库。

1、一级缓存的生命周期有多长？
　　a、MyBatis在开启一个数据库会话时，会创建一个新的SqlSession对象，SqlSession对象中会有一个新的Executor对象。Executor对象中持有一个新的PerpetualCache对象；当会话结束时，SqlSession对象及其内部的Executor对象还有PerpetualCache对象也一并释放掉。

　　b、如果SqlSession调用了close()方法，会释放掉一级缓存PerpetualCache对象，一级缓存将不可用。

　　c、如果SqlSession调用了clearCache()，会清空PerpetualCache对象中的数据，但是该对象仍可使用。

　　d、SqlSession中执行了任何一个update操作(update()、delete()、insert()) ，都会清空PerpetualCache对象的数据，但是该对象可以继续使用

2、怎么判断某两次查询是完全相同的查询？
　　mybatis认为，对于两次查询，如果以下条件都完全一样，那么就认为它们是完全相同的两次查询。

　　2.1 传入的statementId

　　2.2 查询时要求的结果集中的结果范围

　　2.3. 这次查询所产生的最终要传递给JDBC java.sql.Preparedstatement的Sql语句字符串（boundSql.getSql() ）

　　2.4 传递给java.sql.Statement要设置的参数值

二级缓存
MyBatis的二级缓存是Application级别的缓存，它可以提高对数据库查询的效率，以提高应用的性能。

MyBatis的缓存机制整体设计以及二级缓存的工作模式

二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession去操作数据库得到数据会存在二级缓存区域，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。

二级缓存是多个SqlSession共享的，其作用域是mapper的同一个namespace，不同的sqlSession两次执行相同namespace下的sql语句且向sql中传递参数也相同即最终执行相同的sql语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次会从缓存中获取数据将不再从数据库查询，从而提高查询效率。Mybatis默认没有开启二级缓存需要在setting全局参数中配置开启二级缓存。

sqlSessionFactory层面上的二级缓存默认是不开启的，二级缓存的开启需要进行配置，实现二级缓存的时候，MyBatis要求返回的POJO必须是可序列化的。也就是要求实现Serializable接口，配置方法很简单，只需要在映射XML文件配置就可以开启缓存了<cache/>，如果我们配置了二级缓存就意味着：

映射语句文件中的所有select语句将会被缓存。
映射语句文件中的所欲insert、update和delete语句会刷新缓存。
缓存会使用默认的Least Recently Used（LRU，最近最少使用的）算法来收回。
根据时间表，比如No Flush Interval,（CNFI没有刷新间隔），缓存不会以任何时间顺序来刷新。
缓存会存储列表集合或对象(无论查询方法返回什么)的1024个引用
缓存会被视为是read/write(可读/可写)的缓存，意味着对象检索不是共享的，而且可以安全的被调用者修改，不干扰其他调用者或线程所做的潜在修改。
如果缓存中有数据就不用从数据库中获取，大大提高系统性能。

1.2 一级缓存
1.2.1 一级缓存工作原理
下图是根据id查询用户的一级缓存图解

第一次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，如果没有，从数据库查询用户信息。

得到用户信息，将用户信息存储到一级缓存中。

如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。

第二次发起查询用户id为1的用户信息，先去找缓存中是否有id为1的用户信息，缓存中有，直接从缓存中获取用户信息。

1.2.2 一级缓存测试
mybatis默认支持一级缓存，不需要在配置文件去配置。

按照上边一级缓存原理步骤去测试。

@Test

   public void testCache1() throws Exception{

      SqlSessionsqlSession = sqlSessionFactory.openSession();//创建代理对象

      UserMapperuserMapper = sqlSession.getMapper(UserMapper.class);

      //下边查询使用一个SqlSession
      //第一次发起请求，查询id为1的用户
      Useruser1 = userMapper.findUserById(1);

      System.out.println(user1);

//如果sqlSession去执行commit操作（执行插入、更新、删除），清空SqlSession中的一级缓存，这样做的目的为了让缓存中存储的是最新的信息，避免脏读。

      //更新user1的信息
      user1.setUsername("测试用户22");
      userMapper.updateUser(user1);
      //执行commit操作去清空缓存
      sqlSession.commit();

      //第二次发起请求，查询id为1的用户
      Useruser2 = userMapper.findUserById(1);
      System.out.println(user2);
      sqlSession.close();

   }
1.2.3    一级缓存应用
正式开发，是将mybatis和spring进行整合开发，事务控制在service中。

一个service方法中包括很多mapper方法调用。

service{

         //开始执行时，开启事务，创建SqlSession对象
         //第一次调用mapper的方法findUserById(1)
         //第二次调用mapper的方法findUserById(1)，从一级缓存中取数据
//aop控制只要方法结束，sqlSession关闭 sqlsession关闭后就销毁数据结构，清空缓存
         Service结束sqlsession关闭

}
如果是执行两次service调用查询相同的用户信息，不走一级缓存，因为Service方法结束，sqlSession就关闭，一级缓存就清空。

1.3 二级缓存
1.3.1 原理

首先开启mybatis的二级缓存。

sqlSession1去查询用户id为1的用户信息，查询到用户信息会将查询数据存储到二级缓存中。

如果SqlSession3去执行相同 mapper下sql，执行commit提交，清空该 mapper下的二级缓存区域的数据。

sqlSession2去查询用户id为1的用户信息，去缓存中找是否存在数据，如果存在直接从缓存中取出数据。

二级缓存与一级缓存区别，二级缓存的范围更大，多个sqlSession可以共享一个UserMapper的二级缓存区域。数据类型仍然为HashMap

UserMapper有一个二级缓存区域（按namespace分，如果namespace相同则使用同一个相同的二级缓存区），其它mapper也有自己的二级缓存区域（按namespace分）。

每一个namespace的mapper都有一个二缓存区域，两个mapper的namespace如果相同，这两个mapper执行sql查询到数据将存在相同的二级缓存区域中。

1.3.2 开启二级缓存
mybaits的二级缓存是mapper范围级别，除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存。

在核心配置文件SqlMapConfig.xml中加入

在UserMapper.xml中开启二缓存，UserMapper.xml下的sql执行完成会存储到它的缓存区域（HashMap）。

<mapper namespace="cn.hpu.mybatis.mapper.UserMapper">



<cache></cache>

1.3.3 调用pojo类实现序列化接口

public class Userimplements Serializable {

//Serializable实现序列化，为了将来反序列化

二级缓存需要查询结果映射的pojo对象实现java.io.Serializable接口实现序列化和反序列化操作，注意如果存在父类、成员pojo都需要实现序列化接口。

pojo类实现序列化接口是为了将缓存数据取出执行反序列化操作，因为二级缓存数据存储介质多种多样，不一定在内存有可能是硬盘或者远程服务器。

1.3.4    测试方法
// 二级缓存测试

   @Test

   public void testCache2() throws Exception {

      SqlSessionsqlSession1 = sqlSessionFactory.openSession();

      SqlSessionsqlSession2 = sqlSessionFactory.openSession();

      SqlSessionsqlSession3 = sqlSessionFactory.openSession();

      // 创建代理对象

      UserMapperuserMapper1 = sqlSession1.getMapper(UserMapper.class);

      // 第一次发起请求，查询id为1的用户

      Useruser1 = userMapper1.findUserById(1);

      System.out.println(user1);

      //这里执行关闭操作，将sqlsession中的数据写到二级缓存区域

      sqlSession1.close();

      //使用sqlSession3执行commit()操作

      UserMapperuserMapper3 = sqlSession3.getMapper(UserMapper.class);

      Useruser = userMapper3.findUserById(1);

      user.setUsername("张明明");

      userMapper3.updateUser(user);

      //执行提交，清空UserMapper下边的二级缓存

      sqlSession3.commit();

      sqlSession3.close();

      UserMapperuserMapper2 = sqlSession2.getMapper(UserMapper.class);

      // 第二次发起请求，查询id为1的用户

      Useruser2 = userMapper2.findUserById(1);

      System.out.println(user2);

      sqlSession2.close();

   }
1.3.5 useCache配置禁用二级缓存
在statement中设置useCache=false可以禁用当前select语句的二级缓存，即每次查询都会发出sql去查询，默认情况是true，即该sql使用二级缓存。

<selectid="findOrderListResultMap" resultMap="ordersUserMap" useCache="false">
总结：针对每次查询都需要最新的数据sql，要设置成useCache=false，禁用二级缓存。

1.3.6 mybatis刷新缓存（就是清空缓存）
在mapper的同一个namespace中，如果有其它insert、update、delete操作数据后需要刷新缓存，如果不执行刷新缓存会出现脏读。

设置statement配置中的flushCache="true" 属性，默认情况下为true即刷新缓存，如果改成false则不会刷新。使用缓存时如果手动修改数据库表中的查询数据会出现脏读。

如下：

<insertid="insertUser" parameterType="cn.itcast.mybatis.po.User" flushCache="true">

总结：一般下执行完commit操作都需要刷新缓存，flushCache=true表示刷新缓存默认情况下为true,我们不用去设置它，这样可以避免数据库脏读。

1.3.7 Mybatis Cache参数
flushInterval（刷新间隔）可以被设置为任意的正整数，而且它们代表一个合理的毫秒形式的时间段。默认情况是不设置，也就是没有刷新间隔，缓存仅仅调用语句时刷新。

size（引用数目）可以被设置为任意正整数，要记住你缓存的对象数目和你运行环境的可用内存资源数目。默认值是1024。

readOnly（只读）属性可以被设置为true或false。只读的缓存会给所有调用者返回缓存对象的相同实例。因此这些对象不能被修改。这提供了很重要的性能优势。可读写的缓存会返回缓存对象的拷贝（通过序列化）。这会慢一些，但是安全，因此默认是false。

如下例子：

<cache eviction="FIFO" flushInterval="60000" size="512" readOnly="true"/>
这个更高级的配置创建了一个 FIFO 缓存,并每隔 60 秒刷新,存数结果对象或列表的 512 个引用,而且返回的对象被认为是只读的,因此在不同线程中的调用者之间修改它们会导致冲突。可用的收回策略有, 默认的是 LRU:

1. LRU – 最近最少使用的:移除最长时间不被使用的对象。

2. FIFO – 先进先出:按对象进入缓存的顺序来移除它们。

3. SOFT – 软引用:移除基于垃圾回收器状态和软引用规则的对象。

4. WEAK – 弱引用:更积极地移除基于垃圾收集器状态和弱引用规则的对象。

1.4 mybatis整合ehcache

ehcache是一个分布式缓存框架。

EhCache 是一个纯Java的进程内缓存框架，是一种广泛使用的开源Java分布式缓存，具有快速、精干等特点，是Hibernate中默认的CacheProvider。

1.4.1 分布缓存
我们系统为了提高系统并发，性能、一般对系统进行分布式部署（集群部署方式）

不使用分布缓存，缓存的数据在各各服务单独存储，不方便系统开发。所以要使用分布式缓存对缓存数据进行集中管理。

mybatis无法实现分布式缓存，需要和其它分布式缓存框架进行整合。

1.4.2 整合方法(掌握无论整合谁，首先想到改type接口)
mybatis提供了一个cache接口，如果要实现自己的缓存逻辑，实现cache接口开发即可。

mybatis和ehcache整合，mybatis和ehcache整合包中提供了一个cache接口的实现类。

1.4.3 第一步加入ehcache包

1.4.4 整合ehcache
配置mapper中cache中的type为ehcache对cache接口的实现类型。

可以根据需求调整缓存参数：

<cache type="org.mybatis.caches.ehcache.EhcacheCache">

        <property name="timeToIdleSeconds" value="3600"/>

        <property name="timeToLiveSeconds" value="3600"/>

        

       <property name="maxEntriesLocalHeap"value="1000"/>

       

        <property name="maxEntriesLocalDisk" value="10000000"/>

        <property name="memoryStoreEvictionPolicy" value="LRU"/>

    </cache>
1.4.5    加入ehcache的配置文件
在classpath下配置ehcache.xml

<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

    xsi:noNamespaceSchemaLocation="../config/ehcache.xsd">

    <diskStore path="F:\develop\ehcache"/>

    <defaultCache

maxElementsInMemory="1000"

       maxElementsOnDisk="10000000"

       eternal="false"

       overflowToDisk="false"

       timeToIdleSeconds="120"

       timeToLiveSeconds="120"

       diskExpiryThreadIntervalSeconds="120"

       memoryStoreEvictionPolicy="LRU">

    </defaultCache>

</ehcache>
属性说明：

 diskStore：指定数据在磁盘中的存储位置。

 defaultCache：当借助CacheManager.add("demoCache")创建Cache时，EhCache便会采用<defalutCache/>指定的的管理策略

以下属性是必须的：

maxElementsInMemory - 在内存中缓存的element的最大数目

maxElementsOnDisk - 在磁盘上缓存的element的最大数目，若是0表示无穷大

 eternal - 设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断

 overflowToDisk- 设定当内存缓存溢出的时候是否将过期的element缓存到磁盘上

以下属性是可选的：

timeToIdleSeconds - 当缓存在EhCache中的数据前后两次访问的时间超过timeToIdleSeconds的属性取值时，这些数据便会删除，默认值是0,也就是可闲置时间无穷大

timeToLiveSeconds - 缓存element的有效生命期，默认是0.,也就是element存活时间无穷大

diskSpoolBufferSizeMB 这个参数设置DiskStore(磁盘缓存)的缓存区大小.默认是30MB.每个Cache都应该有自己的一个缓冲区.

diskPersistent在VM重启的时候是否启用磁盘保存EhCache中的数据，默认是false。

diskExpiryThreadIntervalSeconds - 磁盘缓存的清理线程运行间隔，默认是120秒。每个120s，相应的线程会进行一次EhCache中数据的清理工作

memoryStoreEvictionPolicy - 当内存缓存达到最大，有新的element加入的时候，移除缓存中element的策略。默认是LRU（最近最少使用），可选的有LFU（最不常使用）和FIFO（先进先出）

1.5 二级应用场景
对于访问多的查询请求且用户对查询结果实时性要求不高，此时可采用mybatis二级缓存技术降低数据库访问量，提高访问速度，业务场景比如：耗时较高的统计分析sql、电话账单查询sql等。

实现方法如下：通过设置刷新间隔时间，由mybatis每隔一段时间自动清空缓存，根据数据变化频率设置缓存刷新间隔flushInterval，比如设置为30分钟、60分钟、24小时等，根据需求而定。

1.6 二级缓存局限性
mybatis二级缓存对细粒度的数据级别的缓存实现不好，对同时缓存较多条数据的缓存，比如如下需求：对商品信息进行缓存，由于商品信息查询访问量大，但是要求用户每次都能查询最新的商品信息，此时如果使用mybatis的二级缓存就无法实现当一个商品变化时只刷新该商品的缓存信息而不刷新其它商品的信息，因为mybaits的二级缓存区域以mapper为单位划分，当一个商品信息变化会将所有商品信息的缓存数据全部清空。解决此类问题需要在业务层根据需求对数据有针对性缓存。需要使用三级缓存

hibernate缓存：一级缓存和二级缓存

1.什么是缓存？

　缓存是介于物理数据源与应用程序之间，是对数据库中的数据复制一份临时放在内存中的容器，其作用是为了减少应用程序对物理数据源访问的次数，从而提高了应用程序的运行性能。Hibernate在进行读取数据的时候，根据缓存机制在相应的缓存中查询，如果在缓存中找到了需要的数据(我们把这称做“缓存命中")，则就直接把命中的数据作为结果加以利用，避免了大量发送SQL语句到数据库查询的性能损耗。

缓存策略提供商：

提供了HashTable缓存，EHCache，OSCache，SwarmCache，jBoss Cathe2，这些缓存机制，其中EHCache，OSCache是不能用于集群环境（Cluster Safe）的，而SwarmCache，jBoss Cathe2是可以的。HashTable缓存主要是用来测试的，只能把对象放在内存中，EHCache，OSCache可以把对象放在内存（memory）中，也可以把对象放在硬盘（disk）上（为什么放到硬盘上？上面解释了）。

Hibernate缓存分类：

一、Session缓存（又称作事务缓存）：Hibernate内置的，不能卸除。

缓存范围：缓存只能被当前Session对象访问。缓存的生命周期依赖于Session的生命周期，当Session被关闭后，缓存也就结束生命周期。

二、SessionFactory缓存（又称作应用缓存）：使用第三方插件，可插拔。

缓存范围：缓存被应用范围内的所有session共享,不同的Session可以共享。这些session有可能是并发访问缓存，因此必须对缓存进行更新。缓存的生命周期依赖于应用的生命周期，应用结束时，缓存也就结束了生命周期，二级缓存存在于应用程序范围。

一级缓存：

Hibernate一些与一级缓存相关的操作（时间点）：

数据放入缓存：

1. save()。当session对象调用save()方法保存一个对象后，该对象会被放入到session的缓存中。

2. get()和load()。当session对象调用get()或load()方法从数据库取出一个对象后，该对象也会被放入到session的缓存中。

3. 使用HQL和QBC等从数据库中查询数据。

例如：数据库有一张表如下：

使用get()或load()证明缓存的存在：

public class Client

{

    public static void main(String[] args)

    {

        Session session = HibernateUtil.getSessionFactory().openSession();

        Transaction tx = null;

        try

        {

            /*开启一个事务*/

            tx = session.beginTransaction();

            /*从数据库中获取id="402881e534fa5a440134fa5a45340002"的Customer对象*/

            Customer customer1 = (Customer)session.get(Customer.class, "402881e534fa5a440134fa5a45340002");

            System.out.println("customer.getUsername is"+customer1.getUsername());

            /*事务提交*/

            tx.commit();

            System.out.println("-------------------------------------");

            /*开启一个新事务*/

            tx = session.beginTransaction();

            /*从数据库中获取id="402881e534fa5a440134fa5a45340002"的Customer对象*/

            Customer customer2 = (Customer)session.get(Customer.class, "402881e534fa5a440134fa5a45340002");

            System.out.println("customer2.getUsername is"+customer2.getUsername());

            /*事务提交*/

            tx.commit();

            System.out.println("-------------------------------------");

            /*比较两个get()方法获取的对象是否是同一个对象*/

            System.out.println("customer1 == customer2 result is "+(customer1==customer2));

        }

        catch (Exception e)

        {

            if(tx!=null)

            {

                tx.rollback();

            }

        }

        finally

        {

            session.close();

        }

    }

}

程序控制台输出结果：

Hibernate:
    select
        customer0_.id as id0_0_,
        customer0_.username as username0_0_,
        customer0_.balance as balance0_0_
    from
        customer customer0_
    where
        customer0_.id=?
customer.getUsername islisi
-------------------------------------
customer2.getUsername islisi
-------------------------------------
customer1 == customer2 result is true

其原理是：在同一个Session里面，第一次调用get()方法， Hibernate先检索缓存中是否有该查找对象，发现没有，Hibernate发送SELECT语句到数据库中取出相应的对象，然后将该对象放入缓存中，以便下次使用，第二次调用get()方法，Hibernate先检索缓存中是否有该查找对象，发现正好有该查找对象，就从缓存中取出来，不再去数据库中检索，没有再次发送select语句。

数据从缓存中清除：

1. evit()将指定的持久化对象从缓存中清除，释放对象所占用的内存资源，指定对象从持久化状态变为脱管状态，从而成为游离对象。
2. clear()将缓存中的所有持久化对象清除，释放其占用的内存资源。

其他缓存操作：

1. contains()判断指定的对象是否存在于缓存中。
2. flush()刷新缓存区的内容，使之与数据库数据保持同步。

二级缓存：

@Test

public void testCache2() {

Session session1 = sf.openSession();//获得Session1

session1.beginTransaction();

Category c = (Category)session1.load(Category.class, 1);

System.out.println(c.getName());

session1.getTransaction().commit();

session1.close();


Session session2 = sf.openSession();//获得Session2

session2.beginTransaction();

Category c2 = (Category)session2.load(Category.class, 1);

System.out.println(c2.getName());

session2.getTransaction().commit();

session2.close();

}

当我们重启一个Session，第二次调用load或者get方法检索同一个对象的时候会重新查找数据库，会发select语句信息。

原因：一个session不能取另一个session中的缓存。

性能上的问题：假如是多线程同时去取Category这个对象，load一个对象，这个对像本来可以放到内存中的，可是由于是多线程，是分布在不同的session当中的，所以每次都要从数据库中取，这样会带来查询性能较低的问题。

解决方案：使用二级缓存。

1.什么是二级缓存？

SessionFactory级别的缓存，可以跨越Session存在，可以被多个Session所共享。

2.适合放到二级缓存中：

（1）经常被访问

（2）改动不大

（3）数量有限

（4）不是很重要的数据，允许出现偶尔并发的数据。

这样的数据非常适合放到二级缓存中的。

用户的权限：用户的数量不大，权限不多，不会经常被改动，经常被访问。

例如组织机构。

思考：什么样的类，里面的对象才适合放到二级缓存中？

改动频繁，类里面对象特别多，BBS好多帖子，这些帖子20000多条，哪些放到缓存中，不能确定。除非你确定有一些经常被访问的，数据量并不大，改动非常少，这样的数据非常适合放到二级缓存中的。

3.二级缓存实现原理：

　Hibernate如何将数据库中的数据放入到二级缓存中？注意，你可以把缓存看做是一个Map对象，它的Key用于存储对象OID，Value用于存储POJO。首先，当我们使用Hibernate从数据库中查询出数据，获取检索的数据后，Hibernate将检索出来的对象的OID放入缓存中key 中，然后将具体的POJO放入value中，等待下一次再次向数据查询数据时，Hibernate根据你提供的OID先检索一级缓存，若有且配置了二级缓存，则检索二级缓存，如果还没有则才向数据库发送SQL语句，然后将查询出来的对象放入缓存中。

4.使用二级缓存

（1）打开二级缓存：

为Hibernate配置二级缓存：

在主配置文件中hibernate.cfg.xml ：

<!-- 使用二级缓存 -->
<property name="hibernate.cache.use_second_level_cache">true</property>    
<!--设置缓存的类型，设置缓存的提供商-->
<property name="hibernate.cache.provider_class">org.hibernate.cache.EhCacheProvider</property>

或者当hibernate与Spring整合后直接配到Spring配置文件applicationContext.xml中

<bean id="sessionFactory" class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

     <property name="dataSource" ref="dataSource"/>

     <property name="mappingResources">

        <list>

          <value>com/lp/ecjtu/model/Employee.hbm.xml</value>

          <value>com/lp/ecjtu/model/Department.hbm.xml</value>

        </list>

     </property>

     <property name="hibernateProperties">

        <value>

        hibernate.dialect=org.hibernate.dialect.OracleDialect

        hibernate.hbm2ddl.auto=update

        hibernate.show_sql=true

        hibernate.format_sql=true

        hibernate.cache.use_second_level_cache=true

        hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider

         hibernate.generate_statistics=true

     </value>

    </property>

</bean>

（2）配置ehcache.xml

<?xml version="1.0" encoding="UTF-8"?>

<ehcache>

    <!--

        缓存到硬盘的路径

    -->

    <diskStore path="d:/ehcache"></diskStore>

    <!--

        默认设置

        maxElementsInMemory : 在內存中最大緩存的对象数量。

        eternal : 缓存的对象是否永远不变。

        timeToIdleSeconds ：可以操作对象的时间。

        timeToLiveSeconds ：缓存中对象的生命周期，时间到后查询数据会从数据库中读取。

        overflowToDisk ：内存满了，是否要缓存到硬盘。

    -->

    <defaultCache maxElementsInMemory="200" eternal="false"

        timeToIdleSeconds="50" timeToLiveSeconds="60" overflowToDisk="true"></defaultCache>

    <!--

        指定缓存的对象。

        下面出现的的属性覆盖上面出现的，没出现的继承上面的。

    -->

    <cache name="com.suxiaolei.hibernate.pojos.Order" maxElementsInMemory="200" eternal="false"

        timeToIdleSeconds="50" timeToLiveSeconds="60" overflowToDisk="true"></cache>

</ehcache>

（3）使用二级缓存需要在实体类中加入注解：

需要ehcache-1.2.3.jar包:

还需要 commons_loging1.1.1.jar包

在实体类中通过注解可以配置实用二级缓存：

@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)

Load默认使用二级缓存，就是当查一个对象的时候，它先会去二级缓存里面去找，如果找到了就不去数据库中查了。

Iterator默认的也会使用二级缓存，有的话就不去数据库里面查了，不发送select语句了。

List默认的往二级缓存中加数据，假如有一个query，把数据拿出来之后会放到二级缓存，但是执行查询的时候不会到二级缓存中查，会在数据库中查。原因每个query中查询条件不一样。

（4）也可以在需要被缓存的对象中hbm文件中的<class>标签下添加一个<cache>子标签:

 <hibernate-mapping>

        <class name="com.suxiaolei.hibernate.pojos.Order" table="orders">

            <cache usage="read-only"/>

            <id name="id" type="string">

                <column name="id"></column>

                <generator class="uuid"></generator>

            </id>

            <property name="orderNumber" column="orderNumber" type="string"></property>

            <property name="cost" column="cost" type="integer"></property>

            <many-to-one name="customer" class="com.suxiaolei.hibernate.pojos.Customer"

                         column="customer_id" cascade="save-update">

            </many-to-one>

        </class>

    </hibernate-mapping>

存在一对多的关系，想要在在获取一方的时候将关联的多方缓存起来，需要再集合属性下添加<cache>子标签，这里需要将关联的对象的 hbm文件中必须在存在<class>标签下也添加<cache>标签，不然Hibernate只会缓存OID。

<hibernate-mapping>

        <class name="com.suxiaolei.hibernate.pojos.Customer" table="customer">

            <!-- 主键设置 -->

            <id name="id" type="string">

                <column name="id"></column>

                <generator class="uuid"></generator>

            </id>

            <!-- 属性设置 -->

            <property name="username" column="username" type="string"></property>

            <property name="balance" column="balance" type="integer"></property>

            <set name="orders" inverse="true" cascade="all" lazy="false" fetch="join">

                <cache usage="read-only"/>

                <key column="customer_id" ></key>

                <one-to-many class="com.suxiaolei.hibernate.pojos.Order"/>

            </set>

        </class>

    </hibernate-mapping>

从上面可以看到，经过了层层包装，从内到外一次经过如下包装：

1、PerpetualCache：第一层缓存，这个是缓存的唯一实现类，肯定需要。
2、LruCache：二级缓存淘汰机制之一。因为我们配置的默认机制，而默认就是LRU算法淘汰机制。淘汰机制总共有4中，我们可以自己进行手动配置。
3、SerializedCache：序列化缓存。这就是为什么开启了默认二级缓存我们的结果集对象需要实现序列化接口。
4、LoggingCache：日志缓存。
5、SynchronizedCache：同步缓存机制。这个是为了保证多线程机制下的线程安全性。

下面就是MyBatis中所有缓存的包装汇总：

-------------------------------------------------------------------

一、Mybatis实现Ehcache作为二级缓存
1. 为什么需要缓存

拉高程序的性能

2. 什么样的数据需要缓存

很少被修改或根本不改的数据

业务场景比如：耗时较高的统计分析sql、电话账单查询sql等

3. ehcache是什么

Ehcache 是现在最流行的纯Java开源缓存框架，配置简单、结构清晰、功能强大

注1：本章介绍的是2.X版本，3.x的版本和2.x的版本API差异比较大

4. ehcache的特点

4.1 够快

Ehcache的发行有一段时长了，经过几年的努力和不计其数的性能测试，Ehcache终被设计于large, high concurrency systems.

4.2 够简单

开发者提供的接口非常简单明了，从Ehcache的搭建到运用运行仅仅需要的是你宝贵的几分钟。其实很多开发者都不知道自己用在用Ehcache，Ehcache被广泛的运用于其他的开源项目

4.3 够袖珍

关于这点的特性，官方给了一个很可爱的名字small foot print ，一般Ehcache的发布版本不会到2M，V 2.2.3 才 668KB。

4.4 够轻量

核心程序仅仅依赖slf4j这一个包，没有之一！

4.5 好扩展

Ehcache提供了对大数据的内存和硬盘的存储，最近版本允许多实例、保存对象高灵活性、提供LRU、LFU、FIFO淘汰算法，基础属性支持热配置、支持的插件多

4.6 监听器

缓存管理器监听器（CacheManagerListener）和缓存监听器（CacheEvenListener）,做一些统计或数据一致性广播挺好用的

4.7 分布式缓存

从Ehcache 1.2开始，支持高性能的分布式缓存，兼具灵活性和扩展性

3. ehcache的使用

3.1 导入相关依赖

3.2 核心接口

CacheManager：缓存管理器

Cache：缓存对象，缓存管理器内可以放置若干cache，存放数据的实质，所有cache都实现了Ehcache接口

Element：单条缓存数据的组成单位
————————————————

1、导入相关依赖
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>${spring.version}</version>
</dependency>

<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-ehcache</artifactId>
<version>1.1.0</version>
</dependency>

<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
<version>2.10.0</version>
</dependency>

2 、修改日志配置，因为ehcache使用了Slf4j作为日志输出
日志我们使用slf4j，并用log4j来实现。SLF4J不同于其他日志类库，与其它有很大的不同。

SLF4J(Simple logging Facade for Java)不是一个真正的日志实现，而是一个抽象层（ abstraction layer），

它允许你在后台使用任意一个日志类库。

slf4j是一个抽象日志框架，它的好处在于：它没有具体的实现，谁来实现，取决于框架自身

①、替换成log4j2日志配置相关依赖

<log4j2.version>2.9.1</log4j2.version>

<log4j2.disruptor.version>3.2.0</log4j2.disruptor.version>

<slf4j.version>1.7.13</slf4j.version>

②、替换成log4j2日志相关依赖

<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>${slf4j.version}</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>jcl-over-slf4j</artifactId>
<version>${slf4j.version}</version>
<scope>runtime</scope>
</dependency>


<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-api</artifactId>
<version>${log4j2.version}</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>${log4j2.version}</version>
</dependency>

<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-slf4j-impl</artifactId>
<version>${log4j2.version}</version>
</dependency>

<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-web</artifactId>
<version>${log4j2.version}</version>
<scope>runtime</scope>
</dependency>


<dependency>
<groupId>com.lmax</groupId>
<artifactId>disruptor</artifactId>
<version>${log4j2.disruptor.version}</version>
</dependency>

3、在Resource中添加一个ehcache.xml的配置文件
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
updateCheck="false">



<diskStore path="java.io.tmpdir"/>












<defaultCache eternal="false" maxElementsInMemory="1000" overflowToDisk="false" diskPersistent="false"
timeToIdleSeconds="0" timeToLiveSeconds="600" memoryStoreEvictionPolicy="LRU"/>





</ehcache>
4、在applicationContext.xml中加入chache配置
①、复制applicationContext-mybatis.xml创建applicationContext.xml文件

把applicationContext.xml作为spring文件的总路口

</beans>
②、创建applicationContext-ehcache.xml

里面存放ehcache.xml的缓存配置，这样ehcache就交给sparing进行管理了

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

<bean id="cacheManagerFactory" class="org.springframework.cache.ehcache.EhCacheManagerFactoryBean">
<property name="configLocation" value="classpath:ehcache.xml"/>
<property name="shared" value="true"></property>
</bean>

<bean id="cacheManager" class="org.springframework.cache.ehcache.EhCacheCacheManager">
<property name="cacheManager" ref="cacheManagerFactory"/>
</bean>
</beans>
————————————————

5 、mybaits的二级缓存是mapper范围级别，除了在SqlMapConfig.xml设置二级缓存的总开关，还要在具体的mapper.xml中开启二级缓存
①、开启mybatis的二级缓存
applicationContext-mybatis.xml中添加

<property name="configurationProperties">
<props>

<prop key="cacheEnabled">true</prop>

<prop key="lazyLoadingEnabled">false</prop>

<prop key="aggressiveLazyLoading">true</prop>
</props>
</property>

②、 BookMapper.xml中添加二级缓存核心类
<cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>

④、mybatis框架默认缓存多条数据：
可以通过select标签的useCache属性打开或关闭二级缓存

注意有三：

mybatis默认使用的二级缓存框架就是ehcache（org.mybatis.caches.ehcache.EhcacheCache），无缝结合
Mybatis缓存开关一旦开启，可缓存单条记录，也可缓存多条，hibernate不能缓存多条。
Mapper接口上的所有方法上另外提供关闭缓存的属性
5. 小结

　　对于访问多的查询请求且用户对查询结果实时性要求不高，此时可采用mybatis二级缓存技术降低数据库访问量，提高访问速度，

二、Mybatis实现redis作为二级缓存

1. redis常用类
1.1 Jedis

jedis就是集成了redis的一些命令操作，封装了redis的java客户端

1.2 JedisPoolConfig

Redis连接池

1.3 ShardedJedis

基于一致性哈希算法实现的分布式Redis集群客户端

实现 mybatis 的二级缓存，一般来说有如下两种方式:

1）采用 mybatis 内置的 cache 机制。

2）采用三方 cache 框架，比如ehcache, oscache 等等.

spring + redis 集成实现缓存功能(与mybatis无关)
3.1 添加两个redis的配置文件，并将redis.properties和applicationContext-redis.xml配置到applicationContext.xml文件中
redis.properties

applicationContext-redis.xml

注1：将redis.properties导入到applicationContext.xml文件中

spring中引入第二个属性文件会出现“找不到某个配置项”错误，这是因为spring只允许有一个<context:property-placeholder/>

<context:property-placeholder ignore-unresolvable="true" location="classpath:jdbc.properties" />

<context:property-placeholder ignore-unresolvable="true" location="classpath:jdbc.properties,classpath:redis.properties" />

注2：通过import标签将applicationContext-redis.xml导入到applicationContext.xml文件中

redis.properties
我的虚拟机的端口号：192.168.42.138

redis.hostName=192.168.42.138
redis.port=6379
redis.password=123456
redis.timeout=10000
redis.maxIdle=300
redis.maxTotal=1000
redis.maxWaitMillis=1000
redis.minEvictableIdleTimeMillis=300000
redis.numTestsPerEvictionRun=1024
redis.timeBetweenEvictionRunsMillis=30000
redis.testOnBorrow=true
redis.testWhileIdle=true
applicationContext-redis.xml（数据源用到JedisPoolConfig）
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">




<bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">

<property name="maxIdle" value="${redis.maxIdle}"/>

<property name="maxTotal" value="${redis.maxTotal}"/>

<property name="maxWaitMillis" value="${redis.maxWaitMillis}"/>

<property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"/>

<property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/>

<property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"/>

<property name="testOnBorrow" value="${redis.testOnBorrow}"/>

<property name="testWhileIdle" value="${redis.testWhileIdle}"/>
</bean>


<bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
destroy-method="destroy">
<property name="poolConfig" ref="poolConfig"/>

<property name="hostName" value="${redis.hostName}"/>

<property name="port" value="${redis.port}"/>

<property name="password" value="${redis.password}"/>

<property name="timeout" value="${redis.timeout}"/>
</bean>


<bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate">
<property name="connectionFactory" ref="connectionFactory"/>

<property name="keySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
</property>
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/>
</property>
<property name="hashValueSerializer">
<bean class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer"/>
</property>

<property name="enableTransactionSupport" value="true"/>
</bean>


<bean id="redisCacheTransfer" class="com.mwy.util.RedisCacheTransfer">
<property name="redisTemplate" ref="redisTemplate"/>
</bean>

</beans>

3.2 将redis缓存引入到mybatis中
创建mybatis的自定义缓存类“RedisCache”，必须实现org.apache.ibatis.cache.Cache接口
RedisCache ：默认类中没有值，需要借助下面第三方（RedisCacheTransfer中的setRedisTemplate）获得值，而这个RedisCacheTransfer靠 applicationContext-redis.xml中的配置获得·

package com.mwy.util;
import org.apache.ibatis.cache.Cache;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.RedisCallback;
import org.springframework.data.redis.core.RedisTemplate;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;
public class RedisCache implements Cache //实现类
{
private static final Logger logger = LoggerFactory.getLogger(RedisCache.class);
private static RedisTemplate<String,Object> redisTemplate;
private final String id;
/**
* The {@code ReadWriteLock}.
*/
private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
@Override
public ReadWriteLock getReadWriteLock()
{
return this.readWriteLock;
}
public static void setRedisTemplate(RedisTemplate redisTemplate) {
RedisCache.redisTemplate = redisTemplate;
}
public RedisCache(final String id) {
if (id == null) {
throw new IllegalArgumentException("Cache instances require an ID");
}
logger.debug("MybatisRedisCache:id=" + id);
this.id = id;
}
@Override
public String getId() {
return this.id;
}
@Override
public void putObject(Object key, Object value) {
try{
logger.info(">>>>>>>>>>>>>>>>>>>>>>>>putObject: key="+key+",value="+value);
if(null!=value)
redisTemplate.opsForValue().set(key.toString(),value,60, TimeUnit.SECONDS);
}catch (Exception e){
e.printStackTrace();
logger.error("redis保存数据异常！");
}
}
@Override
public Object getObject(Object key) {
try{
logger.info(">>>>>>>>>>>>>>>>>>>>>>>>getObject: key="+key);
if(null!=key)
return redisTemplate.opsForValue().get(key.toString());
}catch (Exception e){
e.printStackTrace();
logger.error("redis获取数据异常！");
}
return null;
}
@Override
public Object removeObject(Object key) {
try{
if(null!=key)
return redisTemplate.expire(key.toString(),1,TimeUnit.DAYS);
}catch (Exception e){
e.printStackTrace();
logger.error("redis获取数据异常！");
}
return null;
}
@Override
public void clear() {
Long size=redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection redisConnection) throws DataAccessException {
Long size = redisConnection.dbSize();
//连接清除数据
redisConnection.flushDb();
redisConnection.flushAll();
return size;
}
});
logger.info(">>>>>>>>>>>>>>>>>>>>>>>>clear: 清除了" + size + "个对象");
}
@Override
public int getSize() {
Long size = redisTemplate.execute(new RedisCallback<Long>() {
@Override
public Long doInRedis(RedisConnection connection)
throws DataAccessException {
return connection.dbSize();
}
});
return size.intValue();
}
}

将redis配置到BookMapper.xml中
<cache type="com.mwy.util.RedisCache"></cache>

3.2 静态注入中间类“RedisCacheTransfer”，解决RedisCache中RedisTemplate的静态注入，从而使MyBatis实现第三方缓存
RedisCache 里面使用了redisTemplate，但是redisTemplate里面没有值，使用第三方让redisTemplate 有值：

RedisCacheTransfer.java
package com.mwy.util;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;

public class RedisCacheTransfer {
@Autowired
public void setRedisTemplate(RedisTemplate redisTemplate) {
RedisCache.setRedisTemplate(redisTemplate);
}
}
applicationContext-redis.xml：

加入spring（applicationContext.xml）中进行管理
一个spring文件中只允许使用一个这样的context:property-placeholder标签

注释掉 applicationContext-mybatis.xml：：

在applicationContext.xml中集中配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context" xmlns:tx="http://www.springframework.org/schema/tx"
xmlns:aop="http://www.springframework.org/schema/aop"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">

<context:property-placeholder location="classpath:jdbc.properties,classpath:redis.properties"/>

<import resource="classpath:applicationContext-mybatis.xml"></import>



<import resource="classpath:applicationContext-redis.xml"></import>
</beans>
记得查看pom.xml中：

所以说redis与ehcache使用并没有什么区别，就是配置不同而已