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();
    }
}

@Component
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        *// 拿到session*
*        *HttpSession session = request.getSession();
 
        *// 拿到session中的用户信息*
*        *UserDTO user = (UserDTO)session.getAttribute("user");
 
        *// 判断用户是否存在*
*        *if(user == null) {
            *// 如果不存在，直接拦截*
*            *response.setStatus(HttpServletResponse.*SC_UNAUTHORIZED*);
            return false;
        }
 
        *// 存在的话，存放到threadlocal中，这样子后面其它拦截器使用2*
*        ***UserHolder.** ***saveUser** ***(user);** 
 
        *// 放行*
*        *return true;
    }
}

@Configuration
public class WebConfig implements WebMvcConfigurer {
    @Autowired
    private LoginInterceptor loginInterceptor;
    
    @Autowired
    private RefrashInterceptor refrashInterceptor;
 
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(refrashInterceptor).addPathPatterns("/**").order(0);
        registry.addInterceptor(loginInterceptor)
                .addPathPatterns("/**")
                .excludePathPatterns("/user/code")
                .excludePathPatterns("/user/login")
                .order(1);
    }
}

order(0) → preHandle
order(1) → preHandle
Controller 执行
order(1) → afterCompletion
order(0) → afterCompletion

public class RefreshInterceptor implements HandlerInterceptor {
    ...
 
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        // 清理 ThreadLocal，防止内存泄漏
        UserHolder.removeUser();
    }
}

@Override
public Result getShopByID(Long id) {
    *// 1. 从redis中查询shop缓存*
*    *String cache_key = RedisConstants.*CACHE_SHOP_KEY *+ id;
    String shopJson = stringRedisTemplate.opsForValue().get(cache_key);
 
    *// 2. 存在，并且有内容，说明是真的有信息，则直接返回*
*    *if (StringUtils.*hasText*(shopJson)) {
        return Result.*ok*(JSONUtil.*toBean*(shopJson, Shop.class));
    }
 
    ***// 存在，但是没有内容，说明是空对象，是为了避免缓存穿透的** *
*    ***if(shopJson != null)**  {
        return Result.*fail*("商铺不存在！");
    }
 
    *// 3. 不存在，根据id查询数据库*
*    *Shop shop = getById(id);
 
    ***// 4. 不存在，不是直接返回错误，而是将该id写入redis，设为空对象，设置ttl，避免缓存穿透💥** *
*    *if(shop == null) {
        stringRedisTemplate.opsForValue().set(
                RedisConstants.*CACHE_SHOP_KEY *+ id,
                **""** ,
                RedisConstants.*CACHE_NULL_TTL*,
                TimeUnit.*MINUTES*);
        return Result.*fail*("商铺不存在！");
    }
 
    *// 5. 存在，将数据写到redis中，设置过期时间（缓存更新策略）*
*    *stringRedisTemplate.opsForValue().set(cache_key, JSONUtil.*toJsonStr*(shop));
    stringRedisTemplate.expire(cache_key, RedisConstants.*CACHE_SHOP_TTL*, TimeUnit.*MINUTES*);
 
    *// 6. 返回*
*    *return Result.*ok*(shop);
}

private boolean tryLock(Long id) {
    *// 为了防止线程崩了导致死锁，需要设置过期时间*
*    *Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(RedisConstants.*LOCK_SHOP_KEY *+ id, "1", RedisConstants.*LOCK_SHOP_TTL*, TimeUnit.*SECONDS*);
    return **BooleanUtil.** ***isTrue** ***(flag)** ;
}

@Data
public class RedisData {
    private LocalDateTime expireTime;
    private Object data;
}
 
// 反序列化时候：
RedisData redisData = JSONUtil.*toBean*(shopJson, RedisData.class);
**JSONObject**  data = (**JSONObject** )redisData.getData();
Shop shop = JSONUtil.*toBean*(data, Shop.class);

