Jedis jedis = new Jedis("localhost", 6379);
jedis.auth("123.com");
jedis.set("name", "wmhs");
jedis.close();

@Test
void StringRedisTemplateTest() {
    ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
    // name
    ops.set("name", "wmh");
    System.out.println("name: " + ops.get("name"));
    // yx
    ops.set("yx", gson.toJson(new User("yx", 18)));
    String yx = ops.get("yx");
    System.out.println("yx: " + gson.fromJson(yx, User.class));
}

String code = RandomUtil.randomNumbers(6);

redisTemplate.opsForValue().set(
    REDIS_CODE_PRE + phone, code, 2, TimeUnit.MINUTES
);

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Autowired
    private StringRedisTemplate template;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new TokenInterceptor(template)).addPathPatterns(
            "/**"
        ).order(0);
        registry.addInterceptor(new LoginInterceptor()).addPathPatterns(
            "/user"
        ).order(2);
    }
}

String token = request.getHeader("authorization"));

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

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

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

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

@Data
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        if (UserHolder.getUser() == null) {
            response.setStatus(401);
            return false;
        }
        return true;
    }
}

@Override
public List<UserDTO> getUserlist() {
    Gson gson = new Gson();
    // 1. 查询redis缓存
    String cache = redisTemplate.opsForValue().get(CACHE_LIST_PRE);
    // 2.1. 存在缓存
    if (StrUtil.isNotBlank(cache)) {
        // 3. 反序列化
        return gson.fromJson(cache, new TypeToken<List<UserDTO>>() {}.getType());
    }
    // 2.2. 不存在缓存
    // 3. 查询数据库
    List<User> userList = list();
    // 4. 信息脱敏
    ArrayList<UserDTO> userDTOList = new ArrayList<>();
    for (User user : userList) {
        UserDTO dto = new UserDTO();
        BeanUtil.copyProperties(user, dto);
        dto.setPhone(DesensitizedUtil.mobilePhone(dto.getPhone()));
        userDTOList.add(dto);
    }
    // 5. 保存到Redis
    redisTemplate.opsForValue()
        .set(CACHE_LIST_PRE, gson.toJson(userDTOList), 2, TimeUnit.MINUTES);
    return userDTOList;
}

// 缓存空对象
@Override
public UserDTO getInfoById(Long id) {
    // 缓存查询
    String userString = redisTemplate.opsForValue()
        .get(CACHE_USER_PRE + id);
    if (StrUtil.isNotBlank(userString)) {
        // 有缓存 => 真实数据
        return gson.fromJson(userString, UserDTO.class);
    }
    if (userString != null) {
        // 有缓存 => 空对象
        throw new BusinessException(404, "用户不存在");
    }
    // 数据库查询
    User user = getById(id);
    if (user == null) {
        // 缓存空对象
        redisTemplate.opsForValue()
            .set(CACHE_USER_PRE + id, "", 2, TimeUnit.MINUTES);
        throw new BusinessException(404, "用户不存在");
    }
    // 信息脱敏
    UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
    // 缓存真实数据
    redisTemplate.opsForValue()
        .set(CACHE_USER_PRE + id, gson.toJson(userDTO), 2, TimeUnit.MINUTES);
    return userDTO;
}

