文章目录
- 常用数据结构
- String类型
- Hash类型
- List类型
- Set类型
- SortedSet 类型
- 通用命令
- key的层级结构
- Spring Data Redis
- 快速入门
- RedisTemplate的序列化方式
- StringRedisTemplate
- RedisTemplate的Hash类型操作
- 实战操作
- 短信登录
- 发送验证码
- 校验登录信息
- 校验登录状态
- 商家查询缓存
- 缓存更新策略
- 缓存穿透
- 缓存雪崩
- 缓存击穿
- 缓存工具封装
常用数据结构
String类型
Hash类型
List类型
List可以看做是一个双向链表结构,既可以支持正向检索,也可以支持反向检索。
链表的特点是插入和删除效率快,常用来存储有序的、需频繁插入和删除的数据,例如朋友圈点赞列表,评论列表等。
Set类型
注意:这里的set是无序的!
# 存放数据
sadd zs lisi wangwu zhaoliu
sadd ls wangwu mazi ergou# 查询张三好友数
scard zs# 计算张三和李四有哪些共同好友
sinter zs ls# 是张三好友不是李四好友
sdiff zs ls# 查询张三和李四的好友共有哪些人
sunion zs ls# 判断李四是否为张三好友
sismember zs ls# 将李四从张三的好友列表中删除
srem zs ls
SortedSet 类型
通用命令
- keys:查看符合模板的所有key
- del:删除一个key,可以空格跟多个key,批量删除
- exists:判断key是否存在
- expire:给一个key设置有效期(单位为秒),有效期到期时,该key会自动删除
- TTL:查看一个key的剩余有效期,-1表示永久有效。
key的层级结构
Redis的key允许有多个单词形成的层级结构,多个单词之间用:
隔开。
Spring Data Redis
spring data redis 是redis的Java客户端的一种实现,它整合Lettuce和Jedis。
快速入门
1、 引入依赖
2、配置文件
3、注入RedisTemplate
在依赖的启动器中会自动地依赖自动配置,自动配种会将需要的类注册到IoC容器中。
4、编写测试案例
RedisTemplate的序列化方式
RedisTemplate的默认序列化方式会将存储内容转为字节码,如果我们想要实现所见即所存,可以自定义序列化方法。
经过配置,我们不仅可以存中文字符串,亦可以存入对象,RedisTemplate会自动帮助我们把对象序列化为json,并在使用时反序列化为对象。
StringRedisTemplate
从上边存放的对象可以看出,为了实现能够自动反序列化对象,在redis中不仅存入了对象的json序列,还存放了对象的字节码类型名。这就带来了额外的存储开销!!!
为了节省内存空间,我们并不会使用JSON序列化器来处理value,而是统一使用String序列化器,要求只能存储String类型的key和value,当需要存储Java对象时,手动完成对象的序列化和反序列化。
RedisTemplate的Hash类型操作
opsForHash是针对Hash类型的数据操作的API函数。
实战操作
短信登录
发送验证码
controller层:
/**
* 发送手机验证码
*/
@PostMapping("code")
public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {return userService.sedCode(phone,session);
}
service层:
将验证码code保存在Redis中。
@Overridepublic Result sedCode(String phone, HttpSession session) {//1. 校验手机号if (RegexUtils.isPhoneInvalid(phone)) {//2.如果不符合,返回错误信息return Result.fail("手机号格式错误");}//3. 符合,生成验证码String code = RandomUtil.randomNumbers(6);//4. 保存验证码到Redis,并设置有效期stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);//5. 发送验证码log.debug("发送短信验证码成功,验证码:{}",code);//返回okreturn Result.ok();}
校验登录信息
@Override
public Result login(LoginFormDTO loginForm, HttpSession session) {//1. 校验手机号String phone = loginForm.getPhone();if (RegexUtils.isPhoneInvalid(phone)) {return Result.fail("手机号格式错误");}//2. 从redis中获取并校验验证码Object cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);String code = loginForm.getCode();if (cacheCode == null || !cacheCode.toString().equals(code)){//3. 不一致,报错return Result.fail("验证码错误");}//4.一致,根据手机号查询用户User user = query().eq("phone", phone).one();//5. 判断用户是否存在if (user == null){//6. 不存在,创建新用户user = createUserWithPhone(phone);}//7.保存用户信息到Redis,并随机生成token令牌,将User对象转为Hash存储,并设置token有效期String token = UUID.randomUUID().toString(true);// 只保存user中非敏感信息UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);// 使用hash存储,因此把对象转为map,由于id字段为Long类型,而redis存放字符串类型,因此需要类型转换Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(), CopyOptions.create().setIgnoreNullValue(true).setFieldValueEditor((fileName, fileValue) -> fileValue.toString()));// 存放在redis中的user对象的keyString tokenKey = LOGIN_USER_KEY + token;// 存入redisstringRedisTemplate.opsForHash().putAll(tokenKey, userMap);// 设置有效期stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);return Result.ok();
}
校验登录状态
基于springmvc的拦截器校验登录状态,如果检测到登录状态,需要刷新token有效期。这些操作使用拦截器来实现。
多个拦截器的执行顺序:
拦截器接口中的三个方法:
- preHandle:controller层之前
- postHandle:controller方法执行之后,视图渲染返回前
- afterComplete:视图渲染完毕
刷新拦截器放在前边:
public class RefreshTokenInterceptor implements HandlerInterceptor {private StringRedisTemplate stringRedisTemplate;public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {this.stringRedisTemplate = stringRedisTemplate;}@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {// 1.获取请求头中的tokenString token = request.getHeader("authorization");if (StrUtil.isBlank(token)) {return true;}// 2.基于TOKEN获取redis中的用户String key = LOGIN_USER_KEY + token;Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);// 3.判断用户是否存在if (userMap.isEmpty()) {return true;}// 5.将查询到的hash数据转为UserDTOUserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);// 6.存在,保存用户信息到 ThreadLocalUserHolder.saveUser(userDTO);// 7.刷新token有效期stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);// 8.放行return true;}@Overridepublic void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {// 移除用户UserHolder.removeUser();}
}
校验登录状态拦截器:
public class LoginInterceptor implements HandlerInterceptor {@Overridepublic boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {//1. 从threadLocal中判断是否有user,有就放行,没有就拦截if (UserHolder.getUser() == null) {// 没有需要拦截response.setStatus(401);return false;}//2. 有user放行return true;}
}
拦截器注册:
order越小,优先级越高
public class MvcConfig implements WebMvcConfigurer {@Resourceprivate StringRedisTemplate stringRedisTemplate;@Overridepublic void addInterceptors(InterceptorRegistry registry) {// 登录拦截器registry.addInterceptor(new LoginInterceptor()).excludePathPatterns("/shop/**","/voucher/**","/shop-type/**","/upload/**","/blog/hot","/user/code","/user/login").order(1);// token刷新拦截器registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);}
}
商家查询缓存
使用缓存,加速查询过程。
缓存更新策略
缓存穿透
缓存穿透是指客户端请求的数据在缓冲中和数据库中都不存在,这样缓存永远不会生效,这些请求都会打到数据库中。
基于缓存null,可能会导致存放了一些无用信息,造成额外内存开销,可以通过给缓存设置较短的TTL,缓解这种情况。
缓存雪崩
缓存雪崩是指在同一时间段,大量的缓存key同时失效或者Redis服务宕机,导致大量请求到达数据库,带来巨大访问压力。
解决方案:
- 给不同的key的TTL添加随机值,避免同时大量缓存过期
- 利用Redis集群,提高服务的可用性
- 给缓存业务添加降级限流策略,当出现大量缓存失效时,做服务降级限流,牺牲部分服务
- 给业务添加多级缓存
缓存击穿
缓存击穿问题也称为热点key问题,就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了(热点key失效),无数的请求访问会在瞬间给数据库带来巨大的冲击。
解决方法主要有两种:
1、互斥锁:
重建缓存的过程上锁,其他没有拿到锁的线程会阻塞,相互等待。这种做法简单粗暴,多个线程相互等待锁释放。
互斥锁的代码实现上,可以使用redis的setnx
指令:
setnx:set if not exist,仅当不存在时才设置。
这样,假如我们指定一个字段key,lock
,那么多个线程想要设置这个key时,只有第一个线程会设置成功。
这样就模拟了锁的获取。
如果要释放锁,那么即可将该字段删除。
2、逻辑过期:
在缓存中保存一个逻辑上的有效期字段“expire”。
第一个发现缓存过期,获取到锁的线程,会开启一个新的线程来执行缓存重建过程,而自己直接返回过期的缓存。其余没有拿到锁的线程,在缓存重建成功之前,都会拿到过期缓存,他们不阻塞等待,直接返回过期缓存。
逻辑过期策略解决缓存击穿问题,可能会返回过期缓存,适用于弱一致性缓存策略。
缓存击穿一般出现在活动期间,出现突然的访问高峰时,因此逻辑缓存字段“expire”可以在活动结束后移除
互斥锁线程需要等待,性能受影响,但数据是强一致性的。
逻辑过期,线程无需等待,性能更好,但可能返回过期缓存,属于弱一致性。
缓存工具封装
首先构建这样一个CacheClient,作为缓存工具类:
设置需要的线程池(缓存击穿,执行逻辑过期策略时需要),StringRedisTemplate(redis操作需要)。
在构造函数时,需要传入stringRedisTemplate。
@Component
public class CacheClient {private final StringRedisTemplate stringRedisTemplate;private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);public CacheClient(StringRedisTemplate stringRedisTemplate) {this.stringRedisTemplate = stringRedisTemplate;}
}
方法1:将java对象序列化为json并存放在string类型的key中,并可以设置TTL时间:
主要需要注意的点在于,对象的序列化,使用hutool工具包的JSONUtil.toJsonStr(value)
将对象转为JsonStr。
public void set(String key, Object value, Long time, TimeUnit unit) {stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);}
方法2:将java对象序列化为json并存放在string类型的key中,并可以设置逻辑过期时间:
逻辑过期时间,需要在原对象的基础上加一个逻辑过期属性字段expire
,表示逻辑过期时间,具体实现可以构建一个RedisData
类,该类中封装有一个对象成员,和一个逻辑过期属性成员。
@Data
public class RedisData {private LocalDateTime expireTime;private Object data;
}
构建好了RedisData类,那么方法2实现逻辑就与方法1一致了,只是逻辑过期对象是永久存在的。
public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {// 设置逻辑过期RedisData redisData = new RedisData();redisData.setData(value);redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));// 写入RedisstringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
}
}
方法3:根据指定的key查询缓存,使用缓存空值的方式来应对缓存穿透问题。
使用泛型来封装函数,指定两个泛型类型,R表示查询的对象类型,ID表示存储对象的id类型。另外,假如缓存未命中,需要查询数据库,这个查询数据库的过程也需要调用者提供,因此,函数参数中有一个函数接口类型,
Function<ID, R> dbFallback,表示一个入参为ID类型,返回值类型为R的函数。
可以直接使用dbFallback的apply()方法,执行。
关于缓存穿透,如果数据库中查询结果为null,将null值缓存到redis,并返回错误信息。如果数据库查询结果非null,则将其缓存到redis。
public <R,ID> R queryWithPassThrough(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit){String key = keyPrefix + id;// 1.从redis查询商铺缓存String json = stringRedisTemplate.opsForValue().get(key);// 2.判断是否存在if (StrUtil.isNotBlank(json)) {// 3.存在,直接返回return JSONUtil.toBean(json, type);}// 判断命中的是否是空值if (json != null) {// 返回一个错误信息return null;}// 4.不存在,根据id查询数据库R r = dbFallback.apply(id);// 5.不存在,返回错误if (r == null) {// 将空值写入redisstringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);// 返回错误信息return null;}// 6.存在,写入redisthis.set(key, r, time, unit);return r;
}
方法4:根据指定的key查询缓存,使用逻辑过期的策略来应对缓存击穿问题。
首先,引入基于redis的setnx(如果没有则设置)模拟的上锁和解锁过程。
专门在redis中保存一个键值对来模拟锁对象,使用setnx,对应于stringRedisTemplate的selfIfAbsent()
方法,仅在缓存中不存在该键值对才能设置成功,相当于获取到锁对象。
private boolean tryLock(String key) {Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);return BooleanUtil.isTrue(flag);
}private void unlock(String key) {stringRedisTemplate.delete(key);
}
有了lock函数和unlock函数,方法4与方法3相比,多了如下操作:
- 获取到缓存对象时,需要去除逻辑过期“expire”字段,再返回
- 获取到缓存对象,需要判断是否逻辑上过期。
- 若缓存过期,在重建时,利用lock上锁函数,获取到锁,开启新的独立线程,从数据库中查询结果,重建缓存。
- 线程是异步执行的,非阻塞,直接返回过期的结果。
- 没有获取到锁的请求,直接返回过期缓存。
public <R, ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {String key = keyPrefix + id;// 1.从redis查询商铺缓存String json = stringRedisTemplate.opsForValue().get(key);// 2.判断是否存在if (StrUtil.isBlank(json)) {// 3.存在,直接返回return null;}// 4.命中,需要先把json反序列化为对象RedisData redisData = JSONUtil.toBean(json, RedisData.class);R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);LocalDateTime expireTime = redisData.getExpireTime();// 5.判断是否过期if(expireTime.isAfter(LocalDateTime.now())) {// 5.1.未过期,直接返回店铺信息return r;}// 5.2.已过期,需要缓存重建// 6.缓存重建// 6.1.获取互斥锁String lockKey = LOCK_SHOP_KEY + id;boolean isLock = tryLock(lockKey);// 6.2.判断是否获取锁成功if (isLock){// 6.3.成功,开启独立线程,实现缓存重建CACHE_REBUILD_EXECUTOR.submit(() -> {try {// 查询数据库R newR = dbFallback.apply(id);// 重建缓存this.setWithLogicalExpire(key, newR, time, unit);} catch (Exception e) {throw new RuntimeException(e);}finally {// 释放锁unlock(lockKey);}});}// 6.4.返回过期的商铺信息return r;}