黑马点评（达人探店）

达人探店

一、发布探店笔记

发布探店笔记功能是项目本身就完成了的功能，他会把图片存在本地，有兴趣可以去看源码，在UploadCOntroller类下

二、查看探店笔记

这个功能项目本身是没有完成这个接口的，所以需要我们自己去完成。

三、点赞功能

项目本身已经实现了点赞功能

项目原本的写法是通过点击点赞标识，直接向数据库发起请求，更新liked字段，并没有加任何判断。

这样看似没问题，但是却不符合逻辑，因为一个用户可以对同一篇笔记多次点赞，而现实应该是点一次赞，再点一次取消赞。
所以我们需要根据下面的需求更新代码：

使用redis的ZSet集合存储（key：被点赞的博客id，value：点赞的用户id）

使用Zset是为了后面方便按照用户的点赞时间排序（展示最先点赞的5个用户)

    /**
     * 点赞功能
     *
     * @param id
     * @return
     */
    @Override
    public Result likeBlog(Long id) {
        ZSetOperations<String, String> opsForZSet = stringRedisTemplate.opsForZSet();
        //1.获取当前登录用户
        UserDTO user = UserHolder.getUser();
        //2.判断当前用户是否在点赞列表中
        String key = "blog:liked:" + id;
        Double score = opsForZSet.score(key, user.getId().toString());

        if (score == null) {
            //3.如果不在，则点赞
            //3.1 数据库对应blog的点赞数+1
            boolean isSuccess = this.update().setSql("liked = liked + 1").eq("id", id).update();
            //3.1 redis中blog对应的set集合添加当前用户
            if (isSuccess) {
                opsForZSet.add(key, user.getId().toString(), System.currentTimeMillis());
            }
        } else {
            //4.如果在，则取消点赞
            //4.1 数据库对应blog的点赞数-1
            boolean isSuccess = this.update().setSql("liked = liked - 1").eq("id", id).update();
            //4.2 redis中blog的set集合移除当前用户
            if (isSuccess) {
                opsForZSet.remove(key, user.getId().toString());
            }
        }
        return Result.ok();

    }

