点评项目核心内容

package com.hmdp.utils;

import com.hmdp.dto.UserDTO;
import com.hmdp.entity.User;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       //1、获取session
        HttpSession session = request.getSession();
        //2、获取session中的用户
        Object user = session.getAttribute("user");
        //3、判断用户是否存在
        if (user == null) {
            //4、不存在，拦截，返回401状态码
            response.setStatus(401);
            return false;
        }
        //5、存在，保存用户信息到ThreadLocal
        UserHolder.saveUser((UserDTO) user);
        //6、放行
        return true;
    }

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

userhold类下

package com.hmdp.utils;

import com.hmdp.dto.UserDTO;

public class UserHolder {
    private static final ThreadLocal<UserDTO> tl = new ThreadLocal<>();

    public static void saveUser(UserDTO user){
        tl.set(user);
    }

    public static UserDTO getUser(){
        return tl.get();
    }

    public static void removeUser(){
        tl.remove();
    }
}

第二步：配置文件（让拦截器生效）

package com.hmdp.config;

import com.hmdp.utils.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration
public class MvcConfig  implements WebMvcConfigurer {
//配置，添加拦截器，让之前的拦截器生效
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
             //排除掉不需要拦截的路径
                .excludePathPatterns(
                      "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/usr/code",
                        "/usr/login"
                );
    }
}

集群的session共享问题

session共享问题：多态Tomcat并不共享session存储空间，当请求切换到不同tomcat服务是导致数据丢失问题

session的代替为redis，满足数据共享，内存存储key、value结构

基于redis实现共享session登录

保存登录的用户信息，可以使用String结构，以JSON字符串来保存，比较直观：

Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD，并且内存占用更少:

创建bean对象技巧

自己创建的类，无法直接用@Autowire方式注入，因为他不属于 spring容器管理的。

需要在创建的加入一个构造方法，然后在由其他由spring管理的类调用，然后在注入传入这个属性即可

@Configuration
public class MvcConfig  implements WebMvcConfigurer {
//由spring管理的类注册
    @Resource
    private StringRedisTemplate stringRedisTemplate;

//配置，添加拦截器，让之前的拦截器生效
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
       //调用时传入这个即可
        registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
        
    }

public class LoginInterceptor implements HandlerInterceptor {

private StringRedisTemplate stringRedisTemplate;

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

什么是缓存

缓存就是数据交换的缓冲区（称作Cache，是存储数据的临时笛梵，一般读写性能较高）

使用缓存来处理对象

 //1、从redis查询商铺缓存，使用opsForValue接受对象，返回的是json串
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        //2、判断是否存在
        if (StrUtil.isNotBlank(shopJson)){
            //3、存在，直接返回缓存中的
               //是json数据，则需要通过JSONUtil返回指定的对象即可
            Shop shop= JSONUtil.toBean(shopJson, Shop.class);
            return  Result.ok(shop);
        }
        //4、缓存中不存在，根据id查询数据库
        Shop shop = this.getById(id);
        //5、数据库中不存在，返回错误
        if (shop==null){
            return Result.fail("商铺不存在");
        }
        //6、存在，写入缓存
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(shop));
       //7、返回

使用String类型缓存来处理集合