*// 缓存击穿（互斥锁实现方式，因为没有逻辑过期，所以会过期，请求可能直接打在数据库上，所以需要防止缓存穿透）*
private Shop getShopByBreakDownMutex(Long id) {
    *// 1. 从redis中查询shop缓存（这里用string类型演示）*
*    *String cache_key = RedisConstants.*CACHE_SHOP_KEY *+ id;
    String shopJson = stringRedisTemplate.opsForValue().get(cache_key);
 
    *// 2. 存在缓存，并且有内容，说明是真的有信息，则直接返回*
*    *if (StringUtils.*hasText*(shopJson)) {
        return JSONUtil.*toBean*(shopJson, Shop.class);
    }
 
    *// 存在缓存，但是没有内容，说明是空对象，是为了避免缓存穿透的，直接返回null*
*    *if(shopJson != null) {
        return null;
    }
 
    try {
        ***// 3. 不存在缓存，先获取锁** *
*        *boolean isLock = tryLock(id);
 
        ***// 3.1 如果拿不到锁，休眠后重试** *
*        *if (!isLock) {
            Thread.*sleep*(50);
            return getShopByBreakDownMutex(id); *// 递归去调用重试*
*        *}
 
        ***// 3.2 如果拿到锁，进行doublecheck，防止后面不必要的访问数据库** *
*        *String doublecheck = stringRedisTemplate.opsForValue().get(cache_key);
        if(StringUtils.*hasText*(doublecheck)) {
            return JSONUtil.*toBean*(doublecheck, Shop.class);
        }
 
        *// 实在没有再去查数据库*
*        *Shop shop = getById(id);
 
        *// 3.3 如果数据库中不存在，不是直接返回错误，而是将该id写入redis，设为空对象，设置ttl，避免缓存穿透💥*
*        *if(shop == null) {
            stringRedisTemplate.opsForValue().set(
                    RedisConstants.*CACHE_SHOP_KEY *+ id,
                    "",
                    RedisConstants.*CACHE_NULL_TTL*,
                    TimeUnit.*MINUTES*);
            return null;
        }
 
        *// 3.4 数据库中存在，将数据写到redis中，设置过期时间（缓存更新策略）*
*        *stringRedisTemplate.opsForValue().set(cache_key, JSONUtil.*toJsonStr*(shop), RedisConstants.*CACHE_SHOP_TTL*, TimeUnit.*MINUTES*);
 
        return shop;
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    } finally {
        **unlock(id)** ; // 别忘了释放锁
    }
}

// 创建线程池
private ExecutorService executorService = Executors.*newFixedThreadPool*(10);
 
