Redis学习（一）数据类型、Java中使用redis、缓存概念

常用数据结构

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中。

 @Override
 public 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);
     //返回ok
     return 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对象的key
    String tokenKey = LOGIN_USER_KEY + token;
    // 存入redis
    stringRedisTemplate.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;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
    
        // 1.获取请求头中的token
        String 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数据转为UserDTO
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 6.存在，保存用户信息到 ThreadLocal
        UserHolder.saveUser(userDTO);
        // 7.刷新token有效期
        stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
        // 8.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    
    
        // 移除用户
        UserHolder.removeUser();
    }
}

校验登录状态拦截器：

public class LoginInterceptor implements HandlerInterceptor {
    
    

    @Override
    public 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 {
    
    

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public 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)));
    // 写入Redis
    stringRedisTemplate.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) {
    
    
        // 将空值写入redis
        stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
        // 返回错误信息
        return null;
    }
    // 6.存在，写入redis
    this.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;
    }

附件商铺 - GEO数据结构

示例

1、添加北京的三个火车站坐标，key为g1

GEOADD g1 116.378248 39.865275 bjn 116.42803 39.903738 bjz 116.322287 39.893729 bjx

在Redis中保存的数据结构为ZSET，经纬度被编码为score哈希值

2、计算北京西到北京南的距离：

GEODIST g1 bjx bjn km

3、搜索天安门（116.397904 39.909005）附件10km内所有的火车站，并且按照距离升序排序。

GEODIST g1 FROMLONLAT 116.397904 39.909005 BYRADIUS 10 km

附件商铺

需求：搜索某个类型的店铺，按照距离返回店铺列表：

数据库中的店铺信息：

Redis存储思路：

controller层接口：

service层实现：