@Resource
private StringRedisTemplate stringRedisTemplate;
    @Override
    public Result shopTypeList() {
        String key="shop_Type_List";
        //查询缓存
        String shopTypeJson = stringRedisTemplate.opsForValue().get(key);

        if (StrUtil.isNotBlank(shopTypeJson)){
            //查到了，直接返回，json转list集合
            List<ShopType> shopTypes = JSONUtil.toList(shopTypeJson, ShopType.class);
            return Result.ok(shopTypes);
        }
        //缓存没查到，查数据库
        List<ShopType> typeList = this.query().orderByAsc("sort").list();
        //数据库没查到，返回错误
        if (typeList==null){
            return Result.fail("没有列表信息");
        }
        //数据库查到，缓存下
        //list集合转json
        String json = JSONUtil.toJsonStr(typeList);
        stringRedisTemplate.opsForValue().set(key, json);

缓存更新策略

业务场景

低一致性需求：使用内存淘汰机制，例如店铺类型的查询

高一致性需求；主动更新，并以超时剔除作为兜底方案，例如店铺的详细信息

主动更新策略

操作缓存和数据库的三个问题需要考虑：

1，删除缓存还是更新缓存？

更新缓存：每次更新数据都会更新缓存，无效写操作较多（×）
删除缓存：更新数据库时让缓存失效，查询时在更新缓存（√）

2、如何保证缓存与数据库的操作同时成功或者失败？

单体系统，将缓存与数据库操作放在一个事务
分布式系统，利用TCC操作等分布式事务方案

3、先操作缓存还是先操作数据库

先操作数据库，在删除缓存

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

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

2、高一致性需求：主动更新，并以超时提出作为兜底方案

读操作：

缓存命中则直接返回
缓存未命中则查询数据库，并写入缓存，设置超时时间

写操作::

先写数据库，然后在删除缓存
要确保数据库与缓存操作的原子性

缓存穿透

我们使用Redis大部分情况都是通过Key查询对应的值，假如发送的请求传进来的key是不存在Redis中的，那么就查不到缓存，查不到缓存就会去数据库查询。假如有大量这样的请求，这些请求像“穿透”了缓存一样直接打在数据库上，这种现象就叫做缓存穿透。

解决方案：

1、缓存空对象（把无效的Key存进Redis中）。如果Redis查不到数据，数据库也查不到，我们把这个Key值保存进Redis，设置value="null"，当下次再通过这个Key查询时就不需要再查询数据库。这种处理方式肯定是有问题的，假如传进来的这个不存在的Key值每次都是随机的，那存进Redis也没有意义，会占用redis的内存空间，所以设置过期时间是有必要的，其次，当这个值一开始没有内容，我们查询数据库后，将null赋值给这个值，并存在redis中，而之后我们数据库新增了这个值，但是缓存中还是为null，这就会导致短期数据不一致，可以使用更新数据库删除那个缓存就可以解决。

2、使用布隆过滤器。布隆过滤器的作用是某个 key 不存在，那么就一定不存在，它说某个 key 存在，那么很大可能是存在(存在一定的误判率)。于是我们可以在缓存之前再加一层布隆过滤器，在查询的时候先去布隆过滤器查询 key 是否存在，如果不存在就直接返回，这个布隆过滤器也存在一定的穿透风险。

项目中解决缓存穿透的思路

空串""和null的区别

null表示的是一个对象的值，而非一个字符串。例如声明一个对象的引用，String aaa = null ;
""表示的是一个长度为0的空字符串。例如声明一个字符串String bbb = "" ;
所以：null不指向任何对象，相当于没有任何值;而""代表一个长度为0的字符串。

缓存null值解决穿透问题

 public Result queryById(Long id) {
        String key=CACHE_SHOP_KEY+id;
        //1、从redis查询商铺缓存，使用opsForValue接受对象，返回的是json串
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        //2、判断是否存在
        if (StrUtil.isNotBlank(shopJson)){
            //3、存在，直接返回缓存中的
               //是json数据，则需要通过JSONUtil返回指定的对象即可
            Shop shop= JSONUtil.toBean(shopJson, Shop.class);
            return  Result.ok(shop);
        }
        //4、缓存中不存在，判断是否命中的为空串""
        if (shopJson!=null){
            return Result.fail("商铺不存在");
        }
        Shop shop = this.getById(id);
        //5、数据库中不存在，并返回错误
        if (shop==null){
            //插入一个空串,设置过期时间
            stringRedisTemplate.opsForValue().set(key,"", CACHE_NULL_TTL, TimeUnit.MINUTES);
            return Result.fail("商铺不存在");
        }
        //6、存在，写入缓存
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
       //7、返回
        return  Result.ok(shop);
    }

缓存穿透产生的原因是什么?

用户请求的数据在缓存中和数据库中都不存在，不断发起这样的请求给数据库带来巨大压力

缓存穿透的解决方案有?

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

缓存雪崩

当某一个时刻出现大规模的redis缓存失效的情况，就会导致大量的请求直接打在数据库上面，导致数据库压力巨大，如果在高并发的情况下，可能瞬间就会导致数据库宕机。这时候如果运维马上又重启数据库，马上又会有新的流量把数据库打死。这就是缓存雪崩。缓存雪崩是指在同一时段大量的缓存key同时失效或者Redis服务宕机，导致大量请求到达数据库，带来巨大压力。

解决方案:

给不同的Key的TTL添加随机值
利用Redis集群提高服务的可用性
给缓存业务添加降级限流策略
给业务添加多级缓存

1、在原有的失效时间上加上一个随机值，这样就避免了因为采用相同的过期时间导致的缓存雪崩。

如果真的发生了缓存雪崩，有没有什么兜底的措施？

2、使用熔断机制。当流量到达一定的阈值时，就直接返回“系统拥挤”之类的提示，防止过多的请求打在数据库上。至少能保证一部分用户是可以正常使用，其他用户多刷新几次也能得到结果。

3、提高数据库的容灾能力，可以使用分库分表，读写分离的策略。

4、为了防止Redis宕机导致缓存雪崩的问题，可以搭建Redis集群，提高Redis的容灾性

缓存击穿

其实跟缓存雪崩有点类似，缓存雪崩是大规模的key失效，而缓存击穿是一个热点的Key，有大并发集中对其进行访问，突然间这个Key失效了，导致大并发全部打在数据库上，导致数据库压力剧增。这种现象就叫做缓存击穿。

解决方案：

互斥锁
逻辑过期（不过期）

1、业务允许的话，对于热点的key可以设置永不过期的key。

2、使用互斥锁。如果缓存失效的情况，只有拿到锁才可以查询数据库，降低了在同一时刻打在数据库上的请求，防止数据库打死。当然这样会导致系统的性能变差。

多条线程同时访问数据库

互斥锁和逻辑过期介绍

基于互斥锁解决缓存穿透问题

修改id查询店铺，基于互斥锁来解决缓存击穿问题

    /**
     * 互斥锁解决缓存击穿
     * @param id
     * @return
     */
    public Shop queryWithMutex(Long id){
        String key=CACHE_SHOP_KEY+id;
        //1、从redis查询商铺缓存，使用opsForValue接受对象，返回的是json串
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        //2、判断是否存在
        if (StrUtil.isNotBlank(shopJson)){
            //3、存在，直接返回缓存中的
            //是json数据，则需要通过JSONUtil返回指定的对象即可
            Shop shop= JSONUtil.toBean(shopJson, Shop.class);
            return  shop;
        }
        //4、缓存中不存在，判断是否命中的为空串""
        if (shopJson!=null){
            return null;
        }

        //4实现缓存重建
        //4.1获取互斥锁
        String lockKey=LOCK_SHOP_KEY+id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            //4.2判断是否获取成功
            if (!isLock){
                //4.3失败，则休眠并重试
                Thread.sleep(99);
               return queryWithMutex(id);
            }
            //4.4成功，根据id查询数据库
            shop = this.getById(id);
            //模拟重建延时
            Thread.sleep(366);
            //5、数据库中不存在，并返回错误
            if (shop==null){
                //插入一个空串,设置过期时间
                stringRedisTemplate.opsForValue().set(key,"", CACHE_NULL_TTL, TimeUnit.MINUTES);
                return null;
            }
            //6、存在，写入缓存
            stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop), CACHE_SHOP_TTL, TimeUnit.MINUTES);
        } catch (InterruptedException e) {
           throw new RuntimeException(e);
        } finally {
            //7、释放互斥锁
            unLock(lockKey);
        }
        //8、返回
        return shop;
    }