/**
     * 判断当前用户有没有给传来的博客点过赞
     * @param blog
     */
    private void isBlogLiked(Blog blog) {
        ZSetOperations<String, String> opsForZSet = stringRedisTemplate.opsForZSet();
        //1.获取当前登录用户
        UserDTO user = UserHolder.getUser();
        if (user == null) {
            //用户未登录
            return;
        }
        //2.判断当前用户是否在点赞列表中
        String key = "blog:liked:" + blog.getId();
        Double score = opsForZSet.score(key, user.getId().toString());
        blog.setIsLike(score != null);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53

点赞排行榜

在redis中使用ZSet存储用户点赞情况，key为博客的id，value为给这个博客点赞的用户id，并且每个entry都有一个score，这个score为当前点赞时间的距离1970.1.1的毫秒数，使用range方法获取前五个点赞的用户id。拿着用户id去数据库查出它们的头像等信息并展示。

四、关注和取关

这里没有什么特别要说的，只是拿着前端传来的字段修改数据库

@Service
public class FollowServiceImpl extends ServiceImpl<FollowMapper, Follow> implements IFollowService {

    @Resource
    StringRedisTemplate stringRedisTemplate;

    /**
     * 先判断是否关注，已关注则取关，未关注则关注
     *
     * @param id
     * @param isFollow 传来的参数为true，则是要关注，false则是要取关
     * @return
     */
    @Override
    public Result follow(Long id, Boolean isFollow) {
        Long userId = UserHolder.getUser().getId();
        String key = "follows:" + userId;
        SetOperations<String, String> opsForSet = stringRedisTemplate.opsForSet();
        if (BooleanUtil.isTrue(isFollow)) {
            Follow follow = new Follow();
            follow.setFollowUserId(id);
            follow.setUserId(userId);
            follow.setCreateTime(LocalDateTime.now());
            this.save(follow);
            //关注后还要将被关注的用户id存在redis中
            opsForSet.add(key, String.valueOf(id));
        } else {
            LambdaQueryWrapper<Follow> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(Follow::getFollowUserId, id).eq(Follow::getUserId, userId);
            this.remove(lambdaQueryWrapper);
            //取消关注后还要将被取消关注的用户从redis的set集合中移除
            opsForSet.remove(key, id);
        }
        return Result.ok();
    }

    /**
     * 判断当前传来的用户是否被当前用户关注了
     * @param id
     * @return
     */
    @Override
    public Result isFollow(Long id) {
        Long userId = UserHolder.getUser().getId();
//        LambdaQueryWrapper<Follow> lambdaQueryWrapper = new LambdaQueryWrapper<>();
//        lambdaQueryWrapper.eq(Follow::getFollowUserId, id).eq(Follow::getUserId, userId);
//        Follow one = this.getOne(lambdaQueryWrapper);
//        if (one == null) {
//            return Result.ok(false);
//        } else {
//            return Result.ok(true);
//        }
        /**
         * 在添加了“关注后将关注用户id添加到redis存储”功能后，
         * 就不需要查询数据库来判断当前用户有咩有关注传来的用户了，直接在redis中判断
         */
        String key = "follows:" + userId;
        Boolean member = stringRedisTemplate.opsForSet().isMember(key, String.valueOf(id));
        if (BooleanUtil.isTrue(member)) {
            return Result.ok(true);
        } else {
            return Result.ok(false);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65

共同关注

共同关注是指userA和userB两个人关注的列表中相同的用户。
这里选择使用redis的Set数据结构求交集。
那么在向数据库中保存前端传来的关注信息的同时，还需要将当前登录用户关注的用户id在redis中保存一份，例如：这里的意思是，用户1010关注了用户2。

    /**
     * 先判断是否关注，已关注则取关，未关注则关注
     *
     * @param id
     * @param isFollow 传来的参数为true，则是要关注，false则是要取关
     * @return
     */
    @Override
    public Result follow(Long id, Boolean isFollow) {
        Long userId = UserHolder.getUser().getId();
        String key = "follows:" + userId;
        SetOperations<String, String> opsForSet = stringRedisTemplate.opsForSet();
        if (BooleanUtil.isTrue(isFollow)) {
            Follow follow = new Follow();
            follow.setFollowUserId(id);
            follow.setUserId(userId);
            follow.setCreateTime(LocalDateTime.now());
            this.save(follow);
            //关注后还要将被关注的用户id存在redis中
            opsForSet.add(key, String.valueOf(id));
        } else {
            LambdaQueryWrapper<Follow> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(Follow::getFollowUserId, id).eq(Follow::getUserId, userId);
            this.remove(lambdaQueryWrapper);
            //取消关注后还要将被取消关注的用户从redis的set集合中移除
            opsForSet.remove(key, id);
        }
        return Result.ok();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

在完成向数据库保存关注信息的同时向redis中存一份的功能后，
我们就可以获取用户1010，和用户1011的关注列表；
比如登录的用户是1010，他要查询他和1011的共同关注，只需要求他们两个关注列表的交集就可以了，使用redis的Set数据结构中的intersect方法就可以获得共同关注的userId。拿着id去数据库查用户头像，名称等信息。

    @Override
    public Result getCommonFollows(Long id) {
        SetOperations<String, String> opsForSet = stringRedisTemplate.opsForSet();
        Long userId = UserHolder.getUser().getId();
        String key = "follows:" + userId;
        String key2 = "follows:" + id;
        Set<String> intersect = opsForSet.intersect(key, key2);
        if(intersect == null || intersect.isEmpty()){
            return Result.ok(Collections.emptyList());
        }
        List<Long> userIdCollect = intersect.stream().map(Long::valueOf).collect(Collectors.toList());
        List<User> users = baseMapper.selectBatchIds(userIdCollect);
        List<UserDTO> collect = users.stream().map(item -> BeanUtil.copyProperties(item, UserDTO.class)).collect(Collectors.toList());
        return Result.ok(collect);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

五、关注列表笔记推送

feed流

拉模式

拉模式是指张三，李四发布了笔记后，赵六查看收件箱时，会从发件箱拉取笔记到收件箱，再根据时间戳排序。这种模式又叫做读扩散，因为是等到要读的时候才拉取。
优点：
不占内存
缺点：
拉取耗时，因为要等到读的时候才拉取。

推模式

张三，李四在发送笔记时直接将笔记推到自己的所有粉丝的收件箱中。
优点：延时低，因为在发布笔记时就直接推给粉丝了，粉丝不必等打开收件箱时再拉取。
缺点：如果粉丝多，比如张三有一个亿的粉丝，那么他就需要推送一个亿份笔记，对内存要求较高

推拉结合

详情看视频
推拉结合

推模式的代码实现

实现思路

• 用户A发布笔记，从数据库查出博主的粉丝id
• 将笔记的id存到每个粉丝的收件箱中（收件箱是redis的一个ZSet集合，key为“feed:userId，value为博客id）
• 使用ZSet是为了排序，score值设置为当前时间戳
  代码：

    /**
     * 保存笔记，并且将笔记的id发送给笔记发布者的粉丝
     *
     * @param blog
     * @return
     */
    @Override
    public Result saveBlog(Blog blog) {
        // 1.获取登录用户
        UserDTO user = UserHolder.getUser();
        blog.setUserId(user.getId());
        // 2.保存探店博文
        boolean save = blogService.save(blog);
        if (save) {
            ZSetOperations<String, String> ops = stringRedisTemplate.opsForZSet();
            //3.查询笔记发布者的所有粉丝 select * from tb_follow where follow_user_id = ?
            LambdaQueryWrapper<Follow> lambdaQueryWrapper = new LambdaQueryWrapper<>();
            lambdaQueryWrapper.eq(Follow::getFollowUserId, user.getId());
            List<Follow> list = followService.list(lambdaQueryWrapper);
            //4.推送笔记id给粉丝
            for (Follow follow : list) {
                //4.1 获取粉丝id
                Long userId = follow.getUserId();
                //4.2 推送
                ops.add(RedisConstants.FEED_KEY + userId, blog.getId().toString(), System.currentTimeMillis());
            }
        }
        // 5.返回笔记id
        return Result.ok(blog.getId());
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

用户A发布了一篇笔记

则用户B的收件箱会收到博客id

实现粉丝关注页面的分页查询功能（滚动分页）

滚动分页原理分析
上面使用推模式将笔记id推送到了粉丝的收件箱，这一节我们将会根据笔记id查出笔记，并且会根据时间排序。

在这一节中会使用到ZSet的很多命令，我们先模拟一些数据，来测试一下滚动分页和普通分页的区别
数据：

操作：
先测试按照角标查询
倒序查询，并且结果带上分数

添加一条数据，再查询3条数据
此时我们使用zrevrange查询倒数3至5条数据(从0开始的），按照我们的想法，预期结果应该是3，2，1。但是结果却是4，3，2。这样导致数据4又被查询了一遍。
可能有人会说，再查一边就再查一边呗，没影响。
影响可大了，因为在实际使用中，推文或者博客的发布速度很快，可能短时间内就会发布很多条，那么作为粉丝/用户，就可能存在永远都刷不到3，2，1这三条数据。

按照分数查询
按照角标查询会出现重复查询的问题，所以我们需要使用按照分数查询，Zset提供了这样的命令

这条命令的含义是从分数最大值1000开始查询，一直到0，limit后面的0是指偏移量，3为个数限制。
因为前面插入了一条数据，所以结果是7，6，5

这里再插入一条数据，查询时，max参数使用上次查询结果的最后一条数据的分数，min参数还是0，limit的offset参数切换为1，因为5是上次查询的结果，不需要再次查询了，所以偏移量设置为1，限制个数还是3。
查询结果为4，3，2
这里可以看到，使用分数分页查询，就不会出现重复查询的情况了

但是这样还是会出现一个情况，就是当数据的分数相同时，limit的参数offset会发生改变，会变成相同分数的个数，具体情况看视频的第10分钟后的内容redis Zset实现滚动查询

根据上面的情况总结出来命令的各个参数应该填什么：

下面我们将会实现这个接口

本次查询推送的最小时间戳会作为下次查询的lastId。
我们需要封装一个类来存放返回值。

package com.hmdp.dto;

import lombok.Data;

import java.util.List;

@Data
public class ScrollResult {
    private List<?> list;
    private Long minTime;
    private Integer offset;
}
1
2
3
4
5
6
7
8
9
10
11
12

BlogController接口

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

写在BlogService中的滚动分页方法

/**
     * 查询用户的关注者发布的笔记
     *
     * @param max    上次查询结果的分数的最小值
     * @param offset 偏移量
     * @return
     */
    @Override
    public Result queryBlogOfFollow(Long max, Integer offset) {
        //1.获取当前用户
        UserDTO user = UserHolder.getUser();
        //2.查询收件箱
        ZSetOperations<String, String> szo = stringRedisTemplate.opsForZSet();
        Set<ZSetOperations.TypedTuple<String>> typedTuples = szo.reverseRangeByScoreWithScores(RedisConstants.FEED_KEY + user.getId(), 0, max, offset, 2);
        //3.非空判断
        if (typedTuples == null || typedTuples.isEmpty()) {
            return Result.ok();
        }
        //4.解析数据：blogId,score(时间戳),offset（需要我们从查出来的数据进行计算，得到偏移量）
        ArrayList<Long> blogIds = new ArrayList<>();
        long min = 0L;
        int returnOffset = 1;
        for (ZSetOperations.TypedTuple<String> typedTuple : typedTuples) {
            //获取blogId
            Long id = Long.valueOf(Objects.requireNonNull(typedTuple.getValue()));
            blogIds.add(id);
            //获取时间戳，计算偏移量
            Long score = Objects.requireNonNull(typedTuple.getScore()).longValue();
            if (score == min) {
                returnOffset++;
            } else {
                min = score;
                returnOffset = 1;
            }
        }
        //5.查询博客
        String idStr = StrUtil.join(",", blogIds);
        List<Blog> blogs = query().in("id", blogIds).last("ORDER BY FIELD(id," + idStr + ")").list();
        for (Blog blog : blogs) {
            //查询出博客的用户信息
            queryBlogUser(blog);
            //查询出当前用户对博客的点赞情况
            isBlogLiked(blog);
        }
        //6.封装结果
        ScrollResult scrollResult = new ScrollResult();
        scrollResult.setList(blogs);
        scrollResult.setOffset(returnOffset);
        scrollResult.setMinTime(min);
        return Result.ok(scrollResult);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51

六、附近商户

GEO数据结构

练习：

1.添加上面的北京火车站地理信息

在redis中数据以Zset的形式存储

2.计算北京西站到北京站的距离
默认距离单位是 米

3.搜索天安门（116.397904 39.909005）附近10km内的所有火车站，并按照距离升序
我安装的redis是6.2版本之前的，所以只能使用georadius命令

附近商户搜索

数据库中的shop表存储了店铺的信息，将店铺的id和坐标存入geo数据结构，然后从redis中获取店铺的id（按照离当前用户的坐标的距离远近排序），然后根据店铺id从数据库中查询店铺的信息。

但是在使用时，我们查询店铺的信息都是按照店铺类型进行查询的，比如查询美食类，查询ktv类，所以在将店铺信息向redis中存储时还需要根据店铺类型进行分组。

编写一个单元测试，将数据库中的店铺id和地理信息存入redis

    /**
     * 将店铺的地理信息存入redis
     */
    @Test
    void loadShopData(){
        GeoOperations<String, String> geoOps = stringRedisTemplate.opsForGeo();
        //1.查询店铺信息
        List<Shop> list = shopServiceImpl.list();
        //2.把店铺分组，按照typeId分组，typeId一致的分到一个geo集合中
        //TODO 这是Stream流的写法，非常优雅，可以花时间学习一下 通过店铺类型id分类 生成一个map集合
        Map<Long, List<Shop>> collect = list.stream().collect(Collectors.groupingBy(Shop::getTypeId));
        //3.分批完成，写入redis
        Set<Map.Entry<Long, List<Shop>>> entrySet = collect.entrySet();
        for (Map.Entry<Long, List<Shop>> longListEntry : entrySet) {
            Long key = longListEntry.getKey();
            List<Shop> value = longListEntry.getValue();
            //这样的话，每个店铺都要向redis发起一次请求
//            for (Shop shop : value) {
//                Long id = shop.getId();
//                Double x = shop.getX();
//                Double y = shop.getY();
//                geoOps.add(RedisConstants.SHOP_GEO_KEY+key,new Point(x,y),id.toString());
//            }
            //批量插入
            List<RedisGeoCommands.GeoLocation<String>> locations = new ArrayList<>();
            for (Shop shop : value) {
                Long id = shop.getId();
                Double x = shop.getX();
                Double y = shop.getY();
                locations.add(new RedisGeoCommands.GeoLocation<String>(id.toString(),new Point(x,y)));
            }
            geoOps.add(RedisConstants.SHOP_GEO_KEY+key,locations);
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

结果显示存入了两个店铺分类1和2

编写接口和业务代码

    /**
     * 根据商铺类型分页查询商铺信息
     * @param typeId 商铺类型
     * @param current 页码
     * @return 商铺列表
     */
    @GetMapping("/of/type")
    public Result queryShopByType(
            @RequestParam("typeId") Integer typeId,
            @RequestParam(value = "current", defaultValue = "1") Integer current,
            @RequestParam(value = "x",required = false) Double x,
            @RequestParam(value = "y",required = false) Double y
    ) {
        return shopService.queryShopByTypeId(typeId,current,x,y);
//        // 根据类型分页查询
//        Page<Shop> page = shopService.query()
//                .eq("type_id", typeId)
//                .page(new Page<>(current, SystemConstants.DEFAULT_PAGE_SIZE));
//        // 返回数据
//        return Result.ok(page.getRecords());
    }

   /**
     * 根据店铺的TypeId查询店铺信息
     *
     * @param typeId  店铺类型id
     * @param current 当前要获取数据的页码
     * @param x       当前用户的经度
     * @param y       当前用户的纬度
     * @return
     */
    @Override
    public Result queryShopByTypeId(Integer typeId, Integer current, Double x, Double y) {
        //1.判断是否需要根据坐标查询
        if (x == null || y == null) {
            // 根据类型分页查询
            Page<Shop> page = shopService.query()
                    .eq("type_id", typeId)
                    .page(new Page<>(current, SystemConstants.DEFAULT_PAGE_SIZE));
            // 返回数据
            return Result.ok(page.getRecords());
        }
        //2.计算分页参数
        //这个是分页参数的计算公式
        int from = (current - 1) * SystemConstants.DEFAULT_PAGE_SIZE;
        int end = current * SystemConstants.DEFAULT_PAGE_SIZE;
        //3.查询redis，按照距离排序，分页 结果：shopId，distance
        RedisGeoCommands.GeoRadiusCommandArgs args = RedisGeoCommands.GeoRadiusCommandArgs
                .newGeoRadiusArgs()//创建一个新的GeoRadiusCommandArgs对象
                .includeDistance()//查询结果包含与中心点的距离
                .limit(end);//查询从0开始到end结束的数据，所以分页还需要我们手动做逻辑分页
        GeoResults<RedisGeoCommands.GeoLocation<String>> results = stringRedisTemplate.opsForGeo().radius(
                RedisConstants.SHOP_GEO_KEY + typeId,
                new Circle(new Point(x, y), 5000),
                args
        );
        //非空判断
        if(results == null){
            return Result.ok(Collections.emptyList());
        }
        List<GeoResult<RedisGeoCommands.GeoLocation<String>>> list = results.getContent();
        //如果查询出来的数据不足from个，则返回空,因为后续操作会使用strem流的skip对数据进行跳过，如果跳过了超出数据个数的次数，在stream流中的操作将会引发空指针
        if(list.size() <= from){
            return Result.ok(Collections.emptyList());
        }
        //4.解析出商户id
        //这里使用stream跳过from条数据是在做逻辑分页
        List<Long> ids = new ArrayList<>();//存储店铺id
        Map<Long,Distance> map = new HashMap<>();//存储店铺和店铺距离中心点的距离
        list.stream().skip(from).forEach(result ->{
            String id = result.getContent().getName();//获取店铺id
            Distance distance = result.getDistance();//获取店铺距离中心点的距离
            ids.add(Long.valueOf(id));
            map.put(Long.valueOf(id),distance);
        });
        //5.根据商户id查询数据库 这里要根据ids中的id顺序查询数据库
        String idStr = StrUtil.join(",",ids);
        List<Shop> shops=query().in("id",ids).last("ORDER BY FIELD(id,"+idStr+")").list();

        for (Shop shop : shops) {
            Long id = shop.getId();
            shop.setDistance(map.get(id).getValue());
        }
        //6.返回结果
        return Result.ok(shops);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86

七、用户签到

bitmap签到用法

bitmap数据结构

练习：

使用bitset向ket为b的bitmap中添加数据，第0、1、2、4位设置为了1，第3位默认为0.

使用bitget查看，第0、1、2、4位都是1，第3位是0

使用bitfield查看多位


bitfield命令后面的参数很多，我们只想要他的查看功能
b是数据的key，get是查看，u是结果以无符号数字展示（对应的有i，有符号数字），u后面跟着的3是指查看几位，0是offset是指从第几位查起。
结果是7，我们前面插入的数据是11101，从0位开始查看3个，即111，转为十进制数就是7

签到功能实现

    @PostMapping("/sign")
    public Result sign(){
      return userService.sign();
    }

/**
     * 用户签到
     * @return
     */
    @Override
    public Result sign() {
        //1.获取当前登录用户
        UserDTO user = UserHolder.getUser();
        //2.获取当前日期
        LocalDateTime now = LocalDateTime.now();
        //获取年月
        String format = now.format(DateTimeFormatter.ofPattern("yyyy/MM"));
        //3.获取当前是该月第几天
        int dayOfMonth = now.getDayOfMonth();
        //4.拼接key前缀
        String key = USER_SIGN_KEY+user.getId()+format;
        //5.写入redis
        stringRedisTemplate.opsForValue().setBit(key,dayOfMonth-1,true);//月份中的天数是从1开始，而bitmap的第一位是0
        //6.返回结果
        return Result.ok();
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

统计连续签到天数

问题2中的0是偏移量，dayOfMonth是今天是当前月的第几天，是指从0开始取多少个bit位。
重点：问题3，使用位运算

    /**
     * 统计当前用户本月截至今天连续签到天数
     * @return
     */
    @GetMapping("/sign/count")
    public Result signCount(){
        return userService.signCount();
    }

/**
     * 统计本月截至今天，连续签到天数
     *
     * @return
     */
    @Override
    public Result signCount() {
        //1.获取当前用户
        UserDTO user = UserHolder.getUser();
        //2.获取当前年月
        LocalDateTime now = LocalDateTime.now();
        String format = now.format(DateTimeFormatter.ofPattern("yyyy/MM"));
        //3.获取当前是本月第几天
        int dayOfMonth = now.getDayOfMonth();
        //4.获取bitmap中从0开始当今天代表的bit序列（得到一个十进制数
        String key = USER_SIGN_KEY + user.getId() + format;
        List<Long> list = stringRedisTemplate.opsForValue().bitField(
                key,
                BitFieldSubCommands.create().get(BitFieldSubCommands.BitFieldType.unsigned(dayOfMonth)).valueAt(0)
        );//为什么会得到一个list呢，因为bitField命令里面还有很多子命令，可能会用到多个子命令，会有多个结果，所以结果是一个list，
        if (list == null || list.size() == 0) {//返回结果为空，直接返回一个0，代表连续签到天数为0
            return Result.ok(0);
        }
        Long result = list.get(0);
        if(result==null){
            return Result.ok(0);
        }
        //5.遍历循环，统计本月截至今天，连续签到天数
        int count = 0;
        while(true){
            Long x = result & 1;
            if(x == 0){//如果当前bit序列最后一位是0，说明断签，退出循环
                break;
            }else {
                count++;//如果不为0，则count++ 连续签到天数加1
                result >>= 1;//bit序列右移一位，抛弃最后一个bit位，继续判读下一个bit位
            }
        }
        //6.返回结果
        return Result.ok(count);
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50