SpringBoot+Redis實現(xiàn)外呼頻次限制功能的項目實踐

更新時間：2025年07月07日 09:03:11 作者：sean_it

本文提出基于SpringBoot和Redis的外呼頻次限制解決方案,采用Redis計數(shù)器與滑動窗口算法實現(xiàn)精準(zhǔn)控制,具有一定的參考價值,感興趣的可以了解一下

方案設(shè)計

核心思路

使用Redis的計數(shù)器+過期時間機制
采用滑動窗口算法實現(xiàn)精確控制
通過Lua腳本保證原子性操作

實現(xiàn)步驟

1. 添加依賴

<!-- pom.xml -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
    <version>3.12.0</version>
</dependency>

2. 配置Redis

# application.yml
spring:
  redis:
    host: localhost
    port: 6379
    password: 
    database: 0

3. 實現(xiàn)頻次限制服務(wù)

@Service
public class CallFrequencyService {
    
    private final StringRedisTemplate redisTemplate;
    
    private static final String CALL_COUNT_PREFIX = "call:count:";
    private static final String CALL_TIMESTAMP_PREFIX = "call:timestamp:";
    
    @Autowired
    public CallFrequencyService(StringRedisTemplate redisTemplate) {
        this.redisTemplate = redisTemplate;
    }
    
    /**
     * 檢查并增加呼叫計數(shù)
     * @param callerNumber 主叫號碼
     * @param limit 限制次數(shù)
     * @param period 限制周期(秒)
     * @return 是否允許呼叫
     */
    public boolean checkAndIncrement(String callerNumber, int limit, long period) {
        String countKey = CALL_COUNT_PREFIX + callerNumber;
        String timestampKey = CALL_TIMESTAMP_PREFIX + callerNumber;
        
        // 使用Lua腳本保證原子性
        String luaScript = """
            local count = redis.call('get', KEYS[1])
            local timestamp = redis.call('get', KEYS[2])
            local now = tonumber(ARGV[3])
            
            if count and timestamp then
                if now - tonumber(timestamp) < tonumber(ARGV[2]) then
                    if tonumber(count) >= tonumber(ARGV[1]) then
                        return 0
                    else
                        redis.call('incr', KEYS[1])
                        return 1
                    end
                else
                    redis.call('set', KEYS[1], 1)
                    redis.call('set', KEYS[2], ARGV[3])
                    redis.call('expire', KEYS[1], ARGV[2])
                    redis.call('expire', KEYS[2], ARGV[2])
                    return 1
                end
            else
                redis.call('set', KEYS[1], 1)
                redis.call('set', KEYS[2], ARGV[3])
                redis.call('expire', KEYS[1], ARGV[2])
                redis.call('expire', KEYS[2], ARGV[2])
                return 1
            end
            """;
        
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(luaScript);
        redisScript.setResultType(Long.class);
        
        Long result = redisTemplate.execute(redisScript, 
            Arrays.asList(countKey, timestampKey),
            String.valueOf(limit), 
            String.valueOf(period),
            String.valueOf(System.currentTimeMillis() / 1000));
        
        return result != null && result == 1;
    }
    
    /**
     * 獲取剩余可呼叫次數(shù)
     * @param callerNumber 主叫號碼
     * @param limit 限制次數(shù)
     * @return 剩余次數(shù)
     */
    public int getRemainingCount(String callerNumber, int limit) {
        String countKey = CALL_COUNT_PREFIX + callerNumber;
        String countStr = redisTemplate.opsForValue().get(countKey);
        
        if (StringUtils.isBlank(countStr)) {
            return limit;
        }
        
        int used = Integer.parseInt(countStr);
        return Math.max(0, limit - used);
    }
}

4. 實現(xiàn)REST接口

@RestController
@RequestMapping("/api/call")
public class CallController {
    
    private static final int DEFAULT_LIMIT = 1000;
    private static final long DEFAULT_PERIOD = 3 * 24 * 60 * 60; // 3天(秒)
    
    @Autowired
    private CallFrequencyService callFrequencyService;
    
    @PostMapping("/check")
    public ResponseEntity<?> checkCallPermission(@RequestParam String callerNumber) {
        boolean allowed = callFrequencyService.checkAndIncrement(
            callerNumber, DEFAULT_LIMIT, DEFAULT_PERIOD);
        
        if (allowed) {
            return ResponseEntity.ok().body(Map.of(
                "allowed", true,
                "remaining", callFrequencyService.getRemainingCount(callerNumber, DEFAULT_LIMIT)
            ));
        } else {
            return ResponseEntity.status(HttpStatus.TOO_MANY_REQUESTS).body(Map.of(
                "allowed", false,
                "message", "呼叫次數(shù)超過限制"
            ));
        }
    }
    
    @GetMapping("/remaining")
    public ResponseEntity<?> getRemainingCount(@RequestParam String callerNumber) {
        int remaining = callFrequencyService.getRemainingCount(callerNumber, DEFAULT_LIMIT);
        return ResponseEntity.ok().body(Map.of(
            "remaining", remaining,
            "limit", DEFAULT_LIMIT
        ));
    }
}

5. 添加定時任務(wù)重置計數(shù)器（可選）

@Scheduled(cron = "0 0 0 * * ?") // 每天凌晨執(zhí)行
public void resetExpiredCounters() {
    // 可以定期清理過期的key，避免Redis積累太多無用key
    // 實際應(yīng)用中，依賴expire通常已經(jīng)足夠
}

方案優(yōu)化點

分布式鎖：如果需要更精確的控制，可以在Lua腳本中加入分布式鎖
多維度限制：可以擴展為基于號碼+時間段的多維度限制
熔斷機制：當(dāng)達到限制閾值時，可以暫時熔斷該號碼的呼叫能力
動態(tài)配置：將限制參數(shù)配置在數(shù)據(jù)庫或配置中心，實現(xiàn)動態(tài)調(diào)整

測試用例

@SpringBootTest
public class CallFrequencyServiceTest {
    
    @Autowired
    private CallFrequencyService callFrequencyService;
    
    @Test
    public void testCallFrequencyLimit() {
        String testNumber = "13800138000";
        int limit = 5;
        long period = 60; // 60秒
        
        // 前5次應(yīng)該成功
        for (int i = 0; i < limit; i++) {
            assertTrue(callFrequencyService.checkAndIncrement(testNumber, limit, period));
        }
        
        // 第6次應(yīng)該失敗
        assertFalse(callFrequencyService.checkAndIncrement(testNumber, limit, period));
        
        // 等待周期結(jié)束
        try {
            Thread.sleep(period * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        
        // 新周期應(yīng)該重新計數(shù)
        assertTrue(callFrequencyService.checkAndIncrement(testNumber, limit, period));
    }
}

這個方案能夠高效、準(zhǔn)確地實現(xiàn)外呼頻次限制功能，通過Redis的高性能和原子性操作保證系統(tǒng)的可靠性，適合在生產(chǎn)環(huán)境中使用。