// 热点key-互斥锁
@Override
public List<UserDTO> getUserlist() throws InterruptedException {
    // 1. 查询redis缓存
    String cache = redisTemplate.opsForValue().get(CACHE_LIST_PRE);
    // 2.1. 存在缓存
    if (StrUtil.isNotBlank(cache)) {
        // 3. 反序列化
        return gson.fromJson(cache, new TypeToken<List<UserDTO>>() {}.getType());
    }
    // ⭐️ 获取互斥锁
    String lock = REDIS_LOCK_PRE + "userlist";
    Boolean flag = redisTemplate.opsForValue()
        .setIfAbsent(lock, "1", 30, TimeUnit.SECONDS);
    if (BooleanUtil.isFalse(flag)) {
        // ⭐️ 获取锁失败了 => 休眠 + 递归
        Thread.sleep(200);
        return getUserlist();
    }

    ArrayList<UserDTO> userDTOList = new ArrayList<>();
    try {
        // 2.2. 不存在缓存
        // 3. 查询数据库
        List<User> userList = list();
        log.info("查询数据库");
        // 4. 信息脱敏
        for (User user : userList) {
            UserDTO dto = new UserDTO();
            BeanUtil.copyProperties(user, dto);
            dto.setPhone(DesensitizedUtil.mobilePhone(dto.getPhone()));
            userDTOList.add(dto);
        }
        // 5. 保存到Redis
        redisTemplate.opsForValue()
            .set(CACHE_LIST_PRE, gson.toJson(userDTOList), 10, TimeUnit.SECONDS);
    } catch (Exception ignored) {
    } finally {
        // ⭐️ 释放锁
        redisTemplate.delete(lock);
    }
    return userDTOList;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class LogicalExpiration<T> {
    private T value;
    private Date date;
}

public UserDTO getUserById(Long id) {
    // 1. 查询缓存
    String userString = redisTemplate.opsForValue().get(CACHE_USER_PRE + id);
    if (StrUtil.isBlank(userString)) {
        // 没有缓存 -> 查询数据
        User user = getById(id);
        // 没有数据 -> 报错
        if (user == null) {
            throw new BusinessException(500, "用户不存在");
        }
        // 数据脱敏
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        // 新建缓存
        Date date = new Date();
        date.setTime(System.currentTimeMillis() + 2 * 60 * 1000);
        redisTemplate.opsForValue().set(CACHE_USER_PRE + id, gson.toJson(
            new LogicalExpiration<>(userDTO, date)
        ));
        // 返回数据
        return userDTO;
    }
    // 存在缓存 => 反序列化拿到对象
    LogicalExpiration<UserDTO> logicalExpiration = gson.fromJson(
        userString, new TypeToken<LogicalExpiration<UserDTO>>() {}.getType());
    // 判断缓存是否过期
    if (logicalExpiration.getDate().before(new Date())) {
        // 已经过期 => 新建线程进行更新缓存
        ExecutorService executorService = Executors.newSingleThreadExecutor();
        executorService.execute(() -> {
            UserDTO userDTO = BeanUtil.copyProperties(getById(id), UserDTO.class);
            Date date = new Date();
            // 设置TTL为2min
            date.setTime(System.currentTimeMillis() + 2 * 60 * 1000);
            redisTemplate.opsForValue().set(CACHE_USER_PRE + id, gson.toJson(
                new LogicalExpiration<>(userDTO, date)
            ));
        });
    }
    // 返回数据
    return logicalExpiration.getValue();
}

LocalDateTime timeBegin = LocalDateTime.of(2024, 1, 1, 0, 0, 0);
long second = timeBegin.toEpochSecond(ZoneOffset.UTC);

long now = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);

public Long getID(String key) {
    // 获取时间戳
    long now = LocalDateTime.now().toEpochSecond(ZoneOffset.UTC);
    long timestamp = now - TIMESTAMP_BEGIN;

    // 利用redis实现自增长
    String date = new SimpleDateFormat("yyyyMMdd").format(new Date());
    Long inc = redisTemplate.opsForValue().increment("ID:" + key + ":" + date);

    // 拼接并返回
    return timestamp << 32 | inc;
}

@Transactional
public String getProduct(Long id) {
    // 判断商品是否存在
    Product pro = getById(id);
    if (pro == null) {
        throw new BusinessException(400, "商品不存在");
    }
    // 判断库存
    int num = pro.getNum();
    if (num <= 0) {
        throw new BusinessException(400, "库存不足");
    }
    // 库存 - 1
    pro.setNum(num - 1);
    update(pro, new QueryWrapper<>());
    
    // 下订单
    Ordertable order = new Ordertable();
    order.setOrderID(idUtil.getID("order").toString());
    order.setUserID(123);
    ordertableService.save(order);
    return order.getOrderID();
}

@Transactional
public String getProduct(Long id) {
    // 判断商品是否存在
    Product pro = getById(id);
    if (pro == null) {
        throw new BusinessException(400, "商品不存在");
    }
    // 判断库存
    int num = pro.getNum();
    if (num <= 0) {
        throw new BusinessException(400, "库存不足");
    }
    // 下订单
    Ordertable order = new Ordertable();
    order.setOrderID(idUtil.getID("order").toString());
    order.setUserID(111);
    // 库存 - 1
    pro.setNum(num - 1);
    boolean success = update(pro, new QueryWrapper<Product>()
                             .eq("num", num));
    if (!success) {
        throw new BusinessException(400, "下单失败");
    }
    // 保存订单
    ordertableService.save(order);
    return order.getOrderID();
}