基于逻辑过期解决缓存击穿问题

  /**
     * 逻辑辑过期解决缓存击穿
     * @param id
     * @return
     */
 //创建一个线程池
    private static final ExecutorService CACHE_REBUILD_EXECUTOR= Executors.newFixedThreadPool(10);

    public Shop queryWithLogicalExpire(Long id){
        String key=CACHE_SHOP_KEY+id;
        //1、从redis查询商铺缓存，使用opsForValue接受对象，返回的是json串
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        //2、判断是否存在
        if (StrUtil.isBlank(shopJson)){
            //3不存在，直接返回null
           return  null;
        }
        //4命中，需要把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
        JSONObject data = (JSONObject) redisData.getData();
        Shop shop = JSONUtil.toBean(data, Shop.class);
        LocalDateTime expireTime = redisData.getExpireTime();
        //5、判断是否过期，是否在当前时间之后
        if (expireTime.isAfter(LocalDateTime.now())){
            //5。1没过期。直接返回店铺信息
            return  shop;
        }
        //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 {
                    //重建缓存
                    this.saveShop2Redis(id,20L);
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    //释放锁
                    unLock(lockKey);
                }

            });
        }

        return shop;
    }

下载JMeter模拟线程测试

修改数据据库中的一点信息，会发现某一时刻重建前是旧数据，完成后是新数据

控制台中只有一数据重建，一次是查询旧数据，一次为新数据重建

redis缓存工具类封装

基于stringRedisTemplate封装一个缓存工具类，满足下列需求:

方法1:将任意va对象序列化为json并存储在string类型的key中，并且可以设置TTL过期时间

方法2:将任意/ava对象序列化为json并存储在string类型的key中，并且可以设置逻辑过期时间，用于处理缓存击穿问题

方法3:根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题

方法4:根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题

package com.hmdp.utils;

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.LOCK_SHOP_KEY;

@Slf4j
@Component

/**
 * 缓存工具类1
 */
public class CacheClient {
    private final StringRedisTemplate stringRedisTemplate;

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

    public void  set(String key, Object value, Long time, TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,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));
    }

    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,"",2,TimeUnit.MINUTES);
            //返回错误信息
            return null;
        }
        //6.存在写入redis
        this.set(key,r,time,unit);
        return r;
    }

    /**
     * 逻辑删除解决缓存击穿
     */

    private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    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.存在，缓存中存的null
            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 成功，再进行二次判断，查看缓存中是否有数据，因为有可能是别人刚刚重建完释放锁，刚好获取到了

            //6.4 开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(() -> {
                try {
                    //查询数据库
                    R r1 = dbFallback.apply(id);
                    //写入redis
                    this.setWithLogicalExpire(key, r1, time, unit);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                } finally {
                    //释放锁
                    unlock(lockKey);
                }
            });
        }
        //6.6返回过期的商铺信息
        return r;
    }


    //获取锁和开锁
    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);
    }
}

优惠卷秒杀

全局唯一id

全局id生成器

全局ID生成器，是一种在分布式系统下用来生成全局唯一id的工具，一般满足：

唯一性
高可用
高性能
递增性
安全性

为了增加ID的安全性，我们可以不直接使用Redis自增的数值，而是拼接一些其它信息：

ID的组成部分:
符号位:1bit，永远为0
时间戳:31bit，以秒为单位，可以使用69年
序列号:32bit，秒内的计数器，支持每秒产生2^32个不同ID

@Component
public class RedisWorker {

    private static final long BEGIN_TIMESTAMP=1640995000L;
    private static final long COUNT_BITS=32;
    @Resource
    private 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);

      //拼接并返回(先向左移把右边空出，然后在或，相当于加上)
      return timestamp<<COUNT_BITS|count;
  }

}

