mybatis集成ehcache（二级缓存）整合redis

mybatis二级缓存为什么需要缓存什么样的数据需要缓存ehcache是什么ehcache的特点mybatis的二级缓存整合步骤 mybatis整合redis项目结构代码测试

mybatis二级缓存

为什么需要缓存

拉高程序的性能

什么样的数据需要缓存

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

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

ehcache是什么

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

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

ehcache的特点

1 够快 Ehcache的发行有一段时长了，经过几年的努力和不计其数的性能测试，Ehcache终被设计于large, high concurrency systems. 2 够简单 开发者提供的接口非常简单明了，从Ehcache的搭建到运用运行仅仅需要的是你宝贵的几分钟。其实很多开发者都不知道自己用在用Ehcache，Ehcache被广泛的运用于其他的开源项目 3 够袖珍 关于这点的特性，官方给了一个很可爱的名字small foot print ，一般Ehcache的发布版本不会到2M，V 2.2.3 才 668KB。 4 够轻量 核心程序仅仅依赖slf4j这一个包，没有之一！ 5 好扩展 Ehcache提供了对大数据的内存和硬盘的存储，最近版本允许多实例、保存对象高灵活性、提供LRU、LFU、FIFO淘汰算法，基础属性支持热配置、支持的插件多 6 监听器 缓存管理器监听器 （CacheManagerListener）和 缓存监听器（CacheEvenListener）,做一些统计或数据一致性广播挺好用的 7 分布式缓存 从Ehcache 1.2开始，支持高性能的分布式缓存，兼具灵活性和扩展性

mybatis的二级缓存整合步骤

1、pom依赖 2、需要在hibernate.cfg.xml中配置（将hibernate修改成applicationContext-mybatis.xml） 开启二级缓存 开启查询缓存 配置桥接包的工具类 3、哪个类需要用到缓存 ehcache.xml 配置缓存策略 xxx.hbm.xml 配置cache name region

1 导入相关依赖

<dependency> <groupId>org.springframework</groupId> <artifactId>spring-context-support</artifactId> <version>${spring.version}</version> </dependency> <!--mybatis与ehcache整合--> <dependency> <groupId>org.mybatis.caches</groupId> <artifactId>mybatis-ehcache</artifactId> <version>1.1.0</version> </dependency> <!--ehcache依赖--> <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）， 它允许你在后台使用任意一个日志类库。

<!-- 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日志相关依赖 --> <!-- log配置：Log4j2 + Slf4j --> <!-- slf4j核心包--> <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> <!--核心log4j2jar包--> <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> <!--用于与slf4j保持桥接--> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-slf4j-impl</artifactId> <version>${log4j2.version}</version> </dependency> <!--web工程需要包含log4j-web，非web工程不需要--> <dependency> <groupId>org.apache.logging.log4j</groupId> <artifactId>log4j-web</artifactId> <version>${log4j2.version}</version> <scope>runtime</scope> </dependency> <!--需要使用log4j2的AsyncLogger需要包含disruptor--> <dependency> <groupId>com.lmax</groupId> <artifactId>disruptor</artifactId> <version>${log4j2.disruptor.version}</version> </dependency>

