删除规则接口 - @PostMapping("/deleteOneRegularByID")

@EnableAsync
@RestController
public class RegularController {

    // ...

    @PostMapping("/deleteOneRegularByID")
    public Result<Object> deleteOneRegularByID(@RequestBody Map<String, Object> params, HttpServletRequest request) {

        //权限验证
        String token = (String) request.getAttribute("claims_admin");
        if (token == null || "".equals(token)) {
            throw new RuntimeException("权限不足！");
        }

        log.info("deleteOneRegularByID请求报文：" + params);

        //前端传递参数
        Long regularId;
        if (params.get("regularId") != null) {
            regularId = Long.valueOf(params.get("regularId").toString());
        } else {
            log.error("regularId为null");
            return new Result<>(ResultCode.FAIL);
        }

        //前端传递参数
        String phone = (String) params.get("phone");
        if (StringUtils.isEmpty(phone)) {
            log.error("phone为空！");
            return new Result<>(ResultCode.FAIL);
        }
        String userCode = (String) params.get("code");
        if (StringUtils.isEmpty(userCode)) {
            log.error("userCode为空！");
            return new Result<>(ResultCode.FAIL);
        }

        String regularDelete_uuid = redisTemplate.opsForValue().get("regularDelete_uuid" + phone);
        String myCode = redisTemplate.opsForValue().get("regularDelete_" + regularDelete_uuid + phone);
        log.info("myCode：" + myCode);

        if (StringUtils.isEmpty(myCode)) {
            log.error("myCode为空！");
            return new Result<>(ResultCode.FAIL);
        }

        if (!userCode.equals(myCode)) {
            log.error("验证码错误！");
            return new Result<>(ResultCode.CODE_FALSE);
        }
        
        Regular regular = regularService.queryOneRegularByID(regularId);
        List<DeviceEntity> deviceEntities = deviceEntityService.queryDevicesByRegularId(regular.getRegularId());
        if (!deviceEntities.isEmpty()) {
            log.error("此规则已绑定设备，不能删除！");
            return new Result<>(ResultCode.REGULAR_DELETE);
        }

        //调用方法
        int ret = regularService.deleteOneRegularByID(regularId);
        //操作成功
        if (ret < 0) {
            log.error("删除规则失败！");
            return new Result<>(ResultCode.FAIL);
        }
        log.info("删除规则成功！");

        // 异步执行删除具体规则的逻辑
        deleteSpecificRegularsAsync(regularId);

        return new Result<>(ResultCode.SUCCESS);
    }

    @Async
    public void deleteSpecificRegularsAsync(Long regularId) {
        List<SpecificRegular> specificRegulars = specificRegularService.querySpecificRegularsByRegularId(regularId);

        if (!CollectionUtils.isEmpty(specificRegulars)) {
            List<SpecificRegular> specificRegularList = specificRegulars.stream()
                    .map(specificRegular -> {
                        specificRegular.setEnableState(0);
                        return specificRegular;
                    })
                    .collect(Collectors.toList());
            boolean batch = specificRegularService.updateBatchById(specificRegularList);
            if (!batch) {
                log.error("具体规则删除失败！");
                return;
            }
            log.info("具体规则删除成功！");
            springToGameService.reloadDeleteRegularWithSpecificRegular(regular, specificRegularList);
        }
    }
}

使用@Async注解的方法将会在调用时立即返回，并在后台线程中执行。这样可以实现异步执行删除具体规则的逻辑，而不会阻塞主线程的执行。