定时使命删除MongoDB汗青数据

媒介

MongoDB数据过多，导致存储资源飙升，为了低落资源，须要将汗青数据删除。
删除逻辑

添加设置文件控制删除逻辑

2. syncconfig:
3.   deleteMongoConfig:
4.     #同步状态，true同步，false不同步
5.     syncStatus: true
6.     #删除数据的时间，一个月前
7.     deleteDays: 31
8.     #分布式锁key
9.     lockRedisKey: order.sync.deleteMongo
10.     #每次删除数量
11.     limit: 2

复制代码

设置类

2. @ConfigurationProperties(prefix = "syncconfig")
3. @Configuration
4. @RefreshScope
5. @Data
6. public class SyncConfig {
7.     private DeleteMongoDto deleteMongoConfig;
9.     @Data
10.     @NoArgsConstructor
11.     @AllArgsConstructor
12.     public static class DeleteMongoDto {
13.         /**
14.          * 同步状态，true同步，false不同步
15.          */
16.         Boolean syncStatus = false;
17.         /**
18.          * 删除的天数（createTime）
19.          */
20.         Integer deleteDays = 186;
21.         /**
22.          * locakRedisKey，用于做分布式锁，防止定时任务执行时间较长，两个任务重叠执行
23.          */
24.         String lockRedisKey;
25.         /**
26.          * 每次数量
27.          */
28.         Integer limit = 1000;
29.     }
30. }

复制代码

焦点代码

2.     @PostMapping("/deleteMongo")
3.     public BaseResponse<String> deleteMongo() {
4.         return orderService.deleteMongo();
5.     }

复制代码

2. @Override
3.     public BaseResponse<String> deleteMongo() {
4.         //获取配置信息
5.         SyncConfig.DeleteMongoDto deleteMongoDto = syncConfig.getDeleteMongoConfig();
6.         //判断同步是否开启
7.         if (deleteMongoDto == null || !deleteMongoDto.getSyncStatus()) {
8.             log.info("deleteMongosyncStatus=false,not sync");
9.             return ResponseUtils.success("deleteMongosyncStatus=false,not sync");
10.         }
11.         Boolean lockStatus = false;
12.         try {
13.             lockStatus = redisLockService.acquireLock(deleteMongoDto.getLockRedisKey());
14.             if (!lockStatus) {
15.                 log.info("deleteMongo get lock fail,not sync");
16.                 return ResponseUtils.fail("deleteMongo get lock fail,not sync");
17.             }
18.             //根据时间获取orderId
19.             Long orderId = getOrderId(deleteMongoDto.getDeleteDays());
20.             Query query = new Query(Criteria.where("orderId").lt(orderId));
21.             query.limit(deleteMongoDto.getLimit());
22.             // 使用投影来只选择orderId字段
23.             query.fields().include("orderId");
24.             // 这里不用分页是因为分页会查询total效率较低，数据量大的时候耗费资源
25.             /*Pageable pageable = PageRequest.of(0, deleteMongoDto.getLimit());
26.             Page<orderDao> page = orderDao.findByOrderIdLessThan(orderId, pageable);
27.             List<Order> list = page.getContent();*/
28.             List<Order> list=mongoTemplate.find(query,Order.class);
29.             for (Orderitem :
30.                     list) {
31.                 orderDao.deleteById(item.getOrderId());
32.             }
33.             int count = 0;
34.             if (CollectionUtils.isNotEmpty(list)) {
35.                 count = list.size();
36.             }
37.             return ResponseUtils.success("deleteMongo success,count:" + count);
38.         } catch (Exception ex) {
39.             log.error("deleteMongo Exception：" + ex.getMessage());
40.             return ResponseUtils.fail(ex.getMessage());
41.         } finally {
42.             //释放分布式锁
43.             if (lockStatus) {
44.                 redisLockService.releaseLock(deleteMongoDto.getLockRedisKey());
45.             }
46.         }
47.     }
48.     //生成半年前的orderId
49.     private Long getOrderId(Integer deleteDays) {
50.         LocalDateTime deleteTime = LocalDateTime.now().minusDays(deleteDays);
51.         // 将LocalDateTime转换为毫秒值
52.         ZonedDateTime utcZonedDateTime = deleteTime.atZone(ZoneId.systemDefault());
53.         long milliseconds = utcZonedDateTime.toInstant().toEpochMilli();
54.         Long orderId = (milliseconds / 1000) << 32;
55.         return orderId;
56.     }

复制代码

总结

这里是简朴的删除汗青数据逻辑，可以参考实行，分布式锁是为了防止重复调用，现实利用的时间也可以不消分布式锁。然后定时调用这个删除接口即可不停的删除汗青数据了