Redis非关系型数据库

Redis通用命令

• KEYS：查看符合模板的所有key

• TTL：查看一个KEY的剩余有效期

Key层级结构

Redis的key允许有多个单词形成层级结构，多个单词之间用':'隔开，格式如下：

项目名:业务名:类型:id

String类型

• SET：添加或者修改已经存在的一个String类型的键值对

• GET：根据key获取String类型的value

• MSET：批量添加多个String类型的键值对

• MGET：根据多个key获取多个String类型的value

• INCR：让一个整型的key自增1

• INCRBY:让一个整型的key自增并指定步长，例如：incrby num 2 让num值自增2

• INCRBYFLOAT：让一个浮点类型的数字自增并指定步长

• SETNX：添加一个String类型的键值对，前提是这个key不存在，否则不执行

• SETEX：添加一个String类型的键值对，并且指定有效期

hashmap类型 

• HSET key field value：添加或者修改hash类型key的field的值

• HGET key field：获取一个hash类型key的field的值

• HMSET：批量添加多个hash类型key的field的值

• HMGET：批量获取多个hash类型key的field的值

• HGETALL：获取一个hash类型的key中的所有的field和value

• HKEYS：获取一个hash类型的key中的所有的field

• HINCRBY:让一个hash类型key的字段值自增并指定步长

• HSETNX：添加一个hash类型的key的field值，前提是这个field不存在，否则不执行

List类型

类似Java中的双向链表

• LPUSH key element ... ：向列表左侧插入一个或多个元素

• LPOP key：移除并返回列表左侧的第一个元素，没有则返回nil

• RPUSH key element ... ：向列表右侧插入一个或多个元素

• RPOP key：移除并返回列表右侧的第一个元素

• LRANGE key star end：返回一段角标范围内的所有元素

• BLPOP和BRPOP：与LPOP和RPOP类似，只不过在没有元素时等待指定时间，而不是直接返回nil

 Set类型

• SADD key member ... ：向set中添加一个或多个元素

• SREM key member ... : 移除set中的指定元素

• SCARD key： 返回set中元素的个数

• SISMEMBER key member：判断一个元素是否存在于set中

• SMEMBERS：获取set中的所有元素

• SINTER key1 key2 ... ：求key1与key2的交集

• SDIFF key1 key2 ... ：求key1与key2的差集

• SUNION key1 key2 ..：求key1和key2的并集

Zset类型

可以用在排行榜

• ZADD key score member：添加一个或多个元素到sorted set ，如果已经存在则更新其score值

• ZREM key member：删除sorted set中的一个指定元素

• ZSCORE key member : 获取sorted set中的指定元素的score值

• ZRANK key member：获取sorted set 中的指定元素的排名

• ZCARD key：获取sorted set中的元素个数

• ZCOUNT key min max：统计score值在给定范围内的所有元素的个数

• ZINCRBY key increment member：让sorted set中的指定元素自增，步长为指定的increment值

• ZRANGE key min max：按照score排序后，获取指定排名范围内的元素

• ZRANGEBYSCORE key min max：按照score排序后，获取指定score范围内的元素

• ZDIFF.ZINTER.ZUNION：求差集.交集.并集

注意：所有的排名默认都是升序，如果要降序则在命令的Z后面添加REV即可，例如：

• 升序获取sorted set 中的指定元素的排名：ZRANK key member

• 降序获取sorted set 中的指定元素的排名：ZREVRANK key memeber

  zrevrange student 0 2 排名前三的学生

 SrpingDataRedis

 使用步骤

1.导入pom依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.9.0</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>

 <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-pool2</artifactId>
</dependency>

2.配置文件

spring:
  redis:
    host: 47.96.151.25
    port: 6379
    password: lyt123456
    lettuce:
      pool:
        max-active: 8  #最大连接
        max-idle: 8   #最大空闲连接
        min-idle: 0   #最小空闲连接
        max-wait: 100ms #连接等待时间

3.测试

 @Autowired
    private RedisTemplate redisTemplate;

    @Test
    void test() {
        redisTemplate.opsForValue().set("name","lyt");
        System.out.println(redisTemplate.opsForValue().get("name"));
    }

 StringRedisTemplate (常用)

@SpringBootTest
public class Test3 {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Test
    void test() {
        User user = new User("吕怡婷", 12);
        String json = JSON.toJSONString(user);
        stringRedisTemplate.opsForValue().set("user",json);
        String user1 = stringRedisTemplate.opsForValue().get("user");
        User user2 = JSON.parseObject(user1, User.class);
        System.out.println(user2);
    }
}

redis实战

代码位置：D:\本地项目\redis

项目一：短信登录

功能

