一：先新增redis配置

#redis
spring.cache.type=REDIS
spring.redis.database=0
spring.redis.host=127.0.0.1
pring.redis.password=
spring.redis.port=6379
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=100
spring.redis.pool.max-wait=-1
#redis

二：添加redis的配置类

package com.gh.redis;

import java.lang.reflect.Method;

import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {
/*定义缓存数据 key 生成策略的bean
包名+类名+方法名+所有参数
*/
@Bean
public KeyGenerator wiselyKeyGenerator(){
return new KeyGenerator() {
@Override
public Object generate(Object target, Method method, Object... params) {
StringBuilder sb = new StringBuilder();
sb.append(target.getClass().getName());
sb.append(method.getName());
for (Object obj : params) {
sb.append(obj.toString());
}
return sb.toString();
}
};

}

/*要启用spring缓存支持,需创建一个 CacheManager的 bean，CacheManager 接口有很多实现，这里Redis 的集成，用 RedisCacheManager这个实现类
Redis 不是应用的共享内存，它只是一个内存服务器，就像 MySql 似的，
我们需要将应用连接到它并使用某种“语言”进行交互，因此我们还需要一个连接工厂以及一个 Spring 和 Redis 对话要用的 RedisTemplate，
这些都是 Redis 缓存所必需的配置，把它们都放在自定义的 CachingConfigurerSupport 中
*/
@Bean
public CacheManager cacheManager(
@SuppressWarnings("rawtypes") RedisTemplate redisTemplate) {
RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
//        cacheManager.setDefaultExpiration(60);//设置缓存保留时间（seconds）
return cacheManager;
}

//1.项目启动时此方法先被注册成bean被spring管理
@Bean
public RedisTemplate<String, String> redisTemplate(
RedisConnectionFactory factory) {StringRedisTemplate template = new StringRedisTemplate(factory);
Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
template.setValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();
return template;
}
}

三：redis的三个常用注解 @Cacheable  @CacheEvict  @CachePut

　　1：@Cacheable：当重复使用相同参数调用方法的时候，方法本身不会被调用执行，即方法本身被略过了，取而代之的是方法的结果直接从缓存中找到并返回了。

　　实验：在业务逻辑实现方法上加上次注解

　　其中value指的是要放在哪一个数据缓存里面

　　　　key指的就是一个键

@Override
@Cacheable(value="db0",key="T(String).valueOf(#userid)")//把userid转换为string类型的
public List<GhTest> getGhTestByID(int userid) {
// TODO Auto-generated method stub
System.out.println("aaaaaaa");
return dao.getGhTestByID(userid);
}

 　　对接口进行测试

　　　执行第一次控制台输出aaaaa　　　　　　　　redis里面新建一个键值对

　　再次测试，则不再输出aaaaa 说明数据是在缓存中所取。运行的步骤其实也就是，当@Cacheable接收到key value的时候先在value中找是不是存在key，如果不存在则在value中新建key 数据值为这个方法的返回值。如果存在则方法不执行从缓存中读取值。

　　2：@CacheEvict

@Override
@CacheEvict(value = "db0", key ="T(String).valueOf(#userid)")
public int deleteTest(int userid) {
// TODO Auto-generated method stub
return dao.deleteTest(userid);
}

　　使用接口测试发现，会删除掉数据库和缓存里面的值。可以在@CacheEvict 里面添加condition 表达式，让其满足什么条件的时候才删除缓存。

　　3：@CachePut

　　在测试这个修改的时候我遇到了问题，那就是我们平常写的修改和添加返回值一般都是int类型的，也就倒置了缓存里面存的值都是添加或者是修改的行数，并不是真实的数据。

　　例如，

@Override
@CachePut(value = "db0", key ="T(String).valueOf(#test.userid)")
public int updateTest(GhTest test) {
// TODO Auto-generated method stub
return dao.updateTest(test);
}

 　测试新增一条记录，userid为20，查看发现redis缓存里面是1，而不是userid为20的数据记录

　　上面也说了，redis里面存的值，是方法的返回值，我们方法的返回值是int，是被影响的行数。所以会存进去1，那要对方法进行修改。

　　解决方案就是，新建方法，把新增或者修改和查询结合这使用。

@Override
@CachePut(value = "db0", key ="T(String).valueOf(#test.userid)")
public List<GhTest> insertTest2(GhTest test) {
// TODO Auto-generated method stub
insertTest(test);
List<GhTest> list=getGhTestByID(test.getUserid());
return list;
}
@Override
@CachePut(value = "db0", key ="T(String).valueOf(#test.userid)")
public List<GhTest> updateTest2(GhTest test) {
// TODO Auto-generated method stub
updateTest(test);
List<GhTest> list=getGhTestByID(test.getUserid());
return list;
}

　　再次进行测试，先对20那条记录进行修改，在进行id查询，如果不通过数据库查询就说明成功了。

　　发现缓存中的值已经被修改，而且根据id查询也是通过缓存查询。