3 创建ehcache.xml配置文件 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"> <!--磁盘存储:将缓存中暂时不使用的对象,转移到硬盘,类似于Windows系统的虚拟内存--> <!--path:指定在硬盘上存储对象的路径--> <!--java.io.tmpdir 是默认的临时文件路径。 可以通过如下方式打印出具体的文件路径 System.out.println(System.getProperty("java.io.tmpdir"));--> <diskStore path="java.io.tmpdir"/> <!--defaultCache：默认的管理策略--> <!--eternal：设定缓存的elements是否永远不过期。如果为true，则缓存的数据始终有效，如果为false那么还要根据timeToIdleSeconds，timeToLiveSeconds判断--> <!--maxElementsInMemory：在内存中缓存的element的最大数目--> <!--overflowToDisk：如果内存中数据超过内存限制，是否要缓存到磁盘上--> <!--diskPersistent：是否在磁盘上持久化。指重启jvm后，数据是否有效。默认为false--> <!--timeToIdleSeconds：对象空闲时间(单位：秒)，指对象在多长时间没有被访问就会失效。只对eternal为false的有效。默认值0，表示一直可以访问--> <!--timeToLiveSeconds：对象存活时间(单位：秒)，指对象从创建到失效所需要的时间。只对eternal为false的有效。默认值0，表示一直可以访问--> <!--memoryStoreEvictionPolicy：缓存的3 种清空策略--> <!--FIFO：first in first out (先进先出)--> <!--LFU：Less Frequently Used (最少使用).意思是一直以来最少被使用的。缓存的元素有一个hit 属性，hit 值最小的将会被清出缓存--> <!--LRU：Least Recently Used(最近最少使用). (ehcache 默认值).缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存--> <defaultCache eternal="false" maxElementsInMemory="1000" overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0" timeToLiveSeconds="600" memoryStoreEvictionPolicy="LRU"/> <!--name： Cache的名称，必须是唯一的(ehcache会把这个cache放到HashMap里)--> <!--<cache name="stuCache" eternal="false" maxElementsInMemory="100"--> <!--overflowToDisk="false" diskPersistent="false" timeToIdleSeconds="0"--> <!--timeToLiveSeconds="300" memoryStoreEvictionPolicy="LRU"/>--> </ehcache>

4 applicationContext-mybatis.xml中添加

<!--设置mybaits对缓存的支持--> <property name="configurationProperties"> <props> <!-- 全局映射器启用缓存 *主要将此属性设置完成即可--> <prop key="cacheEnabled">true</prop> <!-- 查询时，关闭关联对象即时加载以提高性能 --> <prop key="lazyLoadingEnabled">false</prop> <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 --> <prop key="aggressiveLazyLoading">true</prop> </props> </property>

5 在XxxMapper.xml中配置cache 我这边是用BookMapper.xml 在最上方添加cache

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="com.liuchunming.mapper.BookMapper" > <cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache> <resultMap id="BaseResultMap" type="com.liuchunming.model.Book" > <constructor > <idArg column="bid" jdbcType="INTEGER" javaType="java.lang.Integer" /> <arg column="bname" jdbcType="VARCHAR" javaType="java.lang.String" /> <arg column="price" jdbcType="REAL" javaType="java.lang.Float" /> </constructor> </resultMap> <sql id="Base_Column_List" > bid, bname, price </sql> <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" > select <include refid="Base_Column_List" /> from t_mvc_book where bid = #{bid,jdbcType=INTEGER} </select> <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" > delete from t_mvc_book where bid = #{bid,jdbcType=INTEGER} </delete> <insert id="insert" parameterType="com.liuchunming.model.Book" > insert into t_mvc_book (bid, bname, price ) values (#{bid,jdbcType=INTEGER}, #{bname,jdbcType=VARCHAR}, #{price,jdbcType=REAL} ) </insert> <insert id="insertSelective" parameterType="com.liuchunming.model.Book" > insert into t_mvc_book <trim prefix="(" suffix=")" suffixOverrides="," > <if test="bid != null" > bid, </if> <if test="bname != null" > bname, </if> <if test="price != null" > price, </if> </trim> <trim prefix="values (" suffix=")" suffixOverrides="," > <if test="bid != null" > #{bid,jdbcType=INTEGER}, </if> <if test="bname != null" > #{bname,jdbcType=VARCHAR}, </if> <if test="price != null" > #{price,jdbcType=REAL}, </if> </trim> </insert> <update id="updateByPrimaryKeySelective" parameterType="com.liuchunming.model.Book" > update t_mvc_book <set > <if test="bname != null" > bname = #{bname,jdbcType=VARCHAR}, </if> <if test="price != null" > price = #{price,jdbcType=REAL}, </if> </set> where bid = #{bid,jdbcType=INTEGER} </update> <update id="updateByPrimaryKey" parameterType="com.liuchunming.model.Book" > update t_mvc_book set bname = #{bname,jdbcType=VARCHAR}, price = #{price,jdbcType=REAL} where bid = #{bid,jdbcType=INTEGER} </update> <select id="aaaa" useCache="false" resultType="java.util.Map" parameterType="java.util.Map"> select * from t_mvc_book <where> <if test="null != bname and bname != ''"> and bname like #{bname} </if> </where> </select> </mapper>

