注：redis服务器要先开启! 或者连接远程服务器上的 Redis,但是依然要开启服务，不然会一直 TimeOut!
Pom文件添加依赖
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
配置 application.properties
# redis
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=20
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=10
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=1000
缓存测试
配置文件写完之后基础环境也算是已经搭建好了，开始测试使用 Test
接下来 我们测试上代码：
//注入redisTemplate
@Autowired
private StringRedisTemplate redisTemplate;
/**
* 存入缓存键 key：value
* first ：siwei
* second：siweiWu （30秒过期时间）
*/
@Test
public void setRedis() {
//缓存中最常用的方法
redisTemplate.opsForValue().set("first","siwei");
//设置缓存过期时间为30 单位：秒
//关于TimeUnit下面有部分源码截图
redisTemplate.opsForValue().set("second","siweiWu",30, TimeUnit.SECONDS);
System.out.println("存入缓存成功");
}
/**
* 根据key 获取 value
*/
@Test
public void getRedis(){
String first = redisTemplate.opsForValue().get("first");
String second = redisTemplate.opsForValue().get("second");
System.out.println("取出缓存中first的数据是:"+first);
System.out.println("取出缓存中second的数据是:"+second);
}
/**
* 根据key 删除缓存
*/
@Test
public void delRedis() {
//根据key删除缓存
Boolean first = redisTemplate.delete("first");
System.out.println("是否删除成功:"+first);
}
项目开发使用
贴上公司日常项目开发中使用的缓存服务层代码（可直接拷贝使用，我把包也贴出来，自行导包奥～
请原谅我不会折叠代码,MarkDown语法的小菜鸡一枚～）
- RedisService 服务层接口代码
import org.springframework.data.redis.core.ListOperations;
import java.util.List;
import java.util.Set;
/**
* @author wusw
* @date 2020/4/16 13:11
*/
public interface RedisService {
/**
* 添加 key:string 缓存
*
* @param key key
* @param value value
* @param time time
* @return
*/
boolean cacheValue(String key, String value, long time);
/**
* 添加 key:string 缓存
*
* @param key key
* @param value value
* @return
*/
boolean cacheValue(String key, String value);
/**
* 根据 key:string 判断缓存是否存在
*
* @param key key
* @return boolean
*/
boolean containsValueKey(String key);
/**
* 判断缓存 key:set集合 是否存在
*
* @param key key
* @return
*/
boolean containsSetKey(String key);
/**
* 判断缓存 key:list集合 是否存在
*
* @param key key
* @return boolean
*/
boolean containsListKey(String key);
/**
* 查询缓存 key 是否存在
* @param key key
* @return true/false
*/
boolean containsKey(String key);
/**
* 根据 key 获取缓存value
*
* @param key key
* @return value
*/
String getValue(String key);
/**
* 根据 key 移除 value 缓存
*
* @param key key
* @return true/false
*/
boolean removeValue(String key);
/**
* 根据 key 移除 set 缓存
*
* @param key key
* @return true/false
*/
boolean removeSet(String key);
/**
* 根据 key 移除 list 缓存
*
* @param key key
* @return true/false
*/
boolean removeList(String key);
/**
* 缓存set操作
*
* @param key key
* @param value value
* @param time time
* @return boolean
*/
boolean cacheSet(String key, String value, long time);
/**
* 添加 set 缓存
*
* @param key key
* @param value value
* @return true/false
*/
boolean cacheSet(String key, String value);
/**
* 添加 缓存 set
*
* @param k key
* @param v value
* @param time 时间
* @return
*/
boolean cacheSet(String k, Set<String> v, long time);
/**
* 缓存 set
* @param k key
* @param v value
* @return
*/
boolean cacheSet(String k, Set<String> v);
/**
* 获取缓存set数据
* @param k key
* @return set集合
*/
Set<String> getSet(String k);
/**
* list 缓存
* @param k key
* @param v value
* @param time 时间
* @return true/false
*/
boolean cacheList(String k, String v, long time);
/**
* 缓存 list
* @param k key
* @param v value
* @return true/false
*/
boolean cacheList(String k, String v);
/**
* 缓存 list 集合
* @param k key
* @param v value
* @param time 时间
* @return
*/
boolean cacheList(String k, List<String> v, long time);
/**
* 缓存 list
* @param k key
* @param v value
* @return true/false
*/
boolean cacheList(String k, List<String> v);
/**
* 根据 key 获取 list 缓存
* @param k key
* @param start 开始
* @param end 结束
* @return 获取缓存区间内 所有value
*/
List<String> getList(String k, long start, long end);
/**
* 根据 key 获取总条数 用于分页
* @param key key
* @return 条数
*/
long getListSize(String key);
/**
* 获取总条数 用于分页
* @param listOps =redisTemplate.opsForList();
* @param k key
* @return size
*/
long getListSize(ListOperations<String, String> listOps, String k);
/**
* 根据 key 移除 list 缓存
* @param k key
* @return
*/
boolean removeOneOfList(String k);
}
- RedisServiceImpl 服务层实现类代码
import com.technologies.bear.service.RedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import java.util.List;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* @author wusw
* @date 2020/4/16 13:11
*/
@Service
public class RedisServiceImpl implements RedisService {
/**
* slf4j 日志
*/
private final Logger log = LoggerFactory.getLogger(this.getClass());
/**
* 自定义 key 三种
* String key:String value 普通key:value
* String key:Set<String> set key:set集合
* String key:List<String> list key:list集合
*/
private static final String KEY_PREFIX_KEY = "info:bear:key";
private static final String KEY_PREFIX_SET = "info:bear:set";
private static final String KEY_PREFIX_LIST = "info:bear:list";
private final RedisTemplate<String, String> redisTemplate;
/**
* 注入
* @param redisTemplate 模板
*/
@Autowired
public RedisServiceImpl(RedisTemplate<String, String> redisTemplate) {
this.redisTemplate = redisTemplate;
}
/**
* 添加 key:string 缓存
*
* @param k key
* @param v value
* @param time time
* @return
*/
@Override
public boolean cacheValue(String k, String v, long time) {
try {
String key = KEY_PREFIX_KEY + k;
ValueOperations<String, String> ops = redisTemplate.opsForValue();
ops.set(key, v);
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Throwable e) {
log.error("缓存存入失败key:[{}] value:[{}]", k, v);
}
return false;
}
/**
* 添加 key:string 缓存
*
* @param key key
* @param value value
* @return
*/
@Override
public boolean cacheValue(String key, String value) {
return cacheValue(key, value, -1);
}
/**
* 根据 key:string 判断缓存是否存在
*
* @param key key
* @return boolean
*/
@Override
public boolean containsValueKey(String key) {
return containsKey(KEY_PREFIX_KEY + key);
}
/**
* 判断缓存 key:set集合 是否存在
*
* @param key key
* @return
*/
@Override
public boolean containsSetKey(String key) {
return containsKey(KEY_PREFIX_SET + key);
}
/**
* 判断缓存 key:list集合 是否存在
*
* @param key key
* @return boolean
*/
@Override
public boolean containsListKey(String key) {
return containsKey(KEY_PREFIX_LIST + key);
}
/**
* 查询缓存 key 是否存在
* @param key key
* @return true/false
*/
@Override
public boolean containsKey(String key) {
try {
return redisTemplate.hasKey(key);
} catch (Throwable e) {
log.error("判断缓存存在失败key:[" + key + "],错误信息 Codeor[{}]", e);
}
return false;
}
/**
* 根据 key 获取缓存value
*
* @param key key
* @return value
*/
@Override
public String getValue(String key) {
try {
ValueOperations<String, String> ops = redisTemplate.opsForValue();
return ops.get(KEY_PREFIX_KEY + key);
} catch (Throwable e) {
log.error("根据 key 获取缓存失败，当前key:[{}],失败原因 Codeor:[{}]", key, e);
}
return null;
}
/**
* 缓存set操作
*
* @param k key
* @param v value
* @param time time
* @return boolean
*/
@Override
public boolean cacheSet(String k, String v, long time) {
try {
String key = KEY_PREFIX_SET + k;
SetOperations<String, String> opsForSet = redisTemplate.opsForSet();
opsForSet.add(key, v);
if (time > 0) {
redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
return true;
} catch (Throwable e) {
log.error("缓存 set 失败 当前 key:[{}] 失败原因 [{}]", k, e);
}
return false;
}
/**
* 添加 set 缓存
*
* @param key key
* @param value value
* @return true/false
*/
@Override
public boolean cacheSet(String key, String value) {
return cacheSet(key, value, -1);
}
/**
* 添加 缓存 set
*
* @param k key
* @param v value
* @param time 时间
* @return
*/
@Override
public boolean cacheSet(String k, Set<String> v, long time) {
try {
String key = KEY_PREFIX_SET + k;
SetOperations<String, String> opsForSet = redisTemplate.opsForSet();
opsForSet.add(key, v.toArray(new String[v.size()]));
if (time > 0){
redisTemplate.expire(key,time,TimeUnit.SECONDS);
}
return true;
} catch (Throwable e) {
log.error("缓存 set 失败 当前 key:[{}],失败原因 [{}]", k, e);
}
return false;
}
/**
* 缓存 set
* @param k key
* @param v value
* @return
*/
@Override
public boolean cacheSet(String k, Set<String> v) {
return cacheSet(k,v,-1);
}
/**
* 获取缓存set数据
* @param k key
* @return set集合
*/
@Override
public Set<String> getSet(String k) {
try {
String key = KEY_PREFIX_SET + k;
SetOperations<String, String> opsForSet = redisTemplate.opsForSet();
return opsForSet.members(key);
}catch (Throwable e){
log.error("获取缓存set失败 当前 key:[{}],失败原因 [{}]", k, e);
}
return null;
}
/**
* list 缓存
* @param k key
* @param v value
* @param time 时间
* @return true/false
*/
@Override
public boolean cacheList(String k, String v, long time) {
try {
String key = KEY_PREFIX_LIST + k;
ListOperations<String, String> opsForList = redisTemplate.opsForList();
//此处为right push 方法/ 也可以 left push ..
opsForList.rightPush(key,v);
if (time > 0){
redisTemplate.expire(key,time,TimeUnit.SECONDS);
}
return true;
}catch (Throwable e){
log.error("缓存list失败 当前 key:[{}],失败原因 [{}]", k, e);
}
return false;
}
/**
* 缓存 list
* @param k key
* @param v value
* @return true/false
*/
@Override
public boolean cacheList(String k, String v) {
return cacheList(k,v,-1);
}
/**
* 缓存 list 集合
* @param k key
* @param v value
* @param time 时间
* @return
*/
@Override
public boolean cacheList(String k, List<String> v, long time) {
try {
String key = KEY_PREFIX_LIST + k;
ListOperations<String, String> opsForList = redisTemplate.opsForList();
opsForList.rightPushAll(key,v);
if (time > 0){
redisTemplate.expire(key,time,TimeUnit.SECONDS);
}
return true;
}catch (Throwable e){
log.error("缓存list失败 当前 key:[{}],失败原因 [{}]", k, e);
}
return false;
}
/**
* 缓存 list
* @param k key
* @param v value
* @return true/false
*/
@Override
public boolean cacheList(String k, List<String> v) {
return cacheList(k,v,-1);
}
/**
* 根据 key 获取 list 缓存
* @param k key
* @param start 开始
* @param end 结束
* @return 获取缓存区间内 所有value
*/
@Override
public List<String> getList(String k, long start, long end) {
try {
String key = KEY_PREFIX_LIST + k;
ListOperations<String, String> opsForList = redisTemplate.opsForList();
return opsForList.range(key,start,end);
}catch (Throwable e){
log.error("获取list缓存失败 当前 key:[{}],失败原因 [{}]", k, e);
}
return null;
}
/**
* 根据 key 获取总条数 用于分页
* @param key key
* @return 条数
*/
@Override
public long getListSize(String key) {
try {
ListOperations<String, String> opsForList = redisTemplate.opsForList();
return opsForList.size(KEY_PREFIX_LIST + key);
}catch (Throwable e){
log.error("获取list长度失败key[" + KEY_PREFIX_LIST + key + "], Codeor[" + e + "]");
}
return 0;
}
/**
* 获取总条数 用于分页
* @param listOps =redisTemplate.opsForList();
* @param k key
* @return size
*/
@Override
public long getListSize(ListOperations<String, String> listOps, String k) {
try {
return listOps.size(k);
}catch (Throwable e){
log.error("获取list长度失败key[" + KEY_PREFIX_LIST + k + "], Codeor[" + e + "]");
}
return 0;
}
/**
* 根据 key 移除 list 缓存
* @param k key
* @return
*/
@Override
public boolean removeOneOfList(String k) {
try {
String key = KEY_PREFIX_LIST + k;
ListOperations<String, String> opsForList = redisTemplate.opsForList();
opsForList.rightPop(key);
return true;
}catch (Throwable e){
log.error("移除list缓存失败 key[" + KEY_PREFIX_LIST + k + "], Codeor[" + e + "]");
}
return false;
}
/**
* 根据 key 移除 value 缓存
*
* @param key key
* @return true/false
*/
@Override
public boolean removeValue(String key) {
return remove(KEY_PREFIX_KEY + key);
}
/**
* 根据 key 移除 set 缓存
*
* @param key key
* @return true/false
*/
@Override
public boolean removeSet(String key) {
return remove(KEY_PREFIX_SET + key);
}
/**
* 根据 key 移除 list 缓存
*
* @param key key
* @return true/false
*/
@Override
public boolean removeList(String key) {
return remove(KEY_PREFIX_LIST + key);
}
/**
* 移除缓存
*
* @param key key
* @return boolean
*/
private boolean remove(String key) {
try {
redisTemplate.delete(key);
return true;
} catch (Throwable e) {
log.error("移除缓存失败 key:[{}] 失败原因 [{}]", key, e);
}
return false;
}
}
注：其他 Service 层使用时，只需要将 RedisService 注入即可像普通Service层一样调用
常用方法总结
StringRedisTemplate相关方法我也总结了一下，可能不是很全 不过还是够用了
//SpringDataRedis 使用说明
stringRedisTemplate.opsForValue().get("test");//根据key获取缓存中的val
stringRedisTemplate.boundValueOps("test").increment(-1);// val-1
stringRedisTemplate.boundValueOps("test").increment(1);// val+ 1
stringRedisTemplate.getExpire("test");//根据key获取过期时间
stringRedisTemplate.getExpire("test", TimeUnit.SECONDS);//根据key获取过期时间并换算成指定单位
stringRedisTemplate.delete("test");//根据ky删除缓存
stringRedisTemplate.hasKey("546545");//检查key是否存在,返回boolean 值
stringRedisTemplate.expire("red123", 1000, TimeUnit.MILLISECONDS); //设置过期时间
stringRedisTemplate.opsForSet().add("red123,1,", "1", "2", "3");//向指定key中存放set集合
stringRedisTemplate.opsForSet().isMember("red123", "1");//根据ky查看集合中是否存在指定数据
stringRedisTemplate.opsForSet().members("red123");//根据key获取set集合
TimeUnit源码
上面设置缓存过期时间的TimeUnit源码 部分截图说明(后面会附上全部的源码——总390行，)：
NANOSECONDS：纳秒/十亿分之一秒
MICROSECONDS：微秒
............
转载：(55条消息) spring boot整合redis,设置缓存过期时间_一只Black的博客-CSDN博客_springboot设置redis过期时间