SpringBoot中整合Redis缓存
背景：
工作中需要用到缓存 之前都是用ConcurrentHashMap 公司不让用redis 那我就小试牛刀一下
前端的App、网页在登录时，或是用户在进行一些敏感操作的时候需要进行短信验证。但是在等待用户输入验证码的这段时间里，这个随机生成的验证码在后台应该存放在哪里呢？
放在MySql数据库？可以的确是可以，但是如果用户访问量一下巨大起来，SQL读写面临高并发，会严重拖慢程序响应速度，甚至导致直接宕机。
那放在Session里？emmm好像也不行，执行效率过低，性价比不高。在多用户访问时似乎并不能很好的承担这一重任。
我们需要一个读写迅速，使用方便的工具。于是我们顺着思路，比磁盘读写速度更快的，那就是内存读写咯，于是Redis 数据库便浮现于脑海
知识库：
参考博客：
https://blog.csdn.net/qq_41997592/article/details/122866809
1.pom配置
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
2.yml配置
redis:
#数据库索引
database: 0
host: 127.0.0.1
port: 6379
password:
jedis:
pool:
#最大连接数
max-active: 8
#最大阻塞等待时间(负数表示没限制)
max-wait: -1
#最大空闲
max-idle: 8
#最小空闲
min-idle: 0
#连接超时时间
timeout: 10000
3.redis工厂配置
@Configuration
@EnableCaching
public class RedisConfig {
//编写我们自己的 RedisTemplate
@Bean
@SuppressWarnings("all")
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
//为了方便我们一般直接使用 <String,Object>
RedisTemplate<String, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
//配置具体的序列化方式
//Json序列化配置
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer =
new Jackson2JsonRedisSerializer<Object>(Object.class);
ObjectMapper om = new ObjectMapper();//通过mapper转义
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
//String 序列化配置
StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
//key采用String类型序列化
template.setKeySerializer(stringRedisSerializer);
//hash 也采用String 类型序列化
template.setHashKeySerializer(stringRedisSerializer);
//value 采用 jackson
template.setValueSerializer(jackson2JsonRedisSerializer);
//hash value jackson
template.setHashValueSerializer(jackson2JsonRedisSerializer);
template.afterPropertiesSet();//设置完成后 把所有的properties设置进去
return template;
}
}
4.redisUtil
/**
* Redis工具类<br>
* <b>使用方法：</b>直接在类中使用@Autowired方法注入即可
*/
@Slf4j
@Component
public final class RedisUtils {
/**
* 从 spring 容器中注入自定义的 redisTemplate
*/
private static RedisTemplate<String, Object> redisTemplate;
@Autowired
public RedisUtils(RedisTemplate<String, Object> redisTemplate1){
this.redisTemplate=redisTemplate1;
}
/**
* 对 redis 中指定键对应的数据设置失效时间
*
* @param key 键
* @param time 时间（秒），time要大于0
* @return
*/
public static boolean expire(String key, long time) {
boolean result = false;
try {
if (StringUtils.isNotBlank(key) && time > 0) {
result = redisTemplate.expire(key, time, TimeUnit.SECONDS);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return result;
}
/**
* 从 redis 中根据指定的 key 获取已设置的过期时间
*
* @param key 键，不能为null
* @return 时间（秒），返回0代表为永久有效
*/
public static long getExpire(String key) {
long time = 0L;
try {
if (StringUtils.isNotBlank(key)) {
time = redisTemplate.getExpire(key, TimeUnit.SECONDS);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return time;
}
/**
* 判断 redis 中是否存在指定的 key
*
* @param key 键，不能为null
* @return true表示存在，false表示不存在
*/
public static boolean exists(String key) {
boolean result = false;
try {
if (StringUtils.isNotBlank(key)) {
result = redisTemplate.hasKey(key);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return result;
}
/**
* 从 redis 中移除指定 key 对应的数据
*
* @param keys 可以传一个值或多个
*/
@SuppressWarnings("unchecked")
public static long remove(String... keys) {
long count = 0L;
if (keys != null && keys.length > 0) {
if (keys.length == 1) {
boolean result = redisTemplate.delete(keys[0]);
if (result) {
count = keys.length;
}
} else {
count = redisTemplate.delete(Arrays.asList(keys));
}
}
return count;
}
// ============================ String =============================
/**
* 从 redis 中获取指定 key 对应的 string 数据
*
* @param key 键，不能为null
* @return key 对应的字符串数据
*/
public static <T> T get(String key) {
T t = null;
try {
if (StringUtils.isNotBlank(key)) {
t = (T) redisTemplate.opsForValue().get(key);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return t;
}
/**
* 从 redis 中获取指定 key 对应的 string 数据，并转换为 T 类型
*
* @param key 键，不能为null
* @param clazz 类型，从 redis 获取后的对象直接转换为 T 类型
* @return key 对应的数据
*/
public static <T> T get(String key, Class<T> clazz) {
T t = null;
try {
if (StringUtils.isNotBlank(key)) {
String str = (String) redisTemplate.opsForValue().get(key);
t = stringToBean(str, clazz);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return null;
}
return t;
}
/**
* 判断 redis 中指定 key 的数据对应偏移位置的 bit 位是否为 1
*
* @param key 键，不能为null
* @param offset 偏移位置
* @return true表示存在，false表示不存在
*/
public static boolean getBit(String key, long offset) {
boolean result = false;
try {
if (StringUtils.isNotBlank(key)) {
result = redisTemplate.opsForValue().getBit(key, offset);
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return result;
}
/**
* 将指定的 key, value 放到 redis 中
*
* @param key 键，不能为null
* @param value 值，不能为null
* @return true表示成功，false表示失败
*/
public static <T> boolean set(String key, T value) {
boolean result = false;
try {
if (StringUtils.isNotBlank(key)) {
redisTemplate.opsForValue().set(key, value);
result = true;
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return result;
}
/**
* 将指定的 key, value 放到 redis 中，并设置过期时间
*
* @param key 键，不能为null
* @param value 值，不能为null
* @param time 时间（秒），time要大于0，如果time小于等于0，将设置无限期
* @return true表示成功，false表示失败
*/
public static <T> boolean set(String key, T value, long time) {
try {
if (time > 0) {
redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
} else {
set(key, value);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 将 redis 中指定 key 对应数据的偏移位置的 bit 位设置为 0/1
*
* @param key 键，不能为null
* @param offset 偏移位置
* @param flag true表示设置为1，false表示设置为0
* @return true表示成功，false表示失败
*/
public static boolean setBit(String key, long offset, boolean flag) {
boolean result = false;
try {
if (StringUtils.isNotBlank(key)) {
redisTemplate.opsForValue().setBit(key, offset, flag);
result = true;
}
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
}
return result;
}
/**
* 对 redis 中指定 key 的数据递增，并返回递增后的值
*
* @param key 键，不能为null
* @param delta 要增加几（大于0）
* @return
*/
public static long incr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0。");
}
return redisTemplate.opsForValue().increment(key, delta);
}
/**
* 对 redis 中指定 key 的数据递减，并返回递减后的值
*
* @param key 键，不能为null
* @param delta 要减少几（大于0）
* @return
*/
public static long decr(String key, long delta) {
if (delta < 0) {
throw new RuntimeException("递减因子必须大于0。");
}
return redisTemplate.opsForValue().decrement(key, delta);
}
// ================================ hashmap=================================
/**
* 判断 redis 中指定 key 对应的 hash 表中是否有 hashKey
*
* @param key 键，不能为null
* @param hashKey hash表中的键，不能为null
* @return true表示存在，false表示不存在
*/
public static boolean hexists(String key, String hashKey) {
return redisTemplate.opsForHash().hasKey(key, hashKey);
}
/**
* 从 redis 中获取指定 key 对应的 hash 表中的指定 hashKey 所对应的值
*
* @param key 键，不能为null
* @param hashKey hash表中的键，不能为null
* @return 值
*/
@SuppressWarnings("unchecked")
public static <T> T hget(String key, String hashKey) {
return (T) redisTemplate.opsForHash().get(key, hashKey);
}
/**
* 向 redis 中指定 key 对应的 hash 表（如果 hash 表不存在则自动创建）中放入 hashKey,value 数据
*
* @param key 键，不能为null
* @param hashKey hash表中的键，不能为null
* @param value 值，不能为null
* @return true表示成功，false表示失败
*/
public static <T> boolean hset(String key, String hashKey, T value) {
try {
redisTemplate.opsForHash().put(key, hashKey, value);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 向 redis 中指定 key 对应的 hash 表（如果 hash 表不存在则自动创建）中放入 hashKey,value 数据，并设置过期时间
*
* @param key 键，不能为null
* @param hashKey hash表中的键，不能为null
* @param value 值，不能为null
* @param time 过期时间（秒），注意:如果已存在的hash表有时间，这里将会替换原有的时间
* @return true表示成功，false表示失败
*/
public static <T> boolean hset(String key, String hashKey, T value, long time) {
try {
redisTemplate.opsForHash().put(key, hashKey, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 删除 redis 中指定 key 对应的 hash 表中等于 hashKeys 的数据
*
* @param key 键，不能为null
* @param hashKeys hash表中的键，可以使多个，不能为null
*/
public static <T> void hdel(String key, T... hashKeys) {
redisTemplate.opsForHash().delete(key, hashKeys);
}
/**
* 从 redis 中获取指定 key 对应的 hash 表，并返回相应的 map 对象
*
* @param key 键，不能为null
* @return map对象，包含所有的键值对
*/
public static Map<?, ?> hmget(String key) {
return redisTemplate.opsForHash().entries(key);
}
/**
* 向 redis 中放入指定 key，并设置对应的数据类型为 map
*
* @param key 键，不能为null
* @param map 多个键值对应的map，不能为null
* @return true表示成功，false表示失败
*/
public static boolean hmset(String key, Map<String, ?> map) {
try {
redisTemplate.opsForHash().putAll(key, map);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 向 redis 中放入指定 key，并设置对应的数据类型为 map 以及过期时间
*
* @param key 键，不能为null
* @param map 对应多个键值，不能为null
* @param time 时间（秒），time要大于0，如果time小于等于0，将设置无限期
* @return true表示成功，false表示失败
*/
public static boolean hmset(String key, Map<String, ?> map, long time) {
try {
redisTemplate.opsForHash().putAll(key, map);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 对 redis 中指定 key 对应的 hash 表（如果 hash 表不存在则自动创建）递增，并返回新增后的值
*
* @param key 键，不能为null
* @param item 项，不能为null
* @param delta 要增加几（大于0）
* @return 新增后的值
*/
public static double hincr(String key, String item, double delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0。");
}
return redisTemplate.opsForHash().increment(key, item, delta);
}
/**
* 对 redis 中指定 key 对应的 hash 表（如果 hash 表不存在则自动创建）递增，并返回新增后的值
*
* @param key 键，不能为null
* @param item 项，不能为null
* @param delta 要减少几（大于0）
* @return
*/
public static double hdecr(String key, String item, double delta) {
if (delta < 0) {
throw new RuntimeException("递增因子必须大于0。");
}
return redisTemplate.opsForHash().increment(key, item, -delta);
}
/**
* 从 redis 中移除指定 key 对应 hash 表中键为 values 的数据
*
* @param key 键，不能为null
* @param values 值，不能为null
* @return 移除的个数
*/
public static <T> long hremove(String key, T... values) {
try {
Long count = redisTemplate.opsForHash().delete(key, values);
return count;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
}
// ============================set=============================
/**
* 判断 redis 中是否存在指定 key 对应的 set 对象
*
* @param key 键，不能为null
* @param value 值，不能为null
* @return true表示存在，false表示不存在
*/
public static <T> boolean sexists(String key, T value) {
try {
return redisTemplate.opsForSet().isMember(key, value);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 从 redis 中根据指定 key 对应的值，并返回 set 对象
*
* @param key 键，不能为null
* @return
*/
public static Set<?> sget(String key) {
try {
return redisTemplate.opsForSet().members(key);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return null;
}
}
/**
* 向 redis 中放入指定 key 和数据，并设置其数据类型为 set
*
* @param key 键，不能为null
* @param values 值，不能为null
* @return 成功个数
*/
public static <T> long sset(String key, T... values) {
try {
return redisTemplate.opsForSet().add(key, values);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
}
/**
* 向 redis 中放入指定 key 和数据，并设置其数据类型为 set 以及过期时间
*
* @param key 键，不能为null
* @param time 过期时间（秒），注意:如果已存在的hash表有时间，这里将会替换原有的时间
* @param values 值，不能为null
* @return 成功个数
*/
public static <T> long sset(String key, long time, T... values) {
try {
Long count = redisTemplate.opsForSet().add(key, values);
if (time > 0) {
expire(key, time);
}
return count;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
}
/**
* 获取 redis 中指定 key 对应 set 的大小
*
* @param key 键，不能为null
* @return
*/
public static long ssize(String key) {
try {
return redisTemplate.opsForSet().size(key);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
}
/**
* 从 redis 中移除指定 key 对应 set 中键为 values 的数据
*
* @param key 键，不能为null
* @param values 值，不能为null
* @return 移除的个数
*/
public static <T> long sremove(String key, T... values) {
try {
Long count = redisTemplate.opsForSet().remove(key, values);
return count;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
}
// =============================== list =================================
/**
* 从 redis 中获取指定 key 对应 list 的大小
*
* @param key 键，不能为null
* @return
*/
public static long lsize(String key) {
try {
return redisTemplate.opsForList().size(key);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
}
/**
* 从 redis 中获取指定 key 对应 list 中 index 位置的值
*
* @param key 键，不能为null
* @param index 当index>=0时，0为表头，1为第二个元素，依次类推；当index<0时，-1为表尾，-2为倒数第二个元素，依次类推
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T lindex(String key, long index) {
try {
return (T) redisTemplate.opsForList().index(key, index);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return null;
}
}
/**
* 从 redis 中获取指定 key 对应 list 指定范围的值（start~end设置为0~-1将返回所有值）
*
* @param key 键，不能为null
* @param start 起始位置，0表示起始位置
* @param end 结束位置，-1表示结束位置
* @return
*/
public static List<?> lget(String key, long start, long end) {
try {
return redisTemplate.opsForList().range(key, start, end);
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return null;
}
}
/**
* 向 redis 中放入指定 key，并设置数组类型为 list，将 value 加入到 list 尾部
*
* @param key 键，不能为null
* @param value 值，不能为null
* @return
*/
public static <T> boolean lset(String key, T value) {
try {
redisTemplate.opsForList().rightPush(key, value);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 向 redis 中放入指定 key，并设置数组类型为 list，将 value 加入到 list 尾部，同时设置过期时间
*
* @param key 键，不能为null
* @param value 值，不能为null
* @param time 时间（秒），time要大于0，如果time小于等于0，将设置无限期
* @return
*/
public static <T> boolean lset(String key, T value, long time) {
try {
redisTemplate.opsForList().rightPush(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 向 redis 中放入指定 key，并设置数组类型为 list，并以 value 填入 list
*
* @param key 键，不能为null
* @param value 值，不能为null
* @return
*/
public static boolean lset(String key, List value) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 向 redis 中放入指定 key，并设置数组类型为 list，并以 value 填入 list，同时设置过期时间
*
* @param key 键，不能为null
* @param value 值，不能为null
* @param time 时间（秒），time要大于0，如果time小于等于0，将设置无限期
* @return
*/
public static boolean lset(String key, List value, long time) {
try {
redisTemplate.opsForList().rightPushAll(key, value);
if (time > 0) {
expire(key, time);
}
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 将 redis 中指定 key 对应的 list 数据中指定 index 位置的数据更新为 value
*
* @param key 键，不能为null
* @param index 索引
* @param value 值，不能为null
* @return
*/
public static <T> boolean lupdate(String key, long index, T value) {
try {
redisTemplate.opsForList().set(key, index, value);
return true;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return false;
}
}
/**
* 从 redis 中指定 key 对应的 list 中移除 n 个值为 value 的数据
*
* @param key 键，不能为null
* @param count 移除多少个
* @param value 值，不能为null
* @return 移除的个数
*/
public static <T> long lremove(String key, long count, T value) {
try {
Long remove = redisTemplate.opsForList().remove(key, count, value);
return remove;
} catch (Exception ex) {
log.error(ex.getMessage(), ex);
return 0;
}
}
/**
* 根据指定的类型转换字符串/JSON字符串为相应的对象
*
* @param value 字符串/JSON字符串
* @param clazz 类型
* @param <T> 任意类型
* @return
*/
@SuppressWarnings("unchecked")
public static <T> T stringToBean(String value, Class<T> clazz) {
if (value == null || value.length() <= 0 || clazz == null) {
return null;
}
if (clazz == byte.class || clazz == Byte.class) {
return (T) Byte.valueOf(value);
} else if (clazz == int.class || clazz == Integer.class) {
return (T) Integer.valueOf(value);
} else if (clazz == long.class || clazz == Long.class) {
return (T) Long.valueOf(value);
} else if (clazz == double.class || clazz == Double.class) {
return (T) Double.valueOf(value);
} else if (clazz == float.class || clazz == Float.class) {
return (T) Float.valueOf(value);
} else if (clazz == String.class) {
return (T) value;
} else {
return JSON.parseObject(value, clazz);
}
}
/**
* 将 bean 转换为字符串/JSON字符串
*
* @param value 任意类型对象
* @return 字符串/JSON字符串
*/
public static <T> String beanToString(T value) {
if (value == null) {
return null;
}
Class<?> clazz = value.getClass();
if (clazz == byte.class || clazz == Byte.class) {
return "" + value;
} else if (clazz == int.class || clazz == Integer.class) {
return "" + value;
} else if (clazz == long.class || clazz == Long.class) {
return "" + value;
} else if (clazz == double.class || clazz == Double.class) {
return "" + value;
} else if (clazz == float.class || clazz == Float.class) {
return "" + value;
} else if (clazz == String.class) {
return (String) value;
} else {
return JSON.toJSONString(value);
}
}
}