测试查询单个数据方法用缓存与不用缓存区别 使用了缓存

没使用缓存 查询了两次数据库 测试多个数据是否有缓存 以前hibernate查多个默认不查缓存的，需要手动代码设置 mybatis与hibernate刚好相反 因为mybatis是默认查询缓存的，如果想要不查询缓存的需求呢？ 在BookMapper.xml中sql事务中添加useCache="false" 没使用缓存效果

注意：与hibernate二级缓存不同之处： hibernate默认会缓存单条数据，不会缓存多条数据，如果想缓存多条，那么需要通过代码手动开启使用。 mybatis默认会缓存单条以及多条，如果不想缓存多条，那么在具体的方法sql添加属性值userCache=“false”

mybatis整合redis

1、 redis常用类 Jedis jedis就是集成了redis的一些命令操作，封装了redis的java客户端 JedisPoolConfig Redis连接池 ShardedJedis 基于一致性哈希算法实现的分布式Redis集群客户端

实现 mybatis 的二级缓存，一般来说有如下两种方式: 1） 采用 mybatis 内置的 cache 机制。 2） 采用三方 cache 框架， 比如ehcache, oscache 等等.

实现步骤 1，pom依赖 jedis pool 2、application-redis.xml     1、注册redis-properites     2、创建数据源 jedis pool     3、链接工厂配置     4、配置序列化器     5、redis第三方工具类桥接配置 就是要将RedisTemplate注入缓存要用的工具类 3、配置桥接包中的工具类 哪个实体类需要用缓存 ehcache.xml 配置缓存策略 xxx.hbm.xml 配置cache name region

项目结构

新添工具类

代码

1,pom依赖 添加redis相关依赖与 log4j2配置jackson

<!-- redis与spring的整合依赖 --> <redis.version>2.9.0</redis.version> <redis.spring.version>1.7.1.RELEASE</redis.spring.version> <!-- jackson --> <jackson.version>2.9.3</jackson.version> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>${redis.version}</version> </dependency> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> <version>${redis.spring.version}</version> </dependency> <!-- jackson --> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-databind</artifactId> <version>${jackson.version}</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-core</artifactId> <version>${jackson.version}</version> </dependency> <dependency> <groupId>com.fasterxml.jackson.core</groupId> <artifactId>jackson-annotations</artifactId> <version>${jackson.version}</version> </dependency>

redis.properties

redis.hostName=192.168.254.130 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 这里的话为什么不在RedisCacheTransfer类里面使用注解而是配置Bean来管理呢？

因为它是在xxxMapper.xml里面使用的在读取的时候是识别不了注解的，注解只有在调java代码的时候才起作用。

<?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" 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"> <!-- 1. 引入properties配置文件 --> <!--<context:property-placeholder location="classpath:redis.properties" />--> <!-- 2. redis连接池配置--> <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}"/> <!--逐出连接的最小空闲时间 默认1800000毫秒(30分钟)--> <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"/> <!--每次逐出检查时 逐出的最大数目 如果为负数就是 : 1/abs(n), 默认3--> <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/> <!--逐出扫描的时间间隔(毫秒) 如果为负数,则不运行逐出线程, 默认-1--> <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"/> <!--是否在从池中取出连接前进行检验,如果检验失败,则从池中去除连接并尝试取出另一个--> <property name="testOnBorrow" value="${redis.testOnBorrow}"/> <!--在空闲时检查有效性, 默认false --> <property name="testWhileIdle" value="${redis.testWhileIdle}"/> </bean> <!-- 3. redis连接工厂 --> <bean id="connectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy"> <property name="poolConfig" ref="poolConfig"/> <!--IP地址 --> <property name="hostName" value="${redis.hostName}"/> <!--端口号 --> <property name="port" value="${redis.port}"/> <!--如果Redis设置有密码 --> <property name="password" value="${redis.password}"/> <!--客户端超时时间单位是毫秒 --> <property name="timeout" value="${redis.timeout}"/> </bean> <!-- 4. redis操作模板,使用该对象可以操作redis --> <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"> <property name="connectionFactory" ref="connectionFactory"/> <!--如果不配置Serializer，那么存储的时候缺省使用String，如果用User类型存储，那么会提示错误User can't cast to String！！ --> <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> <!-- 5.使用中间类解决RedisCache.RedisTemplate的静态注入，从而使MyBatis实现第三方缓存 --> <bean id="redisCacheTransfer" class="com.liuchunming.util.RedisCacheTransfer"> <property name="redisTemplate" ref="redisTemplate"/> </bean> </beans>

