1.如果之前项目中已经使用了第三方缓存（例如：ehcache）
（1）首先应该摒弃或者屏蔽掉，防止ehcache缓存的存在对这里的redis缓存的判断
（2）缓存的整合不在spring部分，而在mybatis部分
（3）整合也是整合redis+mybatis或者ehcache+mybatis，先意识到这点
（4）但是一般实际开发过程中，mybatis的相关配置已经整合到spring的配置文件中了
（5）因此缓存相关的配置也和mybatis一样，整合在spring的配置文件，方便利用spring的事务进行统一管理
2.整合过程如下：
（1）配置pom.xml：引入redis依赖
<!--支持Redis的语言——Jedis包-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<!--依赖包-->
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-pool2</artifactId>
<version>2.4.2</version>
</dependency>
<!-- mybatis与redis整合包-->
<dependency>
<groupId>org.mybatis.caches</groupId>
<artifactId>mybatis-redis</artifactId>
<version>1.0.0-beta2</version>
</dependency>
<!-- spring与redis整合包 -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
<version>1.8.1.RELEASE</version>
</dependency>
（2）创建配置Redis属性文件redis.properties
<1>property文件夹下的jdbc.properties和redis.properties.分别是数据源连接配置和redis服务端连接配置
<2>redis.properties配置内容
#ip和端口值为服务器默认设置，能找到redis服务并连接上
redis.host=127.0.0.1
redis.port=6379
#没有密码这里密码对应的值为空（没有最好就不要写，即使为空经测试运行起来也有问题）
redis.password=root
#redis.pool….是对连接redis服务器的jedispool的设置
redis.maxWaitMillis=1000
redis.maxTotal=600
redis.maxIdle=300
#在获取连接的时候检查有效性
redis.testOnBorrow=true
redis.testOnReturn=true
redis.timeout=100000
# 默认缓存失效时间
defaultCacheExpireTime=3600
（4）spring与redis整合的配置文件，如下：或者单独配置redis.xml
<!--扫描redis配置文件:集成在spring中，这里省略-->
//<context:property-placeholder ignore-unresolvable="true" location="classpath:redis.properties"/>
<!-- Redis连接池的设置:把jedisPool交给spring管理 -->
<bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
<!--高版本：maxWaitMillis，低版本：maxWait-->
<property name="maxWaitMillis" value="${redis.maxWaitMillis}" />
<!-- 连接池中最大连接数。高版本：maxTotal，低版本：maxActive -->
<property name="maxTotal" value="${redis.maxTotal}" />
<!-- 连接池中最大空闲的连接数. -->
<property name="maxIdle" value="${redis.maxIdle}" />
<property name="testOnBorrow" value="${redis.testOnBorrow}" />
</bean>
<!-- 配置Redis连接工厂 -->
<bean id="jedisConnectionFactory"
class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
<property name="poolConfig" ref="jedisPoolConfig"/>
<property name="hostName" value="${redis.host}"/>
<property name="port" value="${redis.port}"/>
<property name="password" value="${redis.password}"/>
<property name="timeout" value="${redis.timeout}"/>
</bean>
<!-- 配置redistempLate模板 -->
<bean id="redisTemplate" class="org.springframework.data.redis.core.StringRedisTemplate">
<property name="connectionFactory" ref="jedisConnectionFactory" />
<!-- 如果不配置Serializer，那么存储的时候只能使用String，如果用对象类型存储，那么会提示错误 -->
<property name="keySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>
<property name="valueSerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>
<property name="hashKeySerializer">
<bean class="org.springframework.data.redis.serializer.StringRedisSerializer" />
</property>
<!-- 开启事务，可以通过transcational注解控制 -->
<property name="enableTransactionSupport" value="true"></property>
</bean>
<!--当自定义的Redis缓存类通过注解方式注入spring后，就不要在此配置：静态注入了-->
<!-- <bean id="redisCacheTransfer" class="com.user.util.RedisCacheTransfer">
<property name="jedisConnectionFactory" ref="jedisConnectionFactory" />
</bean> -->
</beans>
<2>单独配置时：在spring的配置文件applicationContext.xml导入spring-redis.xml即可
<import resource="spring-redis.xml"/>
3.mybatis整合redis缓存（使用Spring封装类RedisTemplate后，可省略）
（1）mybatis自己已经做了一个兼容redis的第三方缓存的jar包
（2）在pom.xml中引入mybatis-redis 的jar包，前面已经引入了
<1>可以查看RedisCache的源码
<2>public final class RedisCache implements Cache
（3）在mybatis的Mapper中引入：
<1>也可以使用自定义的接口
<2>使用自定义接口，需要在Mapper中引入具体的接口实现类路径
<mapper namespace="com.user.dao.UserDao">
<!--不自定义缓存接口，使用官方实现的默认接口用的是hash来缓存Mapper中的查询有缺陷
1.经测试如果使用默认接口，不需要配置，否则报错-->
<!--<cache type="org.mybatis.caches.redis.RedisCache" />-->
<!--mybatis集成在spring，缓存类使用注解后就不需要在此配置-->
<!-- <cache type="com.user.caches.redis.RedisCache" /> -->
...
</mapper>
（4）配置完毕之后，需要开启mybatis的全局缓存：
<configuration>
<settings>
<setting name="logImpl" value="LOG4J2" />
<!-- 全局映射器启用缓存-->
<setting name="cacheEnabled" value="true"/>
</settings>
</configuration>
（5）经过上面操作，就可以使用官方提供的Redis缓存了
（6）操作缓存时只需要引入RedisTemplate或者JedisPool
<1>JedisPool是Redis官方推荐的面向Java的操作Redis的客户端
<2>RedisTemplate是SpringDataRedis中对JedisApi的高度封装
<3>RedisTemplate相对于JedisPool来说可以方便地更换Redis的Java客户端
<4>比JedisPool多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用
@Resource
private RedisTemplate redisTemplate;
@Resource
private JedisPool jedisPool;
3.至此Redis已经引入到了SSM框架中
（1）引入过程中注意事项如下：
<1>redis作为缓存服务器的配置和数据库服务器配置一样，需要一些基本信息用来连接redis服务器
<2>redis的配置文件可以单独配置，然后引入spring中还可以直接与spring集成
<3>redis事务管理和spring事务管理不同，需要配置
（2）在使用mybatis官方提供的redis作为mybatis缓存，如果不做一些额外处理，会存在一些不足
<1>默认情况下，mybatis会为每一个mapper创建一个RedisCache，而JedisPool是在RedisCache的构造方法中创建
的,这就意味着会为每一个mapper创建一个JedisPool，使用意图和开销上面都会有问题；
<2>应用中也会独立使用到redis，这样无法让RedisCache直接使用项目中可能已经存在的JedisPool,并且会造成两个
配置文件（除非应用也使用redis.properties）；
<3>RedisCache是使用hash来缓存一个Mapper中的查询，所以只能通过mybatis的cache配置来控制对象的生存时间，
空闲时间等属性；而无法独立的去配置每一个缓存区域（即每一个hash）
（3）针对上面的三个不足之处进行了进一步的改进：
<1>需要用到mybatis-redis中SerializeUtil类
<2>官方提供的redis-cache用的是hash来缓存Mapper中的查询，这里采用string数据结构来缓存
***<3>重要：可以自定义一个RedisCache,使用注解形式注入spring***
4.自定义缓存类接口：RedisCacheService
public interface RedisCacheService {
//读取缓存
Object getCache(String key);
//写入缓存
boolean setCache(String key, Object value);
boolean setCacheToRedis(String key, Object value, long expireTime);
// 批量删除对应的value
void remove(String... keys);
// 批量删除key
void removePattern(String pattern);
// 删除对应的value
void remove(String key);
// 删除符合要求的key by ivan
void deleteKeys(String key);
// 判断缓存中是否有对应的value
boolean exists(String key);
}
5.实现自定义缓存类接口，使用注解方式注入spring：RedisCacheServiceImpl
（1）使用自定义缓存类，注入spring优点如下：
<1>不需要在spring静态引入Redis配置类
<2>不需要在Mapping.xml中引入缓存支持，因为Mybatis已经集成在spring中统一管理
<3>Spring框架已经对Redis底层进行了封装：RedisTemplate<String, Object>，提供了丰富的Redis操作
（2）实现自定义缓存类接口：RedisCacheServiceImpl
/**
* RedisTemplate类:将同一类型操作封装为operation接口
* ValueOperations：简单K-V操作
* SetOperations：set类型数据操作
* ZSetOperations：zset类型数据操作
* HashOperations：针对map类型的数据操作
* ListOperations：针对list类型的数据操作
*/
@Service
public class RedisCacheServiceImpl implements RedisCacheService {
@Resource
private RedisTemplate<String, Object> redisTemplate;
@Override
public Object getCache(String key) {
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
return valueOperations.get(key);
}
@Override
public boolean setCache(String key, Object value) {
boolean result = false;
try {
value = JSON.toJSONString(value);
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
valueOperations.set(key, value);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
@Override
public boolean setCacheToRedis(String key, Object value, long expireTime) {
boolean result = false;
try {
ValueOperations<String, Object> valueOperations = redisTemplate.opsForValue();
valueOperations.set(key, value);
redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);
result = true;
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
@Override
public void remove(String... keys) {
for (String key : keys)
remove(key);
}
@Override
public void removePattern(String pattern) {
Set<String> keys = redisTemplate.keys(pattern);
if (keys.size() > 0)
redisTemplate.delete(keys);
}
@Override
public void remove(String key) {
if (exists(key))
redisTemplate.delete(key);
}
@Override
public void deleteKeys(String key) {
redisTemplate.delete(redisTemplate.keys(key));
}
@Override
public boolean exists(String key) {
return redisTemplate.hasKey(key);
}
public void setRedisTemplate(
RedisTemplate<String, Object> redisTemplate) {
this.redisTemplate = redisTemplate;
}
}
6.调用Redis缓存接口操作，应用实例
public class UserController {
@Resource
private UserService userService;
@Resource
private RedisCacheService redisCacheService;
@RequestMapping(value = "/user", method = RequestMethod.GET)
@ResponseBody
public Object FindInfo(@RequestParam("username") String username) {
//尝试从缓存中取数据
String name = (String) redisCacheService.getCache("username");
if(name==null){
//缓存中没有从数据库读取数据
List<User> list = userService.findByName(username);
System.out.println(list);
//将获取到的数据放入缓存，设置生存时间为1小时
redisCacheService.setCacheToRedis( "username", username, 3600);
System.out.println("数据存入缓存成功");
}else{
return name;
}
return username;
}
7.至此，SSM+Maven+Redis搭建单机版完毕
（1）注意事项如下：
<1>mybatis整合redis缓存（使用Spring封装类RedisTemplate后，可省略）
<2>使用自定义封装类，注解注入spring后，不需要在spring再静态注入
<3>实际开发中使用Spring封装的Redis：RedisTemplate