测试类中

    private ExecutorService es= Executors.newFixedThreadPool(500);
    @Test
    void testIdWordker() throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(300);

        Runnable task=()->{
            for (int i=0;i<100;i++){
                long id = redisWorker.nextId("order");
                System.out.println("id="+id);
            }
            latch.countDown();
        };

        long begin = System.currentTimeMillis();
        for (int i = 0; i <100 ; i++) {
            es.submit(task);
        }
        latch.await();
        long end = System.currentTimeMillis();
        System.out.println("time="+(end-begin));
    }

全局唯一id生成策略

UUID
redis自增
snowflake算法
数据库自增

redis自增id策略

每天一个key，方便统计订单量
id构造是时间戳+计数器

优惠券添加

没有后台只能通过postman添加

{
"shopId": 1,
"title": "200元代金券",
"subTitle": "周六周末可用",
"rules": "全场通用\\n可以叠加\\n仅限制堂食",
"payValue": 16000,
"actualValue": 20000,
"type": 1,
"stock": 100,
"beginTime": "2023-08-01T00:00:00",
"endTime": "2024-08-01T00:00:00"
}

优惠券秒杀下单

下单时需要判断两点:
秒杀是否开始或结束，如果尚未开始或已经结束则无法下单

库存是否充足，不足则无法下单

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Resource
    private ISeckillVoucherService seckillVoucherService;
@Resource
private RedisWorker redisWorker;
    /**
     * 优惠券下单
     * @param voucherId
     * @return
     */
    @Override
    @Transactional
    public Result seckillVoucher(Long voucherId) {
        //1、查询优惠券
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        //2、判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
            //尚未开始
            return Result.fail("秒杀还未开始");
        }
        //3、判断秒杀是否结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())){
            //已经结束
            return Result.fail("秒杀已经结束");
        }
        //4、判断库存是否充足
        if (voucher.getStock()<1){
            //库存不足
            return Result.fail("已经被抢完");
        }
        //5、扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock=stock-1")
                .eq("voucher_id", voucherId).update();
       if (!success)return Result.fail("库存不足");
        //6创建秒杀券订单
        VoucherOrder voucherOrder = new VoucherOrder();
        //6.1订单id
        long orderId = redisWorker.nextId("order");
        voucherOrder.setId(orderId);
        //6.2用户id
        Long userId = UserHolder.getUser().getId();
        voucherOrder.setUserId(userId);
        //6.3代金券id
        voucherOrder.setVoucherId(voucherId);
        //添加订单
        save(voucherOrder);
        //7返回订单id
        return Result.ok(orderId);
    }
}

JMeter线程测试遇到401错误

这是未授权问题
用 F12 打开开发者工具
在network网络里寻找相关信息:

添加一个信息管理器

订单出现了超卖

超卖问题分析

超卖问题是多线程安全问题，即在一个线程还没执行完，其他线程抢先执行，对同一个数据进行修改

乐观锁

乐观锁的关键是判断之前查询到的数据是否被修改，常见的方式有

版本号法

在修改之前查询一次版本号，若版本号不变则说明没有被其他线程修改，则正常进行数据修改，并让版本加一，若是版本号不一致，则不会执行

CAS法

直接比较数据是否发生了改变，若不变则说明安全

如果弄数据是否和之前一致，会导致成功率低

设置200个线程只卖出23个

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Resource
    private ISeckillVoucherService seckillVoucherService;
@Resource
private RedisWorker redisWorker;
    /**
     * 优惠券下单
     * @param voucherId
     * @return
     */
    @Override
    @Transactional
    public Result seckillVoucher(Long voucherId) {
        //1、查询优惠券
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        //2、判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
            //尚未开始
            return Result.fail("秒杀还未开始！");
        }
        //3、判断秒杀是否结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())){
            //已经结束
            return Result.fail("秒杀已经结束");
        }
        //4、判断库存是否充足
        if (voucher.getStock()<1){
            //库存不足
            return Result.fail("已经被抢完");
        }
        //5、扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock=stock-1") //set stock=stock-1
                .eq("voucher_id", voucherId).gt("stock", 0)//where id=? and stock=?只要大于0即可
                .update();
       if (!success)return Result.fail("库存不足");
        //6创建秒杀券订单
        VoucherOrder voucherOrder = new VoucherOrder();
        //6.1订单id
        long orderId = redisWorker.nextId("order");
        voucherOrder.setId(orderId);
        //6.2用户id
        Long userId = UserHolder.getUser().getId();
        voucherOrder.setUserId(userId);
        //6.3代金券id
        voucherOrder.setVoucherId(voucherId);
        //添加订单
        save(voucherOrder);
        //7返回订单id
        return Result.ok(orderId);
    }
}

超卖这样的线程安全问题，解决方案有哪些?

1.悲观锁:添加同步锁，让线程串行执行

优点:简单粗暴
缺点:性能一般

乐观锁:不加锁，在更新时判断是否有其它线程在修改

优点:性能好
缺点:存在成功率低的问题

给整个this对象上锁

优点是简单安全

缺点是性能低，因为这样所有用户都被锁上了，我们的初衷是，单个用户中，只能单卖，这样就会导致其他用户也会受到影响