注意：在配置文件中只能配置一次<context:property-placeholder location=“xxxx” />标签，因为这边配置了，applicationContext-mybatis.xml中同样也配置了，会起冲突 解决：两个配置文件中都注释，在applicationContext.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" 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"> <!-- 1. 引入properties配置文件 --> <context:property-placeholder location="classpath:jdbc.properties,classpath:redis.properties" /> <!--整合mybatis--> <import resource="applicationContext-mybatis.xml"></import> <import resource="applicationContext-redis.xml"></import> </beans>

applicationContext-mybatis.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"> <!--1. 注解式开发 --> <!-- 注解驱动 --> <context:annotation-config/> <!-- 用注解方式注入bean，并指定查找范围：com.javaxl.ssm及子子孙孙包--> <context:component-scan base-package="com.liuchunming"/> <!--<context:property-placeholder location="classpath:jdbc.properties"/>--> <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource" destroy-method="close"> <property name="driverClassName" value="${jdbc.driver}"/> <property name="url" value="${jdbc.url}"/> <property name="username" value="${jdbc.username}"/> <property name="password" value="${jdbc.password}"/> <!--初始连接数--> <property name="initialSize" value="10"/> <!--最大活动连接数--> <property name="maxTotal" value="100"/> <!--最大空闲连接数--> <property name="maxIdle" value="50"/> <!--最小空闲连接数--> <property name="minIdle" value="10"/> <!--设置为-1时，如果没有可用连接，连接池会一直无限期等待，直到获取到连接为止。--> <!--如果设置为N（毫秒），则连接池会等待N毫秒，等待不到，则抛出异常--> <property name="maxWaitMillis" value="-1"/> </bean> <!--4. spring和MyBatis整合 --> <!--1) 创建sqlSessionFactory--> <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"> <!-- 指定数据源 --> <property name="dataSource" ref="dataSource"/> <!-- 自动扫描XxxMapping.xml文件，**任意路径 --> <property name="mapperLocations" value="classpath*:com/liuchunming/**/mapper/*.xml"/> <!-- 指定别名 --> <!--<property name="typeAliasesPackage" value="com/liuchunming/**/model"/>--> <!--设置mybaits对缓存的支持--> <property name="configurationProperties"> <props> <!-- 全局映射器启用缓存 *主要将此属性设置完成即可--> <prop key="cacheEnabled">true</prop> <!-- 查询时，关闭关联对象即时加载以提高性能 --> <prop key="lazyLoadingEnabled">false</prop> <!-- 设置关联对象加载的形态，此处为按需加载字段(加载字段由SQL指 定)，不会加载关联表的所有字段，以提高性能 --> <prop key="aggressiveLazyLoading">true</prop> </props> </property> <!--配置pagehelper插件--> <property name="plugins"> <array> <bean class="com.github.pagehelper.PageInterceptor"> <property name="properties"> <value> helperDialect=mysql </value> </property> </bean> </array> </property> </bean> <!--2) 自动扫描com/javaxl/ssm/**/mapper下的所有XxxMapper接口(其实就是DAO接口)，并实现这些接口，--> <!-- 即可直接在程序中使用dao接口，不用再获取sqlsession对象--> <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> <!--basePackage 属性是映射器接口文件的包路径。--> <!--你可以使用分号或逗号 作为分隔符设置多于一个的包路径--> <property name="basePackage" value="com/liuchunming/**/mapper"/> <property name="sqlSessionFactoryBeanName" value="sqlSessionFactory"/> </bean> <!--注解式事务--> <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager"> <property name="dataSource" ref="dataSource" /> </bean> <!--事务管理器注解扫描驱动--> <tx:annotation-driven transaction-manager="transactionManager" /> <aop:aspectj-autoproxy/> </beans>

