自定义Redis工具类Java
简介redis
Redis支持五种数据类型:string(字符串),hash(哈希),list(列表),set(集合)及zset(sorted set:有序集合)
工具类方法简介
工具类操作的数据类型都为字符串,
工具类包含: 1.切换库方法 、2.通过key获取redis内容String、3.获取全部keys、
4.通过正则获取匹配的keys、5.通过keys获取多个结果集、6.通过keys获取多个结果集实体、
7.通过key删除内容、8.保存key和value值、9.保存key和value值同时设置保存时长(参数默认为秒)、
10.保存key和value值同时设置保存时长(时间参数0:秒 ;1:分; 2:时; 3:天; 其他值 默认 秒)、
11.保存key和自定义对象 设置保存时长、12.保存key和自定义对象集合 设置保存时长、
13.保存key和自定义对象 设置保存时长(保存可设置一段范围内随机值 如 5到10分钟内的随机值)、
14. 通过key获取自定义对象、15.通过key获取自定义对象集合
配置文件
使用的是springboot ,yml编写redis配置如下:
server:
port: 6666
spring:
# redis settings
redis:
host: 127.0.0.1
port: 6379
database: 1
timeout: 0
核心工具类代码
工具类代码如下:
package cn.wys.utils;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.lang.StringUtils;
import org.json.JSONArray;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;
import javax.annotation.PostConstruct;
import javax.annotation.Resource;
import java.util.*;
import java.util.concurrent.TimeUnit;
/**
* @program: Service
* @description redis工具
* @author: wys
* @create: 2020-09-06 09:10
**/
@Component
public class RedisServiceUtils {
private Logger log = LoggerFactory.getLogger(this.getClass());
@Autowired
private StringRedisTemplate stringRedisTemplate;
/**
* 默认数据库
*/
@Value("${spring.redis.database}")
private Integer dbIndex;
@Resource
private ObjectMapper objectMapper;
@PostConstruct
public void init() {
//改变切换库
changeDatabase(dbIndex);
}
/**
* 改变切换库
*
* @param indexDb redis库
*/
private void changeDatabase(int indexDb) {
try {
JedisConnectionFactory connectionFactory = (JedisConnectionFactory) stringRedisTemplate.getConnectionFactory();
//当前库 与要切换的库不相等 则切换
if (connectionFactory.getDatabase() != indexDb) {
connectionFactory.setDatabase(indexDb);
}
} catch (Exception e) {
log.error("RedisServiceUtils.changeDatabase() indexDb:" + indexDb, e);
}
}
/**
* 获取key
*
* @param indexDb redis库
* @param key 查询key
* @return 返回value
*/
public String getRedis(int indexDb, String key) {
try {
changeDatabase(indexDb);
Object o = stringRedisTemplate.opsForValue().get(key);
if (o != null) {
String string = o.toString();
if (StringUtils.isNotEmpty(string)) {
return string;
}
}
} catch (Exception e) {
log.error("RedisServiceUtils.getRedis() indexDb:" + indexDb + "\r\n" +
"key:" + key, e);
}
return null;
}
/**
* 获取当前redis库中所有的key
*
* @param indexDb redis库
* @return
*/
public Set<String> getKeys(int indexDb) {
try {
return getKeys(indexDb, "*");
} catch (Exception e) {
log.error("RedisServiceUtils.getKeys() indexDb:" + indexDb + "\r\n" +
"key: *", e);
}
return null;
}
/**
* 获取当前redis库中符合正则的key
*
* @param indexDb redis库
* @return
*/
public Set<String> getKeys(int indexDb, String pattern) {
try {
changeDatabase(indexDb);
Set<String> keys = stringRedisTemplate.keys(pattern);
if (keys != null && keys.size() > 0) {
return keys;
}
} catch (Exception e) {
log.error("RedisServiceUtils.getKeys() indexDb:" + indexDb + "\r\n" +
"pattern: " + pattern, e);
}
return null;
}
/**
* 通过keys获取多个结果集
*
* @param indexDb redis库
* @return
*/
public List<String> multiGet(int indexDb, List<String> keys) {
try {
changeDatabase(indexDb);
List<String> list = stringRedisTemplate.opsForValue().multiGet(keys);
if (list != null && list.size() > 0) {
return list;
}
} catch (Exception e) {
log.error("RedisServiceUtils.multiGet() indexDb:" + indexDb + "\r\n" +
"key: " + keys, e);
}
return null;
}
/**
* 通过keys获取多个结果集对象
*
* @param indexDb redis库
* @return
*/
public <T> List<T> multiGetType(int indexDb, List<String> keys, Class<T> valueType) {
try {
changeDatabase(indexDb);
List<String> list = stringRedisTemplate.opsForValue().multiGet(keys);
if (list != null && list.size() > 0) {
List<T> tempList = new ArrayList<>(list.size());
for (String s : list) {
tempList.add(objectMapper.readValue(s, valueType));
}
return tempList;
}
} catch (Exception e) {
log.error("RedisServiceUtils.multiGetType() indexDb:" + indexDb + "\r\n" +
"key: " + keys, e);
}
return null;
}
/**
* 删除key
*
* @param key
*/
public void delRedis(int indexDb, String key) {
try {
changeDatabase(indexDb);
stringRedisTemplate.delete(key);
} catch (Exception e) {
log.error("RedisServiceUtils.delRedis() indexDb:" + indexDb + "\r\n" +
"key:" + key
, e);
}
}
/**
* 设置key 和 value
*
* @param key
* @param value
*/
public void setRedis(int indexDb, String key, String value) {
try {
changeDatabase(indexDb);
stringRedisTemplate.opsForValue().set(key, value);
} catch (Exception e) {
log.error("RedisServiceUtils.setRedis() indexDb:" + indexDb + "\r\n" +
"key:" + key + "\r\n" +
"value:" + value, e);
}
}
/**
* 设置key value和时间
*
* @param key
* @param value
* @param time
*/
public void setRedis(int indexDb, String key, String value, Integer time) {
try {
changeDatabase(indexDb);
stringRedisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} catch (Exception e) {
log.error("RedisServiceUtils.setRedis() indexDb:" + indexDb + "\r\n" +
"key:" + key + "\r\n" +
"value:" + value + "\r\n" +
"time:" + time, e);
}
}
/**
* 设置key value 时间和时间单位
*
* @param key
* @param value
* @param time
* @param timeUnitInt 0:秒 ;1:分; 2:时; 3:天; 其他值 默认 秒
*/
public void setRedisTime(int indexDb, String key, String value, Integer time, Integer timeUnitInt) {
try {
changeDatabase(indexDb);
TimeUnit timeUnit = setTimeUtil(timeUnitInt);
stringRedisTemplate.opsForValue().set(key, value, time, timeUnit);
} catch (Exception e) {
log.error("RedisServiceUtils.setRedisTime() indexDb:" + indexDb + "\r\n" +
"key:" + key + "\r\n" +
"value:" + value + "\r\n" +
"time:" + time + "\r\n" +
"timeUnitInt:" + timeUnitInt
, e);
}
}
/**
* 设置key value 时间和时间单位
* 保存 泛型
*
* @param key
* @param value
* @param time
* @param timeUnitInt 0:秒 ;1:分; 2:时; 3:天; 其他值 默认 秒
*/
public <T> void setRedisTime(int indexDb, String key, T value, Integer time, Integer timeUnitInt) {
try {
changeDatabase(indexDb);
TimeUnit timeUnit = setTimeUtil(timeUnitInt);
String redisValue = objectMapper.writeValueAsString(value);
stringRedisTemplate.opsForValue().set(key, redisValue, time, timeUnit);
} catch (Exception e) {
log.error("RedisServiceUtils.setRedisTime() indexDb:" + indexDb + "\r\n" +
"key:" + key + "\r\n" +
"value:" + value + "\r\n" +
"time:" + time + "\r\n" +
"timeUnitInt:" + timeUnitInt
, e);
}
}
/**
* 设置key value 时间和时间单位
* 保存 泛型集合
*
* @param key
* @param values
* @param time
* @param timeUnitInt 0:秒 ;1:分; 2:时; 3:天; 其他值 默认 秒
*/
public <T> void setRedisTime(int indexDb, String key, List<T> values, Integer time, Integer timeUnitInt) {
try {
changeDatabase(indexDb);
TimeUnit timeUnit = setTimeUtil(timeUnitInt);
String redisValue = objectMapper.writeValueAsString(values);
stringRedisTemplate.opsForValue().set(key, redisValue, time, timeUnit);
} catch (Exception e) {
log.error("RedisServiceUtils.setRedisTime() indexDb:" + indexDb + "\r\n" +
"key:" + key + "\r\n" +
"values:" + values + "\r\n" +
"time:" + time + "\r\n" +
"timeUnitInt:" + timeUnitInt
, e);
}
}
/**
* 设置key value 时间和时间单位
* 保存 泛型集合
*
* @param key
* @param values
* @param startTime
* @param endTime
* @param timeUnitInt 0:秒 ;1:分; 2:时; 3:天; 其他值 默认 秒
*/
public <T> void setRedisTimeRandom(int indexDb, String key, Collection<T> values, Integer startTime, Integer endTime, Integer timeUnitInt) {
try {
//切换库
changeDatabase(indexDb);
//获取随机保存时间
Integer randomTime = getRandom(startTime, endTime);
// 传入Integer值 返回 TimeUnit时间类型
TimeUnit timeUnit = setTimeUtil(timeUnitInt);
//转json
String redisValue = objectMapper.writeValueAsString(values);
//保存
stringRedisTemplate.opsForValue().set(key, redisValue, randomTime, timeUnit);
} catch (Exception e) {
log.error("RedisServiceUtils.setRedisTime() indexDb:" + indexDb + "\r\n" +
"key:" + key + "\r\n" +
"values:" + values + "\r\n" +
"startTime:" + startTime + "\r\n" +
"endTime:" + endTime + "\r\n" +
"timeUnitInt:" + timeUnitInt
, e);
}
}
/**
* 传入Integer值 返回 TimeUnit时间类型
*
* @param timeUnitInt 0:秒 ;1:分; 2:时; 3:天; 其他值 默认 秒
* @return
*/
private TimeUnit setTimeUtil(Integer timeUnitInt) {
TimeUnit timeUnit = null;
if (timeUnitInt == null) {
timeUnitInt = 0;
}
switch (timeUnitInt) {
case 1:
timeUnit = TimeUnit.MINUTES;
break;
case 2:
timeUnit = TimeUnit.HOURS;
break;
case 3:
timeUnit = TimeUnit.DAYS;
break;
default:
timeUnit = TimeUnit.SECONDS;
}
return timeUnit;
}
/**
* @param indexDb redis 库 默认 spring.redis.database
* @param redisKey redis key
* @param valueType 返回集合的 类型
* @param <T> 泛型
* @return
*/
public <T> T getRedisValue(Integer indexDb, String redisKey, Class<T> valueType) {
try {
//默认redis 库
if (indexDb == null) {
indexDb = dbIndex;
}
//通过key 获取redis 内容
String redis = getRedis(indexDb, redisKey);
if (StringUtils.isBlank(redis)) {
//key不存在 或失效返回 null
return null;
}
T item = objectMapper.readValue(redis, valueType);
return item;
} catch (Exception e) {
log.error("RedisServiceUtils.getRedisValue() indexDb:" + indexDb + "\r\n" +
"redisKey:" + redisKey + "\r\n" +
"valueType:" + valueType + "\r\n", e);
}
return null;
}
/**
* @param indexDb redis 库 默认 spring.redis.database
* @param redisKey redis key
* @param valueType 返回集合的 类型
* @param <T> 泛型
* @return
*/
public <T> List<T> getRedisValueList(Integer indexDb, String redisKey, Class<T> valueType) {
try {
//默认redis 库
if (indexDb == null) {
indexDb = dbIndex;
}
//通过key 获取redis 内容
String redis = getRedis(indexDb, redisKey);
if (StringUtils.isBlank(redis)) {
//key不存在 或失效返回 null
return null;
}
//解析
JSONArray redisJsonArray = new JSONArray(redis);
List<T> redisList = new ArrayList<>(redisJsonArray.length());
//封装
for (int i = 0; i < redisJsonArray.length(); i++) {
T item = objectMapper.readValue(redisJsonArray.getString(i), valueType);
redisList.add(item);
}
//返回
return redisList;
} catch (Exception e) {
log.error("RedisServiceUtils.getRedisValueList() indexDb:" + indexDb + "\r\n" +
"redisKey:" + redisKey + "\r\n" +
"valueType:" + valueType + "\r\n", e);
}
return null;
}
private Integer getRandom(Integer start, Integer end) {
//创建Random类对象
Random random = new Random();
//产生随机数
int number = random.nextInt(end - start + 1) + start;
//打印随机数
log.info("RedisServiceUtils.getRandom() start:" + start + "\r\n" +
"end:" + end + "\r\n" +
"return number:" + number);
return number;
}
}
maven引入
pom.xml如果没有引入的话可以按照以下引入:
<!--redis start-->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>2.9.0</version>
</dependency>
<!--redis end-->