问题：为什么要分组？如何实现？

​ –解答：分组可以使用户更好的管理自己的短链接

问题：gid是全局唯一的吗？如何保证？

​ –解答：gid是全局唯一的。设计方案为：首先使用Hutool的工具生成一个长度为6的随机字符串，然后会去数据库中查询是否已经存在该gid，如果存在则重新生成gid，这个过程会一直循环，直至生成的gid唯一。

问题：分组分表时以什么作为分片件？

​ –解答：我选择的是username，这样可以保证同一个用户创建的分组在同一个表中。

实现代码：有很多地方写的不是很优雅，有时间再改进

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
87
88
89
90
91
92
93
94
95
96
97
98
99
/**
 * 分组服务实现层
 */
@Service
public class GroupServiceImpl extends ServiceImpl<GroupMapper, GroupDO>implements GroupService {
    @Resource
    private GroupMapper groupMapper;
    /**
     * 新增分组
     */
    public Result createGroup(GroupReqDTO group){
        GroupDO groupDO = new GroupDO();
        String gid;
        while(true){
            //防止gid重复
            gid = RandomUtil.randomString(6);
            if(!getGroup(gid)){
                break;
            }
        }
        groupDO.setGid(gid);
        groupDO.setName(group.getName());
        groupDO.setSortOrder(0);
        groupDO.setUsername(UserContext.get().getUsername());

        save(groupDO);
        return Results.success();
    }

    /**
     * 删除分组
     */
    public Result deleteGroupByGid(String gid){
        LambdaQueryWrapper<GroupDO> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(GroupDO::getGid,gid);
        int delete = groupMapper.delete(queryWrapper);
        if(delete > 1){
            return Results.failure();
        }

        return Results.success(true);
    }

    /**
     * 修改分组
     */
    public Result updateGroup(String name,String gid){
        LambdaUpdateWrapper<GroupDO> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(GroupDO::getGid,gid).set(GroupDO::getName,name);
        boolean isSuccess = update(updateWrapper);
        if(!isSuccess){
            return Results.failure();
        }
        LambdaQueryWrapper<GroupDO> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(GroupDO::getGid,gid);
        GroupDO groupDO = groupMapper.selectOne(queryWrapper);
        GroupRespDTO groupRespDTO = BeanUtil.copyProperties(groupDO, GroupRespDTO.class);

        return Results.success(groupRespDTO);
    }
    /**
     * 分组排序
     */
    public Result sortGroup(List<GroupSortReqDTO>groups){
        String username = "";
        for(GroupSortReqDTO group : groups){
            username = group.getUsername();
            String gid = group.getGid();
            Integer sortOrder = group.getSortOrder();

            LambdaUpdateWrapper<GroupDO> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(GroupDO::getGid,gid).set(GroupDO::getSortOrder,sortOrder);
            update(updateWrapper);
        }

        LambdaQueryWrapper<GroupDO> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(GroupDO::getUsername,username).orderByDesc(GroupDO::getSortOrder);
        List<GroupDO> groupDOS = groupMapper.selectList(queryWrapper);

        List<GroupRespDTO>res = new ArrayList<>();
        for(GroupDO g : groupDOS){
            res.add(BeanUtil.copyProperties(g, GroupRespDTO.class));
        }

        return Results.success(res);
    }
    /**
     * 判读数据库中是否有该分组
     * @param gid
     * @return
     */
    public boolean getGroup(String gid){
        LambdaQueryWrapper<GroupDO> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(GroupDO::getGid,gid);
        GroupDO groupDO = getOne(queryWrapper);
        if(groupDO == null)return false;
        return true;
    }
}