@Transactional
public String getProductOnlyOne(Long id) {
    // 判断商品是否存在
    Product pro = getById(id);
    if (pro == null) {
        throw new BusinessException(400, "商品不存在");
    }
    // 判断库存
    int num = pro.getNum();
    if (num <= 0) {
        throw new BusinessException(400, "库存不足");
    }
    synchronized (UserHolder.getUser().getPhone()) {
        // ⭐️ 判断是否有重复订单
        long cnt = ordertableService.count(new QueryWrapper<Ordertable>().eq("userID", UserHolder.getUser().getPhone()).eq("productID", id));

        if (cnt != 0) {
            // ⭐️ 存在重复订单
            throw new BusinessException(400, "不允许重复下单");
        }
        // 下单
        Ordertable newOrder = new Ordertable();
        newOrder.setOrderID(idUtil.getID("order").toString());
        newOrder.setUserID(UserHolder.getUser().getPhone());
        newOrder.setProductID(Math.toIntExact(id));
        // 库存 - 1
        pro.setNum(num - 1);
        boolean success = update(pro, new QueryWrapper<Product>().eq("num", num));
        if (!success) {
            throw new BusinessException(400, "下单失败");
        }
        // 保存订单
        ordertableService.save(newOrder);
        return newOrder.getOrderID();
    }
}

@Component
public class RedisLock {
    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final UUID uuid;

    static {
        uuid = UUID.randomUUID(true);
    }