通过redis实现共享session登录

知识点

•  redis中key的取名要保证唯一性和方便携带提取数据（例如：存验证码时使用phone:111作为key，用户信息时通过token:uuid作为key）
• 实现HandlerInterceptor接口完成接口的拦截

实现方式

项目二：商户查询redis缓存

缓存的概念

缓存就是数据交换的缓冲区（称作Cache），是存贮数据的临时地方，一般读写性能较高。

功能

• 给商铺类型加上redis缓存
• 给商品详情信息加上redis缓存

缓存更新策略

业务场景：

• 低一致性需求：使用内存淘汰机制。例如店铺类型的查询缓存
• 高一致性需求：主动更新，并以超时剔除作为兜底方案。例如店铺详情查询的缓存

缓存更新策略的最佳实践方案：

低一致性需求：使用 Redis 自带的内存淘汰机制

高一致性需求：主动更新，并以超时剔除作为兜底方案

• 读操作：

1. 缓存命中则直接返回
2. 缓存未命中则查询数据库，并写入缓存，设定超时时

• 写操作：

1. 先写数据库
2. 然后再删除缓存
3. 要确保数据库与缓存操作的原子性 

缓存穿透

概念

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

解决方案

缓存空对象

优点：实现简单，维护方便

缺点：额外的内存消耗、可能造成短期的不一致

布隆过滤

优点：内存占用较少，没有多余key

缺点：实现复杂、存在误判可能

缓存穿透的解决方案有哪些？

缓存null值、布隆过滤、增强id的复杂度，避免被猜测id规律、做好数据的基础格式校验、加强用户权限校验、做好热点参数的限流

缓存雪崩

概念

缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力 

解决方式

解决方案：

给不同的Key的TTL添加随机值

利用Redis集群提高服务的可用性

给缓存业务添加降级限流策略

给业务添加多级缓存

缓存击穿

概念

缓存击穿问题也叫热点Key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。

解决方案

互斥锁

设置逻辑过期

缓存工具封装 

import cn.hutool.core.util.BooleanUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.function.Function;

import static com.hmdp.utils.RedisConstants.CACHE_NULL_TTL;
import static com.hmdp.utils.RedisConstants.LOCK_SHOP_KEY;

@Slf4j
@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;
    }

    /**
     * 
     * @param key
     * @param value
     * @param time
     * @param unit
     */
    public void set(String key, Object value, Long time, TimeUnit unit) {
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    }

    /**
     * 设置逻辑过期时间
     * @param key
     * @param value
     * @param time
     * @param unit
     */
    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));
    }

    /**
     * 缓存穿透：设置过期时间
     * @param keyPrefix
     * @param id
     * @param type
     * @param dbFallback
     * @param time
     * @param unit
     * @param <R>
     * @param <ID>
     * @return
     */
    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;
    }

    /**
     * 缓存击穿：设置逻辑过期时间
     * @param keyPrefix
     * @param id
     * @param type
     * @param dbFallback
     * @param time
     * @param unit
     * @param <R>
     * @param <ID>
     * @return
     */
    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;
    }

    /**
     * 缓存击穿：互斥锁
     * @param keyPrefix
     * @param id
     * @param type
     * @param dbFallback
     * @param time
     * @param unit
     * @param <R>
     * @param <ID>
     * @return
     */
    public <R, ID> R queryWithMutex(
            String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
        String key = keyPrefix + id;
        // 1.从redis查询商铺缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);
        // 2.判断是否存在
        if (StrUtil.isNotBlank(shopJson)) {
            // 3.存在，直接返回
            return JSONUtil.toBean(shopJson, type);
        }
        // 判断命中的是否是空值
        if (shopJson != null) {
            // 返回一个错误信息
            return null;
        }

        // 4.实现缓存重建
        // 4.1.获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        R r = null;
        try {
            boolean isLock = tryLock(lockKey);
            // 4.2.判断是否获取成功
            if (!isLock) {
                // 4.3.获取锁失败，休眠并重试
                Thread.sleep(50);
                return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
            }
            // 4.4.获取锁成功，根据id查询数据库
            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);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            // 7.释放锁
            unlock(lockKey);
        }
        // 8.返回
        return r;
    }

    /**
     * 加锁
     * @param key
     * @return
     */
    private boolean tryLock(String key) {
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        return BooleanUtil.isTrue(flag);
    }

    /**
     * 解锁
     * @param key
     */
    private void unlock(String key) {
        stringRedisTemplate.delete(key);
    }
}

项目三：优惠卷秒杀

redis生成全局id

使用redis自增的特性实现全局id

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;