@Service
public class VoucherOrderServiceImpl extends ServiceImpl<VoucherOrderMapper, VoucherOrder> implements IVoucherOrderService {
@Resource
    private ISeckillVoucherService seckillVoucherService;
@Resource
private RedisWorker redisWorker;
    /**
     * 优惠券下单
     * @param voucherId
     * @return
     */
    @Override
    public Result seckillVoucher(Long voucherId) {
        //1、查询优惠券
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        //2、判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
            //尚未开始
            return Result.fail("秒杀还未开始！");
        }
        //3、判断秒杀是否结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())){
            //已经结束
            return Result.fail("秒杀已经结束");
        }
        //4、判断库存是否充足
        if (voucher.getStock()<1){
            //库存不足
            return Result.fail("已经被抢完");
        }


        //7返回订单id
        return createVoucherOrder(voucherId);
    }

    @Transactional
    public  synchronized Result createVoucherOrder(Long voucherId){
        //5、一人一单
        Long userId = UserHolder.getUser().getId();
        //5.1查询订单
        Integer count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        //判断是否已经存在
        if (count>0){
            //用户已经购买过
            return Result.fail("你已经购买过这个券了");
        }


        //6、扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock=stock-1") //set stock=stock-1
                .eq("voucher_id", voucherId).gt("stock", 0)//where id=? and stock=?只要大于0即可
                .update();
        if (!success)return Result.fail("库存不足");
        //6创建秒杀券订单
        VoucherOrder voucherOrder = new VoucherOrder();
        //6.1订单id
        long orderId = redisWorker.nextId("order");
        voucherOrder.setId(orderId);
        //6.2用户id

        voucherOrder.setUserId(userId);
        //6.3代金券id
        voucherOrder.setVoucherId(voucherId);
        //添加订单
        save(voucherOrder);
        //返回订单id
        return Result.ok(orderId);
    }
}

悲观锁升级后

@Override
    public Result seckillVoucher(Long voucherId) {
        //1、查询优惠券
        SeckillVoucher voucher = seckillVoucherService.getById(voucherId);
        //2、判断秒杀是否开始
        if (voucher.getBeginTime().isAfter(LocalDateTime.now())){
            //尚未开始
            return Result.fail("秒杀还未开始！");
        }
        //3、判断秒杀是否结束
        if (voucher.getEndTime().isBefore(LocalDateTime.now())){
            //已经结束
            return Result.fail("秒杀已经结束");
        }
        //4、判断库存是否充足
        if (voucher.getStock()<1){
            //库存不足
            return Result.fail("已经被抢完");
        }
        Long userId = UserHolder.getUser().getId();

       synchronized (userId.toString().intern()){//intern获取源对象，new多少次都只是从常量池中寻找
           //拿到当前对象的代理对象(事务的对象)
           IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
           return proxy.createVoucherOrder(voucherId);//要想让事务生效，必须要有代理对象
    }
}
    @Transactional
    public   Result createVoucherOrder(Long voucherId){
        //5、一人一单
        Long userId = UserHolder.getUser().getId();
        //5.1查询订单
        Integer count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
        //判断是否已经存在
        if (count>0){
            //用户已经购买过
            return Result.fail("你已经购买过这个券了");
        }


        //6、扣减库存
        boolean success = seckillVoucherService.update()
                .setSql("stock=stock-1") //set stock=stock-1
                .eq("voucher_id", voucherId).gt("stock", 0)//where id=? and stock=?只要大于0即可
                .update();
        if (!success)return Result.fail("库存不足");
        //6创建秒杀券订单
        VoucherOrder voucherOrder = new VoucherOrder();
        //6.1订单id
        long orderId = redisWorker.nextId("order");
        voucherOrder.setId(orderId);
        //6.2用户id

        voucherOrder.setUserId(userId);
        //6.3代金券id
        voucherOrder.setVoucherId(voucherId);
        //添加订单
        save(voucherOrder);
        //返回订单id
        return Result.ok(orderId);
    }

一人一单的并发安全问题

通过加锁可以解决在单机情况下的一人一单安全问题，但是在集群模式下就不行了。
1.我们将服务启动两份，端口分别为8081和8082:

2.然后修改nginx的conf目录下的nginx.conf文件，配置反向代理和负载均衡

nginx配置实现了反代理和负载均衡

发现线程不安全

集群下的锁监听器tomcat等不是同一个

分布式锁

什么是分布式锁

分布式锁：满足分布式系统或集群模式下多进程可见并且互斥的锁

分布式锁的实现

分布式锁的核心是是实现多进程之间互斥，常见的有三种

实现分布式锁时需要实现两个基本方法

获取锁：

互斥:确保只能有一个线程获取锁
非阻塞：尝试一次，成功返回true，失败返回false

添加锁，nx是互斥（当存在则不执行），ex是设置超时时间

local是键 thread1是值

释放锁：

手动释放
超时释放：获取锁时添加一个超时时间

释放锁，直接删除即可

业务流程

基于Redis实现分布式锁的初级版本

锁的类

public class SimpleRedisLock  implements ILock{