    // 获取锁
    public boolean trylock(String key, Thread thread) {
        String value = uuid.toString() + thread.getId();
        Boolean success = redisTemplate
            .opsForValue().setIfAbsent(key, value, 10, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    // 删除锁
    public void unlock(String key) {
        redisTemplate.delete(key);
    }
}

@Transactional
@Override
public String getProductOnlyOneByRedis(Long id) {
    // 判断商品是否存在
    Product pro = getById(id);
    if (pro == null) {
        throw new BusinessException(400, "商品不存在");
    }
    // 判断库存
    int num = pro.getNum();
    if (num <= 0) {
        throw new BusinessException(400, "库存不足");
    }
    
    String lock_key = REDIS_LOCK_PRE + UserHolder.getUser().getPhone();
    try {
        // 获取分布式锁(给用户上锁)
        boolean lock = redisLock.trylock(lock_key, Thread.currentThread());
        if (!lock) {
            throw new BusinessException(400, "下单失败");
        }
        // 判断是否有重复订单
        long cnt = ordertableService.count(
            new QueryWrapper<Ordertable>()
            .eq("userID", UserHolder.getUser().getPhone())
            .eq("productID", id));

        if (cnt != 0) {
            // 存在重复订单
            throw new BusinessException(400, "不允许重复下单");
        }
        // 下单
        Ordertable newOrder = new Ordertable();
        newOrder.setOrderID(idUtil.getID("order").toString());
        newOrder.setUserID(UserHolder.getUser().getPhone());
        newOrder.setProductID(Math.toIntExact(id));
        // 库存 - 1
        pro.setNum(num - 1);
        boolean success = update(pro, new QueryWrapper<Product>().eq("num", num));
        if (!success) {
            throw new BusinessException(400, "下单失败");
        }
        // 保存订单
        ordertableService.save(newOrder);
        return newOrder.getOrderID();
    } finally {
        // 释放锁
        redisLock.unlock(lock_key);
    }
}

@Component
public class RedisLock {
    @Autowired
    private StringRedisTemplate redisTemplate;

    private static final UUID uuid = UUID.randomUUID(true);

    private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;

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

    // 获取锁
    public boolean trylock(String key, Thread thread) {
        Boolean success = redisTemplate.opsForValue().setIfAbsent(
            key, uuid.toString() + thread.getId(), 10, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success);
    }

    // 删除锁
    public void unlock(String key) {
        redisTemplate.execute(UNLOCK_SCRIPT, Collections.singletonList(key),
                uuid.toString() + Thread.currentThread().getId());
    }
}

@Configuration
@ConfigurationProperties(prefix = "spring.data.redis")
@Data
public class RedissonConfig {
    private String host;
    private String port;
    private String password;

    @Bean
    public RedissonClient redissonClient() {
        // 1. 创建配置
        Config config = new Config();
        String redisAddress = String.format("redis://%s:%s", host, port);
        // 使用单个Redis
        config.useSingleServer()
            .setAddress(redisAddress).setPassword(password).setDatabase(0);
        // 2. 创建实例
        RedissonClient redisson = Redisson.create(config);
        return redisson;
    }
}

@Override
public String getProductOnlyOneByRedisson(Long id) {
    // 判断商品是否存在
    Product pro = getById(id);
    if (pro == null) {
        throw new BusinessException(400, "商品不存在");
    }
    // 判断库存
    int num = pro.getNum();
    if (num <= 0) {
        throw new BusinessException(400, "库存不足");
    }

    String lock_key = REDIS_LOCK_PRE + UserHolder.getUser().getPhone();
    RLock lock = redissonClient.getLock(lock_key);
    try {
        // ⭐️ 使用Redisson自带的可重入锁(给用户上锁)
        if (!lock.tryLock()) {
            throw new BusinessException(400, "下单失败");
        }
        // 判断是否有重复订单
        long cnt = ordertableService.count(
            new QueryWrapper<Ordertable>()
            .eq("userID", UserHolder.getUser().getPhone())
            .eq("productID", id));

        if (cnt != 0) {
            // 存在重复订单
            throw new BusinessException(400, "不允许重复下单");
        }
        // 下单
        Ordertable newOrder = new Ordertable();
        newOrder.setOrderID(idUtil.getID("order").toString());
        newOrder.setUserID(UserHolder.getUser().getPhone());
        newOrder.setProductID(Math.toIntExact(id));
        // 库存 - 1
        pro.setNum(num - 1);
        boolean success = update(pro, new QueryWrapper<Product>()
                                 .eq("num", num));
        if (!success) {
            throw new BusinessException(400, "下单失败");
        }
        // 保存订单
        ordertableService.save(newOrder);
        return newOrder.getOrderID();
    } finally {
        // ⭐️ 释放锁
        lock.unlock();
    }
}

@Test
void testWatchDog() {
    RLock lock = redissonClient.getLock("lock");
    try {
        // 只有一个线程能获取到锁（超时时间设置为-1）
        if (lock.tryLock(0, -1, TimeUnit.MILLISECONDS)) {
            // todo 实际要执行的代码
            Thread.sleep(300000);
            System.out.println("getLock: " + Thread.currentThread().getId());
        }
    } catch (InterruptedException e) {
        System.out.println(e.getMessage());
    } finally {
        // 只能释放自己的锁
        if (lock.isHeldByCurrentThread()) {
            System.out.println("unLock: " + Thread.currentThread().getId());
            lock.unlock();
        }
    }
}

@Override
public String getProductOnlyOneByRedis2(Long id) {
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
    redisScript.setLocation(new ClassPathResource("lua/shop.lua"));
    Long success = redisTemplate
        .execute(redisScript, Collections.emptyList(), id, 
                 UserHolder.getUser().getPhone());
    if (success == null || success != 0) {
        throw new BusinessException(400, "下单失败");
    }
    Long orderID = idUtil.getID("order");
    // todo 保存到阻塞队列
    return orderID.toString();
}

@Test
void addProduct() {
    Product pro = new Product();
    pro.setProductName("yixuan");
    pro.setNum(10);
    boolean success = productService.save(pro);
    String key = "RedisSessionDemo:productNum:" + pro.getId();
    String value = pro.getNum().toString();
    if (success) {
        stringRedisTemplate.opsForValue().set(key, value);
    }
    Assertions.assertNotNull(stringRedisTemplate.opsForValue().get(key));
}

private static final DefaultRedisScript<Long> redisScript;

static {
    redisScript = new DefaultRedisScript<>();
    redisScript.setLocation(new ClassPathResource("lua/shop.lua"));
    redisScript.setResultType(Long.class);
}

private BlockingQueue<Ordertable> orderTasks = 
    new ArrayBlockingQueue<>(1024 * 1024);
private static final ExecutorService SHOP_ORDER_EXECUTOR = 
    Executors.newSingleThreadExecutor();

@PostConstruct
private void init() {
    SHOP_ORDER_EXECUTOR.submit(new OrderHandler());
}

private class OrderHandler implements Runnable {
    @Override
    public void run() {
        while (true) {
            try {
                // 获取队列
                Ordertable order = orderTasks.take();
                // 库存 - 1
                boolean success = update().setSql("num = num - 1")
                    .eq("id", order.getProductID())
                    .gt("num", 0)
                    .update();
                if (!success) {
                    throw new BusinessException(400, "下单失败");
                }
                // 保存订单
                ordertableService.save(order);
            } catch (Exception e) {
                log.error("", e);
            }
        }
    }
}

@Override
public String getProductOnlyOneByRedis2(Long id) {
    // 执行lua脚本
    String userPhone = UserHolder.getUser().getPhone();
    Long success = redisTemplate.execute(
        redisScript,Collections.emptyList(), id.toString(), userPhone);
    if (success == null || success != 0) {
        throw new BusinessException(400, "下单失败");
    }

    // 创建订单
    Long orderID = idUtil.getID("order");
    Ordertable order = new Ordertable();
    order.setOrderID(orderID.toString());
    order.setProductID(Math.toIntExact(id));
    order.setUserID(userPhone);

    // 保存到阻塞队列
    orderTasks.add(order);
    return orderID.toString();
}

while (true) {
    //尝试监听队列，使用阻塞模式，最长等待2000毫秒
    Object msg = redis.call(
        "XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS s1 >");
    if (msg == null) {
        //null说明设有消息，继续下一次
        continue;
    }
    try {
        //处理消息，完成后一定要ACK
        handleMessage(msg);
    } catch (Exception e) {
        while (true) {
            Object msg2 = redis.call(
                "XREADGROUP GROUP g1 c1 COUNT 1 STREAMS s1 0");
            if (msg2 == null) {
                //null说明没有异常消息，所有消息都已确以，结束循环
                break;
            }
            try {
                //说明有异常消息，再次处理
                handleMessage(msg2);
            } catch (Exception e) {
                //再次出现异常，记录日志，继续循环
                continue;
            }
        }
    }
}

private static final DefaultRedisScript<Long> StreamScript;

static {
    StreamScript = new DefaultRedisScript<>();
    StreamScript.setLocation(new ClassPathResource("lua/shop-stream.lua"));
    StreamScript.setResultType(Long.class);
}

@Override
public String getProductOnlyOneByStream(Long id) {
    String userPhone = UserHolder.getUser().getPhone();
    Long orderID = idUtil.getID("order");
    Long success = redisTemplate.execute(
        StreamScript, Collections.emptyList(), id, userPhone, orderID);
    if (success == null || success != 0) {
        throw new BusinessException(400, "下单失败");
    }
    return orderID.toString();
}

private static final ExecutorService SHOP_ORDER_EXECUTOR = Executors.newSingleThreadExecutor();

@PostConstruct
private void init() {
    SHOP_ORDER_EXECUTOR.submit(new StreamHandler());
}

private class StreamHandler implements Runnable {

    @Override
    public void run() {
        while (true) {
            try {
                // 获取stream
                // XREADGROUP GROUP g1 c1 COUNT 1 BLOCK 2000 STREAMS stream.order >
                List<MapRecord<String, Object, Object>> list = 
                    redisTemplate.opsForStream().read(Consumer.from("g1", "c1"),           StreamReadOptions.empty().count(1).block(Duration.ofSeconds(2)),StreamOffset.create("stream.order", ReadOffset.lastConsumed())
                );
                if (list == null || list.isEmpty()) {
                    // 没有消息
                    continue;
                }
                // 解析消息
                Map<Object, Object> values = list.get(0).getValue();
                Ordertable order = BeanUtil.fillBeanWithMap(
                    values, new Ordertable(), true);
                // 库存 - 1
                boolean success = update().setSql("num = num - 1")
                    .eq("id", order.getProductID())
                    .gt("num", 0)
                    .update();
                if (!success) {
                    throw new BusinessException(400, "下单失败");
                }
                // 保存订单
                ordertableService.save(order);
                // ACK 确认
                redisTemplate.opsForStream().acknowledge(
                    "stream.order","g1", list.get(0).getId());
            } catch (Exception e) {
                while (true) {
                    try {
                        // 读取 pending-list
                        List<MapRecord<String, Object, Object>> pendingList = redisTemplate.opsForStream()
                            .read(
                            Consumer.from("g1", "c1"),
                            StreamReadOptions.empty().count(1),
                            StreamOffset.create(
                                "stream.order", ReadOffset.from("0"))
                        );
                        if (pendingList == null) {
                            // pendingList 为空 -> 结束循环
                            break;
                        }
                        // 解析消息
                        Map<Object, Object> values = 
                            pendingList.get(0).getValue();
                        Ordertable order = BeanUtil.fillBeanWithMap(
                            values, new Ordertable(), true);
                        // 库存 - 1
                        boolean success = update().setSql("num = num - 1")
                            .eq("id", order.getProductID())
                            .gt("num", 0)
                            .update();
                        if (!success) {
                            throw new BusinessException(400, "下单失败");
                        }
                        // 保存订单
                        ordertableService.save(order);
                        // ACK 确认
                        redisTemplate.opsForStream()
                            .acknowledge("stream.order","g1", 
                                         pendingList.get(0).getId());
                    } catch (Exception excp) {
                        log.error("", excp);
                    }
                }
            }
        }
    }

public Boolean getFollow(Long followId) {
    String phone = UserHolder.getUser().getPhone();
    User user = userMapper.selectOne(new QueryWrapper<User>().eq("phone", phone));
    Integer userID = user.getId();
    return followMapper.exists(
        new QueryWrapper<Follow>().eq("followID", followId).eq("userID", userID)
    );
}

public Boolean setFollow(Long id) {
    String phone = UserHolder.getUser().getPhone();
    User user = userMapper
        .selectOne(new QueryWrapper<User>().eq("phone", phone));
    Integer userID = user.getId();
    boolean isFollowed = followMapper.exists(
        new QueryWrapper<Follow>()
        .eq("followID", id).eq("userID", userID)
    );
    if (isFollowed) {
        // 取关
        followMapper.delete(new QueryWrapper<Follow>()
                            .eq("followID", id).eq("userID", userID));
        return false;
    }
    // 关注
    Follow f = new Follow();
    f.setUserID(userID);
    f.setFollowID(Math.toIntExact(id));
    followMapper.insert(f);
    return true;
}

public Boolean setFollow(Long id) {
    String phone = UserHolder.getUser().getPhone();
    User user = userMapper.selectOne(new QueryWrapper<User>().eq("phone", phone));
    Integer userID = user.getId();
    boolean isFollowed = followMapper.exists(
        new QueryWrapper<Follow>().eq("followID", id).eq("userID", userID)
    );
    if (isFollowed) {
        // 取关
        followMapper.delete(new QueryWrapper<Follow>().eq("followID", id).eq("userID", userID));
        redisTemplate.opsForSet().remove("RedisSessionDemo:follow:" + userID, String.valueOf(id));
        return false;
    }
    // 关注
    Follow f = new Follow();
    f.setUserID(userID);
    f.setFollowID(Math.toIntExact(id));
    followMapper.insert(f);
    redisTemplate.opsForSet().add("RedisSessionDemo:follow:" + userID, String.valueOf(id));
    return true;
}

public List<UserDTO> getCommonFollow(Long followID) {
    String phone = UserHolder.getUser().getPhone();
    User user = userMapper.selectOne(new QueryWrapper<User>().eq("phone", phone));
    Integer userID = user.getId();
    Set<String> commonIds = redisTemplate.opsForSet().intersect("RedisSessionDemo:follow:" + userID, "RedisSessionDemo:follow:" + followID);
    if (commonIds == null) {
        return null;
    }
    List<User> commonUser = userMapper.selectBatchIds(commonIds);
    ArrayList<UserDTO> results = new ArrayList<>();
    commonUser.forEach(u -> results.add(BeanUtil.copyProperties(u, UserDTO.class)));
    return results;
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class LikedDTO {
    /**
     * 点赞数量
     */
    long likedSum;
    /**
     * 用户是否点过赞
     */
    Boolean isLiked;
}