@Component
public class RedisIdWorker {
    /**
     * 开始时间戳
     */
    private static final long BEGIN_TIMESTAMP = 1640995200L;
    /**
     * 序列号的位数
     */
    private static final int COUNT_BITS = 32;

    private StringRedisTemplate stringRedisTemplate;

    public RedisIdWorker(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    public long nextId(String keyPrefix) {
        // 1.生成时间戳
        LocalDateTime now = LocalDateTime.now();
        long nowSecond = now.toEpochSecond(ZoneOffset.UTC);
        long timestamp = nowSecond - BEGIN_TIMESTAMP;

        // 2.生成序列号
        // 2.1.获取当前日期，精确到天
        String date = now.format(DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        // 2.2.自增长
        long count = stringRedisTemplate.opsForValue().increment("icr:" + keyPrefix + ":" + date);

        // 3.拼接并返回
        return timestamp << COUNT_BITS | count;
    }
}

  @Test
    void testIdWorker() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(300);

        Runnable task = () -> {
            for (int i = 0; i < 100; i++) {
                long id = redisIdWorker.nextId("order");
                System.out.println("id = " + id);
            }
            latch.countDown();
        };
        long begin = System.currentTimeMillis();
        for (int i = 0; i < 300; i++) {
            es.submit(task);
        }
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("time = " + (end - begin));
    }

 乐观锁解决超卖

• 版本号实现
• 库存实现

一人只能下单一次功能

在单体系统中通过使用synchronized锁对用户进行上锁实现该功能，在分布式系统中使用redis实现分布式锁

public class RedisLock implements ILock {

   private String name;
   private StringRedisTemplate stringRedisTemplate;
   public static  final  String LOCK_PREFIX="lock:";

    public RedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean tryLock(long timeOut) {
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(LOCK_PREFIX + name, Thread.currentThread().getName()+"", timeOut, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(aBoolean);
    }

    @Override
    public void unLocK() {
        stringRedisTemplate.delete(LOCK_PREFIX + name);
    }
}

redis分布式锁误删

在以上的分布式锁代码中可能会出现误删别的线程的锁

解决方案：

1. 给线程value添加一个 UUID-线程ID
2. 在删除锁时判断redis中的value值和当前线程是否相同

redis实现代码原子性

主要通过redis执行Lua脚本 

-- 比较线程标示与锁中的标示是否一致
if(redis.call('get', KEYS[1]) ==  ARGV[1]) then
    -- 释放锁 del key
    return redis.call('del', KEYS[1])
end
return 0

package com.hmdp.service.impl;

import com.hmdp.service.ILock;
import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;

import java.util.Collections;
import java.util.concurrent.TimeUnit;

public class RedisLock implements ILock {

   private String name;
   private StringRedisTemplate stringRedisTemplate;
   public static  final  String LOCK_PREFIX="lock:";
    private static final String UUID = cn.hutool.core.lang.UUID.randomUUID().toString(true);
    private static final DefaultRedisScript<Long> REDIS_SCRIPT;
static {
    REDIS_SCRIPT = new DefaultRedisScript<>();
    REDIS_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
    REDIS_SCRIPT.setResultType(Long.class);
}
    public RedisLock(String name, StringRedisTemplate stringRedisTemplate) {
        this.name = name;
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean tryLock(long timeOut) {
        Boolean aBoolean = stringRedisTemplate.opsForValue().setIfAbsent(LOCK_PREFIX + name, UUID+Thread.currentThread().getName(), timeOut, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(aBoolean);
    }

    @Override
    public void unLocK() {

        stringRedisTemplate.execute(REDIS_SCRIPT,
                Collections.singletonList(LOCK_PREFIX + name),
                UUID + Thread.currentThread().getName());
//        String redisValue = stringRedisTemplate.opsForValue().get(LOCK_PREFIX + name);
//        String curValue =UUID+ Thread.currentThread().getName();
//        if (redisValue.equals(curValue)){
//            stringRedisTemplate.delete(LOCK_PREFIX + this.name);
//        }
    }
}

Redisson

使用步骤

引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.20.0</version>
</dependency>

完成配置

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class RedissionConfig {
    @Bean
    public RedissonClient redissonClient(){
        Config config = new Config();
        config.useSingleServer().setAddress("redis://47.96.151.25:6379").setPassword("lyt123");
        return Redisson.create(config);
    }
}

 测试

   @Autowired
    RedissonClient redissonClient;

实现原理

redisson主要解决了三个自定锁的问题

• 可重入：利用hash结构记录线程id和重入次数
• 可重试：利用信号量和PubSub功能实现等待，唤醒，获取锁失败的重试机制
• 超时续约：利用watchDog看门狗，每隔一段时间重置超时时间