    private StringRedisTemplate stringRedisTemplate;
    private String name;

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

    private static final String KEY_PREFIX="lock:";

    //获取锁
    @Override
    public boolean tryLock(long timeoutSec) {
        //获取线程标识
        long threadId = Thread.currentThread().getId();
        //获取锁，这里的返回值是一个布尔型的包装类，直接返回有时会出现空指针异常
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, threadId + "", timeoutSec, TimeUnit.SECONDS);
        //和真比较，就不会出现异常
        return Boolean.TRUE.equals(success) ;
    }

    //释放锁
    @Override
    public void unlock() {
  stringRedisTemplate.delete(KEY_PREFIX+name);
    }
}

    Long userId = UserHolder.getUser().getId();

        //创建锁对象
        SimpleRedisLock lock = new SimpleRedisLock(stringRedisTemplate, "order:" + userId);
        //获取锁
        boolean isLock = lock.tryLock(12);

        //判断是否获取锁成功
        if (!isLock){
            //获取锁失败
            return Result.fail("一个人只能下一单");
        }
        try {
            //拿到当前对象的代理对象(事务的对象)
            IVoucherOrderService proxy = (IVoucherOrderService) AopContext.currentProxy();
            return proxy.createVoucherOrder(voucherId);//要想让事务生效，必须要有代理对象
        }  finally {
            //释放锁
            lock.unlock();
        }

线程存在问题

线程阻塞超时自动删除后，线程完成释放别的线程的锁

存在的线程阻塞超时自动删除后，线程释放别的线程的锁

改进分布式锁（判断线程和存的是否一致）

需求:修改之前的分布式锁实现，满足:

1.在获取锁时存入线程标示(可以用UUID表示)

2.在释放锁时先获取锁中的线程标示，判断是否与当前线程标示一致如果一致则释放锁
如果不一致则不释放锁

  public void unlock() {
        //获取线程标识
      String threadId=  ID_PREFIX+Thread.currentThread().getId();
      //获取锁中的标识
        String id=stringRedisTemplate.opsForValue().get(KEY_PREFIX + name);
        //判断两个是否一致，从而判断是否为同一线程
        if (threadId.equals(id)){
            stringRedisTemplate.delete(KEY_PREFIX+name);
        }

有并发安全分析

这里有个并发问题，即当判断完相同时，发生了阻塞，没来得及删除锁，被redis超时释放后，下一个线程来获取后，之前那个线程阻塞完成，就会释放掉锁，但是此时这把锁的拥有者不是他。

所以我们改进的是时候，应该保证，判断和删除在同一条语句中，即使用lua脚本可以保证原子性

Redis的Lua脚本

Redis提供了Lua脚本功能，在一个脚本中编写多条Redis命令，确保多条命令执行时的原子性。Lua是一种编程语言，它的基本语法大家可以参考网站: https://www.runoob.com/lua/lua-tutorial.html语法如下:

如，我们要执行set name jack则脚本是这样

列如。我们要先执行set name Rose，在执行get name ，则脚本如下

需要用Redis命令来调用脚本，调用脚本的常见命令如下:

例如，我们要执行 redis.call('set','name','jack') 这个脚本，语法如下:

脚本中可以从KEYS和ARGV数组获取这些参数:
如果脚本中的key、value不想写死，可以作为参数传递。key类型参数会放入KEYS数组，其它参数会放入ARGV数组，在

resoure下创建unlock.lua

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

    private static final String KEY_PREFIX = "lock:";
    private static final String ID_PREFIX = UUID.randomUUID().toString(true) + "-";
    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;

    static {
        UNLOCK_SCRIPT = new DefaultRedisScript<>();
        UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
        UNLOCK_SCRIPT.setResultType(Long.class);
    }

    //获取锁
    @Override
    public boolean tryLock(long timeoutSec) {
        //获取线程标识
        String threadId = ID_PREFIX + Thread.currentThread().getId();
        //获取锁，这里的返回值是一个布尔型的包装类，直接返回有时会出现空指针异常
        Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, threadId, timeoutSec, TimeUnit.SECONDS);
        //和真比较，就不会出现异常
        return Boolean.TRUE.equals(success);
    }

    //释放锁
    @Override
    public void unlock() {
        //调用Lia
        stringRedisTemplate.execute(UNLOCK_SCRIPT,
                Collections.singletonList(KEY_PREFIX+name),
                ID_PREFIX+Thread.currentThread().getId());
    }

基于Redis的分布式锁实现思路

利用set nxex获取锁，并设置过期时间，保存线程标示
释放锁时先判断线程标示是否与自己一致，一致则删除锁

特性:

利用setnx满足互斥性
利用set ex保证故障时锁依然能释放，避免死锁，提高安全性
利用Redis集群保证高可用和高并发特性

还存在的问题

基于setnx实现的分布式锁还存在下面的问题

不可重入：同一个线程无法多次获取同一把锁

不可重试：获取锁只尝试一次就返回false，没有重试机制

超时释放：锁超时释放虽然可以避免死锁，但如果是业务执行耗时较长，也会导致锁释放，存在安全隐患

主从一致性：如果Redis提供了主从集群主从同步存在延迟，当主宕机时，如果从并同步主中的
锁数据，则会出现锁实现

