添加依赖：
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
lt;/dependency>application.properties:
#redis配置
spring.redis.database=0
spring.redis.host=127.0.0.1
spring.redis.port=6379
spring.redis.password=123
spring.redis.pool.max-idle=8
spring.redis.pool.min-idle=0
spring.redis.pool.max-active=8
spring.redis.pool.max-wait=-1
spring.redis.timeout=5000配置类：
@Configuration
/**开启SpringBoot支持的缓存功能 使用Nosql或者数据库的时候 当查询的时候会缓存数据*/
@EnableCaching
public class RedisConfig {
@Bean
public CacheManager cacheManager(RedisTemplate<?,?> redisTemplate) {
CacheManager cacheManager = new RedisCacheManager(redisTemplate);
return cacheManager;
}
@Primary
@Bean
public RedisTemplate<String, Object> redisTemplate(JedisConnectionFactory factory) {
/**spring data redis 提供多个序列化器 序列化转成json*/
/* RedisTemplate 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;*/
RedisTemplate<String, Object> redisTemplate = new RedisTemplate
<String, Object>();
redisTemplate.setConnectionFactory(factory);
return redisTemplate;
}
@Bean
public StringRedisTemplate stringRedisTemplate(JedisConnectionFactory factory) {
StringRedisTemplate stringRedisTemplate = new StringRedisTemplate();
stringRedisTemplate.setConnectionFactory(factory);
return stringRedisTemplate;
}
}
redis提供两种序列化方式：
一种是String的序列化策略（RedisTemplate）可以保存对象，一种是JDK的序列化策略（StringRedisTemplate）操作String数据。
除此之外：spring data redis 提供多个序列化器
GenericToStringSerializer：使用 Spring 转换服务进行序列化；
JacksonJsonRedisSerializer：使用 Jackson 1，将对象序列化为 JSON；
Jackson2JsonRedisSerializer：使用 Jackson 2，将对象序列化为 JSON；
JdkSerializationRedisSerializer：使用 Java 序列化；
OxmSerializer：使用 Spring O/X 映射的编排器和解排器（marshaler 和 unmarshaler）实
现序列化，用于 XML 序列化；
StringRedisSerializer：序列化 String 类型的 key 和 value。
redis的五种数据结构：
ValueOperations：字符串类型操作
ListOperations：列表类型操作
SetOperations：集合类型操作
ZSetOperations：有序集合类型操作
HashOperations：散列操作spring 封装了 RedisTemplate 对象来进行对redis的各种操作，它支持所有的 redis 原生的 api。
RedisTemplate中定义了对5种数据结构操作
1 redisTemplate.opsForValue();//操作字符串
2 redisTemplate.opsForHash();//操作hash
3 redisTemplate.opsForList();//操作list
4 redisTemplate.opsForSet();//操作set
5 redisTemplate.opsForZSet();//操作有序set
BoundValueOperations：字符串类型操作
BoundListOperations：列表类型操作
BoundSetOperations：集合类型操作
BoundZSetOperations：有序集合类型操作
BoundHashOperations：散列操作BoundValueOperations<String, String> valueOperations = stringRedisTemplate.boundValueOps("key");
BoundListOperations<String, String> listOperations = stringRedisTemplate.boundListOps("key");
BoundSetOperations<String, String> setOperations = stringRedisTemplate.boundSetOps("key");
BoundZSetOperations<String, String> zSetOperations = stringRedisTemplate.boundZSetOps("key");
BoundHashOperations<String, Object, Object> hashOperations = stringRedisTemplate.boundHashOps("key");redisTemplate有两个方法经常用到,一个是opsForXXX一个是boundXXXOps,XXX是value的类型,前者获取到一个Opercation,但是没有指定操作的key,可以在一个连接(事务)内操作多个key以及对应的value;后者会获取到一个指定了key的operation,在一个连接内只操作这个key对应的value.
Service:
@Service
public class RedisService {
/**
* StringRedisTemplate
* 也可以是RedisTemplate template;
* 只是两种序列化策略不同
* 一种是String的序列化策略，储存String类型数据
* 一种是JDK的序列化策略。可以存储对象类型数据
**/
@Autowired
StringRedisTemplate stringRedisTemplate;
@Autowired
RedisTemplate template;
/**
* 存储对象
*/
public void addUser(String key, User user) {
template.opsForValue().set(key, user);
}
/**
* 存储String数据
*/
public void addString(String key, String string) {
stringRedisTemplate.opsForValue().set(key, string);
}
/**
* 获取对象
*/
public User getUser(String key) {
User user = (User) template.opsForValue().get(key);
return user;
}
/**
* 获取String
*/
public String getString(String key) {
String str = stringRedisTemplate.opsForValue().get(key);
return str;
}
/**
* 获取String
*/
public String getString2(String key) {
/**和前面的方法一样 只不过绑定了key*/
BoundValueOperations<String, String> boundValueOperations = stringRedisTemplate.boundValueOps(key);
String str = boundValueOperations.get();
return str;
}
/**
* 存储String设置过期时间
*/
public String addStringLimitTime(String key, String value) {
/** 3秒过期*/
stringRedisTemplate.opsForValue().set(key, value, 3, TimeUnit.SECONDS);
return "ok";
}
/**
* 删除redis存储所有的数据
*/
public void delete() {
Set<String> set = stringRedisTemplate.keys("*");
System.out.println(set.size());
stringRedisTemplate.delete(set);
System.out.println("删除成功");
}
/**
* 删除redis存储所有的数据
*/
public void delete2() {
Set<String> set = template.keys("*");
System.out.println(set.size());
template.delete(set);
System.out.println("删除成功");
}
}
Controller测试：
@Controller
public class RedisController {
@Autowired
RedisService redisService;
/**
* 存储对象测试
*/
@RequestMapping("/addUser")
@ResponseBody
public String addUser() {
User user = new User(1, "A", "123");
redisService.addUser("userA", user);
return "ok";
}
/**
* 获取对象测试
*/
@RequestMapping("/getUser")
@ResponseBody
public User getUser() {
User user = redisService.getUser("userA");
return user;
}
/**
* 存储String测试
*/
@RequestMapping("/addString")
@ResponseBody
public String addString() {
redisService.addString("str1", "String1");
return "ok";
}
/**
* 获取String测试
*/
@RequestMapping("/getString")
@ResponseBody
public String getString() {
String string = redisService.getString("str1");
return string;
}
/**
* 获取String测试
*/
@RequestMapping("/getString2")
@ResponseBody
public String getString2() {
String string = redisService.getString2("str1");
return string;
}
/**
* 过期时间测试
*/
@RequestMapping("/addLimitTime")
@ResponseBody
public String addLimitTime() {
String string = redisService.addStringLimitTime("time", "timeValue");
return string;
}
/**
* 过期时间测试
*/
@RequestMapping("/getLimitTime")
@ResponseBody
public String getLimitTime() {
String string = redisService.getString("time");
return string;
}
/**清除缓存*/
@RequestMapping("/remove")
@ResponseBody
public String delete(){
redisService.delete();
return "ok";
}
}