*// 缓存击穿（逻辑过期方式，因为缓存一直存在，所以请求不会直接打到数据库，并且数据库也有数据，所以不需要考虑缓存穿透）*
private Shop getShopByBreakDownLogicExpire(Long id) {
    *// 1. 从redis中查询shop缓存*
*    *String cache_key = RedisConstants.*CACHE_SHOP_KEY *+ id;
    String shopJson = stringRedisTemplate.opsForValue().get(cache_key);
 
    *// 2. 判断缓存是否命中*
*    *if (!StringUtils.*hasText*(shopJson)) {
        *// 3. 如果没命中，说明数据库中也没有数据，直接返回null*
*        *return null;
    }
 
    ***// 4. 如果命中了，拿到数据，判断缓存逻辑过期时间** *
*    // （因为Object通过redis序列化之后转化为字符串，但是反序列化之后不知道类型是什么，所以用通用类型JSONObject表示）*
*    *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(LocalDateTime.*now*().isBefore(expireTime)) {
        return shop;
    }
 
    *// 6. 如果过期了，获取锁资源，判断锁资源是否拿到*
*    *boolean isLock = tryLock(id);
    if (isLock) {
        try {
            ***// 7. 如果拿到锁资源，则创建新线程去重建缓存（这里用线程池）** *
    *        *executorService.submit(() -> {
                try {
                    insertRedisData(id, RedisConstants.*LOCK_SHOP_TTL*);
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
            });
        }  finally {
            **unlock(lock_key); ** ***// 解锁必须在主线程执行** *
        }
    }
 
    *// 8. 返回数据*
*    *return shop;
}

*// 方法3：根据指定的Key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题*
public <T, ID> T getShopPreventPenetrate(
        String prefix_key,
        ID id,
        **Class<T> type** ,
        **Function<ID, T> dbCallBack** ,
        Long time, TimeUnit unit) {
    *// 1. 从redis中查询缓存*
*    *String key = prefix_key + id;
    String jsonStr = stringRedisTemplate.opsForValue().get(key);
 
    *// 2. 存在缓存，并且有内容，说明是真的有信息，则直接返回对象*
*    *if (StringUtils.*hasText*(jsonStr)) {
        try {
            *// 先尝试直接转为对象*
*            *T bean;
            if (jsonStr.trim().startsWith("{")) {
                JSONObject jsonObject = JSONUtil.*parseObj*(jsonStr);
                *// 如果存在 data 字段，就取 data 部分*
*                *if (jsonObject.containsKey("data")) {
                    bean = JSONUtil.*toBean*(jsonObject.getJSONObject("data"), type);
                } else {
                    bean = JSONUtil.*toBean*(jsonObject, type);
                }
            } else {
                *// 如果不是对象，而是字符串等，直接转*
*                *bean = JSONUtil.*toBean*(jsonStr, type);
            }
            return bean;
        } catch (Exception e) {
            *log*.error("反序列化缓存失败，jsonStr={}", jsonStr, e);
        }
    }
 
    *// 存在缓存，但是没有内容，说明是空对象，是为了避免缓存穿透的，直接返回null*
*    *if(jsonStr != null) {
        return null;
    }
 
    *// 3. 不存在，根据id查询数据库*
*    ***T object = dbCallBack.apply(id)** ;
 
    *// 4. 不存在，不是直接返回错误，而是将该id写入redis，设为空对象，设置ttl，避免缓存穿透💥*
*    *if(object == null) {
        stringRedisTemplate.opsForValue().set(key, "", RedisConstants.*CACHE_NULL_TTL*, TimeUnit.*MINUTES*);
        return null;
    }
 
    *// 5. 存在，将数据写到redis中，设置过期时间（缓存更新策略）*
*    *this.set(key, JSONUtil.*toJsonStr*(object), time, unit);
 
    return object;
}

private final static long *beginTime *= 1735689600L; *// 设置起始时间（2025年1月1号0点0分0时）*
 
private final static long *OFFSET_BIT *= 32L; // 时间戳偏移量
 
***/**** *
*** * 创建一个全局唯一的ID，由 “符号位 + 时间戳 + 序列号” 组成** *
*** */** *
public long nextId(String prefix_key) {
    *// 1. 创建时间戳*
*    *LocalDateTime now = LocalDateTime.*now*();
    long timeStamp = now.**toEpochSecond** (**ZoneOffset.** ***UTC** *) - *beginTime*;
 
    *// 2. 通常increment指令，生成序列号（对于key，为了提高安全性，最好加上一个格式时间，让每天生成的序列号区分开）*
*    *String date = now.**format** (**DateTimeFormatter.** ***ofPattern** *("yyyy:MM:dd"));
    long serial = stringRedisTemplate.opsForValue().**increment** (**"inc:" + prefix_key + ":" + date** );
 
    *// 3. 拼接成ID进行返回*
*    *return timeStamp << *OFFSET_BIT *| serial;
}

@SpringBootTest
class RedisWorkerTest {
    @Autowired
    private RedisWorker redisWorker;
    
    private ExecutorService pool = Executors.*newFixedThreadPool*(500);
 
    @Test
    void nextId() throws InterruptedException {
        // 启动300个线程，每个线程取100次ID
        CountDownLatch countDownLatch = new CountDownLatch(300);
 
        Runnable task = () -> {
            for(int i = 0; i < 100; ++i) {
                **long id = redisWorker.nextId("order");** 
                System.*out*.println("id = " + id);
            }
            countDownLatch.countDown();
        };
 
        long begin = System.*currentTimeMillis*();
        for(int i = 0; i < 300; ++i) {
            pool.submit(task);
        }
        countDownLatch.await();
        long end = System.*currentTimeMillis*();
        System.*out*.println("用时：" + (end - begin) + "ms");
    }
}

@Override
@Transactional
public Result seckill(Long voucherId) {
    *// 1. 根据id，获取优惠券信息*
*    *SeckillVoucher seckillVoucher = seckillVoucherService.query().eq("voucher_id", voucherId).one();
 
    *// 2. 判断秒杀是否开始*
*    *if(seckillVoucher.getBeginTime().isAfter(LocalDateTime.*now*())) {
        return Result.*fail*("活动尚未开始！");
    }
 
    *// 3. 判断秒杀是否结束*
*    *if(seckillVoucher.getEndTime().isBefore(LocalDateTime.*now*())) {
        return Result.*fail*("活动已经结束！");
    }
 
    *// 4. 判断是否有库存*
*    *if(seckillVoucher.getStock() < 1) {
        return Result.*fail*("优惠券已被抢完！");
    }
 
    *// 5. 如果有库存，则库存减少一个*
*    *boolean isDeduct = seckillVoucherService.update()
            .eq("voucher_id", voucherId)
            **.gt("stock", 0)**  
*            ***.setSql("stock = stock - 1")** ** ** ***// 利用CAS机制，防止出现并发问题💥** *
            .update();
    if(!isDeduct) {
        return Result.*fail*("库存不足！");
    }
 
    *// 6. 创建订单，并且保存到数据库*
*    *VoucherOrder order = new VoucherOrder();
    order.setUserId(UserHolder.*getUser*().getId());
    order.setVoucherId(voucherId);
    order.setId(redisWorker.nextId("order")); *// 使用redis创建的全局唯一ID，作为订单ID*
*    *save(order);
 
    *// 7. 返回订单ID*
*    *return Result.*ok*(order.getId());
}

@Service
public class OrderService {
    public void outer() {
        this.inner(); // 调用事务方法
    }
 
    @Transactional
    public void inner() {
        // 期望有事务
    }
}

@Override
public Result seckill(Long voucherId) {
    *// 1. 根据id，获取优惠券信息*
*    *SeckillVoucher seckillVoucher = seckillVoucherService.query().eq("voucher_id", voucherId).one();
 
    *// 2. 判断秒杀是否开始*
*    *if(seckillVoucher.getBeginTime().isAfter(LocalDateTime.*now*())) {
        return Result.*fail*("活动尚未开始！");
    }
 
    *// 3. 判断秒杀是否结束*
*    *if(seckillVoucher.getEndTime().isBefore(LocalDateTime.*now*())) {
        return Result.*fail*("活动已经结束！");
    }
 
    *// 4. 判断是否有库存*
*    *if(seckillVoucher.getStock() < 1) {
        return Result.*fail*("优惠券已被抢完！");
    }
 
    *// 💥① ****需要在deductStock方法外面加锁，因为该方法有@Transactional修饰，等到方法结束才会提交事务，所以如果在方法内加锁，等到解锁后事务才会提交，同样会有并发安全问题** **！*
*    // 💥② ****因为加锁是为了同一个用户只能下单一次，所以是互斥同一个用户，那么对于不同用户来说就没办法互斥了，所以可以用userId作为锁对象，提高效率** **！*
*    // 💥③ ****由于toString()每次都会创建一个新对象，所以锁就不一样，没办法互斥同一个用户，正确做法是使用 intern() 方法将字符串放到字符串常量池，这样子保证每个用户id每次拿到的字符串对象都是同一个** *
*    *Long userId = UserHolder.*getUser*().getId();
    synchronized(**userId.toString().intern()** ) {
        IVoucherOrderService orderService = (IVoucherOrderService) **AopContext.** ***currentProxy** *();
        return orderService.deductStock(voucherId, userId);
    }
}
 
**@Transactional** 
public Result deductStock(Long voucherId, Long userId) {
    *// 5. ****解决一人一单问题** **💥*
*    //  5.1 根据用户id，查询对应订单*
*    *Integer count = query().eq("user_id", userId).eq("voucher_id", voucherId).count();
    *//  5.2 如果存在对应订单，则直接返回*
*    *if(count > 0) {
        return Result.*fail*("已经购买过优惠券了，不可重复购买！");
    }
 
    *// 6. 如果有库存，则库存减少一个*
*    *boolean isDeduct = seckillVoucherService.update()
            .eq("voucher_id", voucherId)
            .gt("stock", 0) *// 利用CAS机制，防止并发问题💥*
*            *.setSql("stock = stock - 1")
            .update();
    if(!isDeduct) {
        return Result.*fail*("库存不足！");
    }
 
    *// 7. 创建订单，并且保存到数据库*
*    *VoucherOrder order = new VoucherOrder();
    order.setUserId(userId);
    order.setVoucherId(voucherId);
    order.setId(redisWorker.nextId("order")); *// 使用redis创建的全局唯一ID，作为订单ID*
*    *save(order);
 
    *// 8. 返回订单ID*
*    *return Result.*ok*(order.getId());
}

public class SimpleRedisLock implements ILock {
 
    private StringRedisTemplate stringRedisTemplate;
 
    private String transaction_name; *// 业务名称，用于拼接key*
 
*    *private String uuid = UUID.*randomUUID*().toString(); *// uuid用于区分不同jvm中的同一线程*
 
*    *private final static String *KEY_PREFIX *= "lock:"; *// key前缀*
 
*    *public SimpleRedisLock(StringRedisTemplate stringRedisTemplate, String transaction_name) {
        this.stringRedisTemplate = stringRedisTemplate;
        this.transaction_name = transaction_name;
    }
 
    @Override
    public boolean tryLock(Long expireTime) {
        *// 1. 获取 “uuid + 线程id” 标识作为value*
*        //  💥uuid用于区分不同jvm中的同一线程*
*        //  💥线程id用于区分同一jvm中的线程*
*        ***String threadId = uuid + "-" + Thread.** ***currentThread** ***().getId()** ;
 
        *// 2. 存放到redis中*
*        *Boolean isLock = stringRedisTemplate.opsForValue().setIfAbsent(*KEY_PREFIX *+ transaction_name, threadId, expireTime, TimeUnit.*SECONDS*);
 
        *// 3. 返回是否存放成功*
*        *return BooleanUtil.*isTrue*(isLock);
    }
 
    @Override
    public void unlock() {
        *// 1. 获取当前线程的 “uuid + 线程id” 标识*
*        *String threadId = uuid + "-" + Thread.*currentThread*().getId();
 
        *// 2. 获取redis中该锁的标识*
*        *String s = stringRedisTemplate.opsForValue().get(*KEY_PREFIX *+ transaction_name);
 
        *// 3. 判断当前标识是否与redis中的标识相同*
*        *if(threadId.equals(s)) {
            *// 4. 如果相同，则删除该锁*
*            *stringRedisTemplate.delete(*KEY_PREFIX *+ transaction_name);
        }
    }
}

@Override
    public Result seckill(Long voucherId) {
        *// 1. 根据id，获取优惠券信息*
*        *SeckillVoucher seckillVoucher = seckillVoucherService.query().eq("voucher_id", voucherId).one();
 
        *// 2. 判断秒杀是否开始*
*        *if(seckillVoucher.getBeginTime().isAfter(LocalDateTime.*now*())) {
            return Result.*fail*("活动尚未开始！");
        }
 
        *// 3. 判断秒杀是否结束*
*        *if(seckillVoucher.getEndTime().isBefore(LocalDateTime.*now*())) {
            return Result.*fail*("活动已经结束！");
        }
 
        *// 4. 判断是否有库存*
*        *if(seckillVoucher.getStock() < 1) {
            return Result.*fail*("优惠券已被抢完！");
        }
 
        *// 💥① 需要在方法外面加锁，因为该方法有@Transactional修饰，等到方法结束才会提交事务，所以如果在方法内加锁，等到解锁后事务才会提交，同样会有并发安全问题！*
*        // 💥② 因为加锁是为了同一个用户只能下单一次，所以是互斥同一个用户，那么对于不同用户来说就没办法互斥了，所以可以用userId作为锁对象，提高效率！*
*        // 💥③ 由于toString()每次都会创建一个新对象，所以锁就不一样，没办法互斥同一个用户，正确做法是使用 intern() 方法将字符串放到字符串常量池，这样子保证每个用户id每次拿到的字符串对象都是同一个*
*        *Long userId = UserHolder.*getUser*().getId();
*//        synchronized(userId.toString().intern()) {*
*//            IVoucherOrderService orderService = (IVoucherOrderService) AopContext.currentProxy();*
*//            return orderService.deductStock(voucherId, userId);*
*//        }*
 
*        ****// 引入分布式锁💥** *
*        // 1. 首先获取分布式锁对象*
*        *SimpleRedisLock lock = new SimpleRedisLock(stringRedisTemplate, "order:" + userId);
 
        *// 2. 判断是否获取锁*
*        *boolean isLock = lock.tryLock(120L);
        if(!isLock) {
            *// 3. 如果没拿到锁，说明同一用户已经拿到锁并且大概率要抢购订单了，所以当前线程不能再获取了*
*            *return Result.*fail*("您已经抢过优惠券了，请勿重复抢购！");
        }
 
        *// 4. 如果拿到锁了，则开始抢购业务*
*        *try {
            IVoucherOrderService orderService = (IVoucherOrderService) AopContext.*currentProxy*();
            return orderService.deductStock(voucherId, userId);
        } finally {
            lock.unlock(); *// 别忘了释放锁！！！*
*        *}
    }

*-- 1. 获取锁标识*
*-- 2. 判断锁标识是否一致*
*-- 3. 一致的话对锁删除*
 
if(*redis*.*call*('get', *KEYS*[1]) == *ARGV*[1]) then
    return *redis*.*call*('del', *KEYS*[1])
end
return 0

private final static DefaultRedisScript<Long> *unlockRedisScript*;
 
static {
    *unlockRedisScript *= new DefaultRedisScript<>();
    *unlockRedisScript*.setLocation(new ClassPathResource("unlock.lua"));
    *unlockRedisScript*.setResultType(Long.class);
}
 
@Override
public void unlock() {
*    *stringRedisTemplate.**execute** (    // execute函数就是eval命令
            *unlockRedisScript*,
            Collections.*singletonList*(*KEY_PREFIX *+ transaction_name),
            uuid + "-" + Thread.*currentThread*().getId());
}

// 获取点赞排行榜中的用户信息UserDTO
@Override
public Result likesBlog(Long id) {
    *// 拿到前五个用户id（存储的是string类型）*
*    *String key = RedisConstants.*BLOG_LIKED_KEY *+ id;
    Set<String> showList_string = stringRedisTemplate.opsForZSet().**range** (key, 0, 4);
    if(CollectionUtil.*isEmpty*(showList_string)) {
        return Result.*ok*(Collections.*emptyList*()); *// 不存在用户点赞，则直接返回空列表*
*    *}
 
    *// 转化为Long类型*
*    *List<Long> showList_id = showList_string.stream()
            .map(Long::*valueOf*)
            .collect(Collectors.*toList*());
 
    *// 然后查出User，转化为UserDTO类型，进行返回*
*    *String idsStr = **StrUtil.** ***join** *(",", showList_id);
    List<UserDTO> userDTOS = userService.query().**in** ("id", showList_id)
            .**last** ("order by field(id, " + idsStr + ")").list()
            .stream()
            .map(user -> BeanUtil.*copyProperties*(user, UserDTO.class))
            .collect(Collectors.*toList*());
 
    return Result.*ok*(userDTOS);
}

// 发布博客后推送消息给粉丝
@Override
public Result saveBlog(Blog blog) {
    *// 1. 获取登录用户*
*    *UserDTO user = UserHolder.*getUser*();
    blog.setUserId(user.getId());
 
    *// 2. 保存探店博文*
*    *save(blog);
 
    ***// 3. 获取该博主的所有粉丝** *
*    *List<Long> followUserIds = followService.query().eq("follow_user_id", user.getId()).list()
            .stream()
            .map(Follow::getUserId)
            .collect(Collectors.*toList*());
 
    ***// 4. 将博客推送给粉丝** *
*    *for(Long id : followUserIds) {
        stringRedisTemplate.opsForZSet().add(RedisConstants.*FEED_KEY *+ id, blog.getId().toString(), System.*currentTimeMillis*());
    }
 
    *// 返回id*
*    *return Result.*ok*(blog.getId());
}
 
 
// 粉丝通过关注页面拿到推送的数据
@Override
public Result queryFollow(Long lastId, Integer offset) {
    *// 1. 获取当前用户信息*
*    *Long userId = UserHolder.*getUser*().getId();
 
    *// 2. 获取redis中的推送内容*
*    *Set<ZSetOperations.TypedTuple<String>> typedTuples = stringRedisTemplate.opsForZSet()
            .**reverseRangeByScoreWithScores** (
                RedisConstants.*FEED_KEY *+ userId,
                0,
                lastId,
                offset,
                2
    );
    if(typedTuples == null || typedTuples.isEmpty()) {
        return Result.*ok*(Collections.*emptyList*());
    }
 
    ***// 3. 解析要传给前端的部分** *
*    *List<Long> list = new ArrayList<>(typedTuples.size());
    long minTime = 0;
    int os = 1;
    for(ZSetOperations.TypedTuple<String> e : typedTuples) {
        *// 取出博客id、时间戳*
*        *long blogId = Long.*parseLong*(e.getValue());
        long score = e.getScore().longValue();
 
        *// 给三个变量赋值*
*        *list.add(blogId);
        if(minTime == score) {
            os++;
        } else {
            minTime = score;
            os = 1;
        }
    }
    *log*.info("list=" + list);
 
 
    *// 4. 将List<Long>转化为List<Blog>*
*    *String idsStr = StrUtil.*join*(",", list);
    List<Blog> blogs = query().in("id", list).last("order by field(id, " + idsStr + ")").list();
    for(Blog blog : blogs) {
        *// 获取用户信息，填充Blog*
*        *setUser(blog);
 
        *// 追加判断blog是否被当前用户点赞，逻辑封装到isBlogLiked方法中*
*        *isBlogLiked(blog);
    }
    *log*.info("blogs=" + blogs);
 
    *// 5. 封装成ScrollResult*
*    *ScrollResult scrollResult = new ScrollResult();
    scrollResult.setList(blogs);
    scrollResult.setOffset(os);
    scrollResult.setMinTime(minTime);
 
    *// 6. 返回*
*    *return Result.*ok*(scrollResult);
}

Map<Long, List<Shop>> collect = shops.stream().**collect** (**Collectors.** ***groupingBy** *(Shop::getTypeId));