Redission实现分布式锁

Redisson是一个在Redis的基础上实现的ava驻内存数据网格 (In-Memory Data Grid)。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务，其中就包含了各种分布式锁的实现。

官网地址: https://redisson.org
GitHub地址: https://github.com/redisson/redisso

Redisson入门

导入maven地址

     <!--redisson-->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.13.6</version>
        </dependency>

创建配置文件

package com.hmdp.config;

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 RedissonConfig {

@Bean
    public RedissonClient redissonClient(){
    //配置
    Config config=new Config();
    config.useSingleServer().setAddress("redis://localhost:6379");
    //创建RedissonClient对象
    return Redisson.create(config);
}
}

       //创建锁对象
//        SimpleRedisLock lock = new SimpleRedisLock(stringRedisTemplate, "order:" + userId);
        RLock lock = redissonClient.getLock("lock:order:" + userId);

        //获取锁，数量分别是：获取锁的最大等待时间（期间会重试），锁自动释放时间，时间单位
        boolean isLock = lock.tryLock(1,10,TimeUnit.SECONDS);
        if(isLock){
          try {
             System.out.println("执行业务");}
          finally {
       // 释放锁
           lock.unlock();}

Redisson可重入锁原理

获取锁的Lua脚本

释放锁的Lua脚本

Redisson分布式锁的原理

Redisson分布式锁原理：

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

总结

1)不可重入Redis分布式锁
原理:利用setnx的互斥性;利用ex避免死锁;释放锁时判断线程标示
缺陷:不可重入、无法重试、锁超时失效
2)可重入的Redis分布式锁:
原理:利用hash结构，记录线程标示和重入次数;利用watchDog延续锁时间;利用信号量控制锁重试等待
缺陷: redis宕机引起锁失效问题
3)Redisson的multiLock:
原理:多个独立的Redis节点，必须在所有节点都获取重入锁，才算获取锁成功
缺陷:运维成本高、实现复杂

Redis秒杀优化（暂未实现）

达人探店

点赞功能

/**
     * 博客点赞
     *
     * @param id
     * @return
     */
    @Override
    public Result likeBlog(Long id) {
        //获取blog实体
        Blog blog = getById(id);
        //获取博客id
        Long blogId = blog.getId();
        //获取登录当前用户id
        Long userId = UserHolder.getUser().getId();

        //拼接key
        String key = BLOG_LIKED_KEY + blogId;
        //去redis中看有没有点赞过，查询这个key是否存在
        Boolean isMember = stringRedisTemplate.opsForSet().isMember(key, userId.toString());
        //不存在，即没点赞过
        if (BooleanUtil.isFalse(isMember)) {
            //修改数据库，让liked加1
            boolean isSuccess = update().setSql("liked=liked+1").eq("id", id).update();
            if (isSuccess) {
                //修改成功后，将自定义的blog的isLike(是否点赞过)改为true
               // blog.setIsLike(true);不能，因为这不是数据库中的字段存不了
                //将这个点赞信息加到redis缓存中
                stringRedisTemplate.opsForSet().add(key, userId.toString());
            }
        } else {
            //存在，即点赞过,则取消赞
            boolean isSuccess = update().setSql("liked=liked-1").eq("id", id).update();
            if (isSuccess) {
                //修改，删除
                stringRedisTemplate.opsForSet().remove(key, userId.toString());
            }
        }
        return Result.ok();
    }

实现点赞排行榜功能

  /**
     * 博客点赞排序
     * @param id
     * @return
     */
    @Override
    public Result queryBlogLikes(long id) {
        String key =BLOG_LIKED_KEY+id;
        //1查询top5的点赞用户 zrange key 0 4
        Set<String> topRange = stringRedisTemplate.opsForZSet().range(key, 0, 4);
        if (topRange==null||topRange.isEmpty()){
            return Result.ok(Collections.emptyList());
        }
        //2解析出其中的用户id
        List<Long> ids = topRange.stream().map(Long::valueOf).collect(Collectors.toList());
        String idStr = StrUtil.join(",", ids);
        //3根据用户id查询用户where id in (5,1) order by field (id,5,1)
        List<UserDTO> userDTOS = userService.query().in("id", ids).last("order by field (id," + idStr + ")").list().stream()
                .map(user -> BeanUtil.copyProperties(user, UserDTO.class))
                .collect(Collectors.toList());
        return Result.ok(userDTOS);
    }

关注和取关

 @Override
    public Result follow(Long followUserId, boolean isFollow) {
        //1获取当前登录用户
        Long userId = UserHolder.getUser().getId();
        if (userId==null)return Result.fail("还没有登录");
        Follow follow = new Follow();
        //2判断为关注还是取关
        if (isFollow){
            //为关注，新增follow数据
            follow.setUserId(userId);
            follow.setFollowUserId(followUserId);
            save(follow);
        }else {
            //为取关，删除follow数据
            LambdaUpdateWrapper<Follow> updateWrapper=new LambdaUpdateWrapper();
            updateWrapper.eq(Follow::getUserId, userId)
                    .eq(Follow::getFollowUserId,followUserId);
            //删除数据
            this.remove(updateWrapper);

        }
        return Result.ok();
    }

    @Override
    public Result isFollow(Long followUserId) {
        //1获取当前登录用户
        Long userId = UserHolder.getUser().getId();
        if (userId==null)return Result.fail("还没有登录");
        Integer count = query().eq("user_id", userId).eq("follow_user_id", followUserId).count();
        //判断是否有数据
        return Result.ok(count>0);
    }