RedisCache.java 将redis缓存引入到mybatis中 创建mybatis的自定义缓存类“RedisCache”，必须实现org.apache.ibatis.cache.Cache接口 桥接表

package com.liuchunming.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(); } }

RedisCacheTransfer.java 静态注入中间类“RedisCacheTransfer”，解决RedisCache中RedisTemplate的静态注入，从而使MyBatis实现第三方缓存 负责把RedisCache注入到工具类中去

package com.liuchunming.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); } }

BookMapper.xml 添加开启缓存配置

<?xml version="1.0" encoding="UTF-8" ?> <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd" > <mapper namespace="com.liuchunming.mapper.BookMapper" > <!--<cache type="org.mybatis.caches.ehcache.EhcacheCache"></cache>--> <cache type="com.liuchunming.util.RedisCache"></cache> <resultMap id="BaseResultMap" type="com.liuchunming.model.Book" > <constructor > <idArg column="bid" jdbcType="INTEGER" javaType="java.lang.Integer" /> <arg column="bname" jdbcType="VARCHAR" javaType="java.lang.String" /> <arg column="price" jdbcType="REAL" javaType="java.lang.Float" /> </constructor> </resultMap> <sql id="Base_Column_List" > bid, bname, price </sql> <select id="selectByPrimaryKey" resultMap="BaseResultMap" parameterType="java.lang.Integer" > select <include refid="Base_Column_List" /> from t_mvc_book where bid = #{bid,jdbcType=INTEGER} </select> <delete id="deleteByPrimaryKey" parameterType="java.lang.Integer" > delete from t_mvc_book where bid = #{bid,jdbcType=INTEGER} </delete> <insert id="insert" parameterType="com.liuchunming.model.Book" > insert into t_mvc_book (bid, bname, price ) values (#{bid,jdbcType=INTEGER}, #{bname,jdbcType=VARCHAR}, #{price,jdbcType=REAL} ) </insert> <insert id="insertSelective" parameterType="com.liuchunming.model.Book" > insert into t_mvc_book <trim prefix="(" suffix=")" suffixOverrides="," > <if test="bid != null" > bid, </if> <if test="bname != null" > bname, </if> <if test="price != null" > price, </if> </trim> <trim prefix="values (" suffix=")" suffixOverrides="," > <if test="bid != null" > #{bid,jdbcType=INTEGER}, </if> <if test="bname != null" > #{bname,jdbcType=VARCHAR}, </if> <if test="price != null" > #{price,jdbcType=REAL}, </if> </trim> </insert> <update id="updateByPrimaryKeySelective" parameterType="com.liuchunming.model.Book" > update t_mvc_book <set > <if test="bname != null" > bname = #{bname,jdbcType=VARCHAR}, </if> <if test="price != null" > price = #{price,jdbcType=REAL}, </if> </set> where bid = #{bid,jdbcType=INTEGER} </update> <update id="updateByPrimaryKey" parameterType="com.liuchunming.model.Book" > update t_mvc_book set bname = #{bname,jdbcType=VARCHAR}, price = #{price,jdbcType=REAL} where bid = #{bid,jdbcType=INTEGER} </update> <select id="aaaa" useCache="true" resultType="java.util.Map" parameterType="java.util.Map"> select * from t_mvc_book <where> <if test="null != bname and bname != ''"> and bname like #{bname} </if> </where> </select> </mapper>

测试

jjunit测试

@Test public void testCacheOne() {//测试单个数据是否有缓存 System.out.println(this.bookService.selectByPrimaryKey(3)); System.out.println(this.bookService.selectByPrimaryKey(3)); }

第一次查询从数据库查询一次，然后存入redis 第二次查询直接查询redis缓存 redis与ehcache的区别 ehcache至少会查询一次数据库，redis只要缓存还存在与redis的服务器中，那么就不需要查询mysql数据库