Redis学习（一）数据类型、Java中使用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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

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);
}
1
2
3
4
5
6
7

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();
 }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

校验登录信息

@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();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

校验登录状态

基于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();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

校验登录状态拦截器：

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;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

拦截器注册：
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);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

商家查询缓存

使用缓存，加速查询过程。

缓存更新策略

缓存穿透

缓存穿透是指客户端请求的数据在缓冲中和数据库中都不存在，这样缓存永远不会生效，这些请求都会打到数据库中。

基于缓存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
2
3
4
5
6
7
8
9
10
11

方法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);
    }
1
2
3

方法2：将java对象序列化为json并存放在string类型的key中，并可以设置逻辑过期时间：

逻辑过期时间，需要在原对象的基础上加一个逻辑过期属性字段expire，表示逻辑过期时间，具体实现可以构建一个RedisData类，该类中封装有一个对象成员，和一个逻辑过期属性成员。

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}
1
2
3
4
5

构建好了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));
}
}
1
2
3
4
5
6
7
8
9

方法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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

方法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);
}
1
2
3
4
5
6
7
8

有了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;
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44

附件商铺 - GEO数据结构

示例

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

GEOADD g1 116.378248 39.865275 bjn 116.42803 39.903738 bjz 116.322287 39.893729 bjx
1

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

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

GEODIST g1 bjx bjn km
1

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

GEODIST g1 FROMLONLAT 116.397904 39.909005 BYRADIUS 10 km
1

附件商铺

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

数据库中的店铺信息：

Redis存储思路：

controller层接口：

service层实现：