查看共同关注

/**
     * 被查看的人和我的共同关注
     *
     * @param checkedUserId
     * @return
     */
    @Override
    public Result commonConcernPerson(Long checkedUserId) {
        //1获取当前登录用户
        Long userId = UserHolder.getUser().getId();
        if (userId == null) return Result.fail("还没有登录");
        String key = "follows:" + userId;
        //2求交集
        String key2 = "follows:" + checkedUserId;
        Set<String> intersect = stringRedisTemplate.opsForSet().intersect(key, key2);
      if (intersect==null||intersect.isEmpty()){
          //没有交集
          return Result.ok(Collections.emptyList());
      }
        //解析出id集合
        List<Long> ids = intersect.stream().map(Long::valueOf).collect(Collectors.toList());
        //4、根据id查询用户，转为userDto
        List<UserDTO> userDTOS = userService.listByIds(ids)
                .stream()
                .map(user -> BeanUtil.copyProperties(user, UserDTO.class ))
                .collect(Collectors.toList());
        return Result.ok(userDTOS);
    }

关注推送

关注推送也叫做Feed流，直译为投喂。为用户持续的提供“沉浸式”的体验，通过无限下拉刷新获取新的信息。

feed流模式

Feed流产品有两种常见模式:
Timeline:不做内容筛选，简单的按照内容发布时间排序，常用于好友或关注。例如朋友圈优点:信息全面，不会有缺失。并且实现也相对简单
缺点:信息噪音较多，用户不一定感兴趣，内容获取效率低

智能排序:利用智能算法屏蔽掉违规的、用户不感兴趣的内容。推送用户感兴趣信息来吸引用户> 优点: 投喂用户感兴趣信息，用户粘度很高，容易沉迷
缺点:如果算法不精准，可能起到反作用

对于普通人：直接发送到他的粉丝下

对于大v：活跃粉丝直接给他推送，不活跃粉丝放在收件箱，等他要读的时候推

feed流实现方案

需求

修改新增探店笔记的业务，在保存blog到数据库的同时，推送到粉丝的收件箱

收件箱满足可以根据时间戳排序，必须用Redis的数据结构实现

查询收件箱数据时，可以实现分页查询

不能使用传统的分页，得使用滚动分页

    
@GetMapping("/of/follow")
public Result queryBlogOfFollow(
@RequestParam("lastId") Long max,@RequestParam(value = "offset",defaultValue = "0") Integer offset){
        return blogService.queryBlogOfFollow(max,offset);
}

    @Override
    public Result queryBlogOfFollow(Long max, Integer offset) {
        //1获取当前用户
        Long userId = UserHolder.getUser().getId();
        //2查询收件箱 ZREVRANGEBYSCORE key Max Min LIMiT offset count
        String key =FEED_KEY+userId;
        Set<ZSetOperations.TypedTuple<String>> typedTuples = stringRedisTemplate.opsForZSet()
                .reverseRangeByScoreWithScores(key, 0, max, offset, 2);
        //3判断是否为空
        if (typedTuples==null||typedTuples.isEmpty()){
            return Result.ok();
        }
        //4解析数据：blogId，minTime(时间戳)，offset
    List<Long> ids=new ArrayList<>(typedTuples.size());
        long minTime=0;
        int offNum=1;
        //统计有多次offNum（和最小的相同的个数）
        for (ZSetOperations.TypedTuple<String> tuple : typedTuples) {
            //获取id
            ids.add(Long.valueOf(tuple.getValue()));
            //获取分数（时间戳）
            long time = tuple.getScore().longValue();
            if (time==minTime){
                offNum++;
            }else {
                minTime=time;
                offNum=1;
            }
        }
        //5,根据id查询blog
        String idStr =StrUtil.join(",", ids);
        List<Blog> blogs = query().in("id", ids).last("order by field (id," + idStr + ")").list();

        //把博客相关信息点赞填充
        for (Blog blog : blogs) {
            //查询blog有关用户
            queryBlogUser(blog);
            isLikeBlog(blog);
        }

        //5封装并返回
        ScrollResult scrollResult = new ScrollResult();
        scrollResult.setList(blogs);
        scrollResult.setOffset(offNum);
        scrollResult.setMinTime(minTime);
        return Result.ok(scrollResult);
    }

Redis最佳实践

Redis键值设计

优雅的key结构

Redis的key虽然可以自定义，但最好遵循下面结构最佳实践的约定：

遵循基本格式：[业务名称]:[数据名]:[id]
长度不超过44字节
不包含特殊字符

例如：在登录业务，保存用户信息，key是这样：login:user:1

优点：

可读强
避免key冲突
方便管理

更节省内存：key是string类型，底层编码包含int、embstr、和raw三种，embstr在小于44字节使用，采用连续的空间，内存占用更小