
Hello,我是小兔大白糖。 这篇整理面试口述与高频追问要点,方便对照站内同主题通识文。
TL;DR:黑白名单与频控限流是风控系统的"第一道闸门"——黑名单(Blacklist)是终身禁入令,白名单(Whitelist)是 VIP 免检通道,灰名单(Graylist)是观察期缓刑,而频控限流(Rate Limiting)则是防止暴力冲撞的"减速带"。四者协同构成了从"快速拒绝"到"精细限流"的多层防御体系,核心挑战在于如何在毫秒级延迟内完成分级判定,同时保证分布式环境下的计数原子性和策略一致性。
1. 概念定义(是什么)
1.1 黑白灰名单的三色模型
风控中的名单体系不是非黑即白的二元对立,而是一个三色光谱:
| 名单类型 | 英文 | 决策特征 | 有效期 | 典型场景 |
|---|---|---|---|---|
| 白名单 | Whitelist | 直接放行,跳过风控校验 | 长期/永久 | 内部员工、KYC 认证通过的高信用用户、已知合规机构 |
| 灰名单 | Graylist | 增强观察,提高 scrutiny 级别 | 短期(分钟~天) | 新注册设备、异常登录后恢复、可疑但证据不足的用户 |
| 黑名单 | Blacklist | 直接阻断/强挑战 | 可配置(小时~永久) | 已知欺诈地址、制裁名单(OFAC/UN)、被盗账户、恶意 IP |
关键区分:
- 黑名单 ≠ 简单拒绝:在支付/交易场景中,直接拒绝可能打草惊蛇(fraudster 会立即切换身份)。因此黑名单往往触发"静默拒绝"(shadow ban)——返回成功但后端拒绝执行,或要求额外的 KYC/人脸验证。
- 白名单 ≠ 完全信任:白名单只是"降低校验强度",而非"免除审计"。合规要求下,大额交易即便白名单用户也需要上报。
1.2 频控限流的本质
频控(Rate Control)是对时间维度上的行为密度进行限制,防止:
- 暴力破解:每秒 1000 次登录尝试
- 羊毛党扫货:毫秒级并发下单
- DDoS 层攻击:API 接口被刷爆
- 资金外逃:短时间内大额集中提现
四大经典算法对比:
| 算法 | 核心思想 | 优点 | 缺点 | 适用场景 |
|---|---|---|---|---|
| 固定窗口计数器 | 每个时间窗口内固定配额 | 实现简单 | 窗口边界突发(double the rate) | 粗粒度限制,不推荐核心链路 |
| 滑动窗口计数器 | 统计最近 N 秒内的请求数 | 精度高,无边界问题 | 内存/计算开销大(需记录每个请求) | 精准限流(如发送验证码) |
| 滑动窗口日志 | 记录每个请求时间戳,滑动过滤 | 最精确 | 存储成本高 | 低 QPS 高价值接口 |
| 令牌桶(Token Bucket) | 以固定速率产生令牌,请求需消耗令牌 | 允许突发,平滑输出 | 瞬时突发可能超限额 | API 网关、带宽控制 |
| 漏桶(Leaky Bucket) | 请求入桶,以固定速率漏出 | 绝对平滑,无突发 | 无法应对合法突发 | 流量整形(traffic shaping) |
1.3 类比理解
类比:机场安检体系
- 白名单 = 机组人员/机场员工专用通道(Known Crew Member,免检快速通过)
- 灰名单 = SSSS 标记旅客(Secondary Security Screening Selection,需要脱鞋、开包、全身扫描,额外审查但不拒绝登机)
- 黑名单 = 禁飞名单(No-Fly List,直接拒绝登机,甚至触发执法)
- 频控限流 = 安检通道人数限制(每个通道每分钟最多过 30 人,防止拥堵和漏检——对应系统防止过载和漏判)
- 阶梯限流 = 根据机场拥挤度动态开放通道(平时 2 条,节假日 8 条,红色预警时只开 1 条并提高检查标准)
2. 核心原理与图解
2.1 多级名单决策架构
分层设计哲学:
- L1 层:纯本地内存,无网络 I/O,负责"明显 friend"和"明显 foe"的快速判定。命中率需 > 90%,否则 L2 压力爆炸。
- L2 层:Redis 集中存储,解决多节点一致性。灰名单和频控计数器在此层实现。
- L3 层:复杂规则引擎和模型评分,异步或同步执行,取决于延迟 SLA。
2.2 灰名单状态机(Graylist State Machine)
灰名单不是静态标签,而是一个有状态、有生命周期的过渡区域:
灰名单的数学表达:
灰名单得分 G(t) = α·BehaviorScore(t) + β·VelocityRisk(t) + γ·NetworkRisk(t) + δ·DeviceRisk(t)
其中:
- α + β + γ + δ = 1.0(权重和为 1)
- BehaviorScore: 用户历史行为偏离度(z-score)
- VelocityRisk: 时间密度异常(如 10 分钟内 5 次改绑手机)
- NetworkRisk: IP/ASN/代理/VPN 风险评分
- DeviceRisk: 设备指纹异常度(模拟器/云手机/改机工具)
灰名单准入阈值:G(t) ∈ [θ_gray, θ_black)
灰名单观察窗口:T_observation = f(G(t)),即得分越高观察期越长
2.3 频控算法的时序本质
2.3.1 令牌桶(Token Bucket)
令牌桶的关键参数:
- Rate (r):令牌产生速率,如 100 tokens/second。决定长期平均流量。
- Capacity (C):桶的最大容量,如 200 tokens。决定最大允许的瞬时突发(burst)。
- 关键公式:当前可用令牌数 = min(C, 上次令牌数 + r × Δt - 已消耗)
为什么令牌桶允许突发?
想象桶是满的(C=200),之前没有请求。此时突然涌入 150 个请求,全部可以通过,因为桶里有 200 个令牌。之后令牌以 r 的速度补充。这对于正常业务是有利的(如用户批量查询),但需要配合阶梯限流防止异常大突发。
2.3.2 滑动窗口 vs 固定窗口的边界问题
时间轴(每秒限流 100):
固定窗口问题:
|-- 窗口 1 (59.5s ~ 60.5s) --|-- 窗口 2 (60.5s ~ 61.5s) --|
100 请求在 60.4s 100 请求在 60.6s
=> 在 60.4s ~ 60.6s 这 0.2 秒内通过了 200 请求!
实际速率 = 1000 req/s,远超限制。
滑动窗口解决:
统计最近 1 秒内的请求数,无论何时到达,
只要 60.4s ~ 61.4s 这个滑动区间内的总数 > 100 就拒绝。
2.3.3 阶梯限流(Tiered Throttling)
阶梯限流是多维度、多层级的复合限流策略,不是单一阈值:
大型加密货币交易所 提现接口阶梯限流示例:
层级 1 - 用户级(最严格):
- 每用户每 24h 最多提现 5 次
- 每用户单笔最低 10 USDT,最高 50,000 USDT
层级 2 - 设备级:
- 每设备每 1h 最多登录 10 次
- 每设备每 5min 最多发起 3 次提现请求
层级 3 - IP 级:
- 每 IP 每 1min 最多 60 次 API 调用
- 高风险 ASN(代理/VPN 服务商)每 IP 每 1min 最多 10 次
层级 4 - 全局级(最宽松,保护系统):
- 全局提现 QPS 不超过 10,000
- 全局登录 QPS 不超过 50,000
层级 5 - 地址级(AML 专项):
- 每个目标地址每 24h 最多接收 3 笔来自不同用户的转账
- 已知混币器地址:直接黑名单
3. 语法详解与代码示例(怎么用)
3.1 多级名单服务(Multi-Level List Service)
package com.大型加密货币交易所.risk.list;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import io.lettuce.core.api.sync.RedisCommands;
import lombok.extern.slf4j.Slf4j;
import java.time.Duration;
import java.util.EnumMap;
import java.util.Map;
import java.util.Optional;
import java.util.Set;
import java.util.concurrent.TimeUnit;
/**
* 多级名单服务:全局 / 业务 / 用户三级黑白名单体系
*
* 设计要点:
* 1. L1 本地缓存(Caffeine/Guava):P99 < 1ms,应对高频查询
* 2. L2 Redis 集群:多节点一致性,支持 TTL 自动过期
* 3. 名单变更通过 Pub/Sub 广播,本地缓存失效
* 4. 支持白名单覆盖(用户白名单 > 业务黑名单 > 全局黑名单)
*/
@Slf4j
public class MultiLevelListService {
/**
* 名单类型枚举
*/
public enum ListType {
GLOBAL_BLACK, // 全局黑名单(制裁名单、已知欺诈地址)
GLOBAL_WHITE, // 全局白名单(合规机构、内部系统)
BUSINESS_BLACK, // 业务黑名单(某业务线自定义)
BUSINESS_WHITE, // 业务白名单(某业务线 VIP)
USER_BLACK, // 用户级黑名单(人工封禁)
USER_WHITE // 用户级白名单(人工加白)
}
/**
* 名单条目
*/
public record ListEntry(
String key, // 名单键:userId / ip / address / deviceId
ListType type,
String reason, // 列入原因:OFAC_HIT / FRAUD_CONFIRMED / MANUAL_REVIEW
long expireAt, // 过期时间戳(-1 表示永久)
String operator, // 操作人
Map<String, String> metadata // 扩展信息(制裁名单编号、案件号等)
) {}
/**
* 决策结果
*/
public enum Decision {
ALLOW, // 明确放行
BLOCK, // 明确阻断
CHALLENGE, // 需要增强验证
OBSERVE // 进入观察模式
}
public record ListDecision(
Decision decision,
ListType matchedList,
String reason,
ListEntry entry
) {}
// L1 本地缓存:key -> ListEntry
private final Cache<String, ListEntry> localCache;
// L2 Redis 客户端
private final RedisCommands<String, String> redis;
// 业务标识 -> Redis key 前缀映射
private static final String REDIS_KEY_PREFIX = "risk:list:";
public MultiLevelListService(RedisCommands<String, String> redis) {
this.redis = redis;
this.localCache = CacheBuilder.newBuilder()
.maximumSize(100_000)
.expireAfterWrite(Duration.ofMinutes(5))
.recordStats()
.build();
}
/**
* 核心判定方法:查询一个 key 在所有层级名单中的状态
*
* 优先级规则(从高到低):
* 1. 用户级白名单 > 一切(人工特批)
* 2. 用户级黑名单(人工封禁)
* 3. 业务级白名单
* 4. 业务级黑名单
* 5. 全局白名单
* 6. 全局黑名单
*
* @param key 待查询的键
* @param bizType 业务类型:WITHDRAW / LOGIN / TRADE / KYC
* @return 决策结果
*/
public ListDecision check(String key, String bizType) {
// 1. L1 本地缓存查询
ListEntry cached = localCache.getIfPresent(cacheKey(key, bizType));
if (cached != null && !isExpired(cached)) {
return toDecision(cached);
}
// 2. L2 Redis 查询 - 按优先级顺序
// 2.1 用户级
ListEntry userWhite = fetchFromRedis(redisKey(ListType.USER_WHITE, key));
if (userWhite != null) {
localCache.put(cacheKey(key, bizType), userWhite);
return new ListDecision(Decision.ALLOW, ListType.USER_WHITE, "User whitelisted", userWhite);
}
ListEntry userBlack = fetchFromRedis(redisKey(ListType.USER_BLACK, key));
if (userBlack != null) {
localCache.put(cacheKey(key, bizType), userBlack);
return new ListDecision(Decision.BLOCK, ListType.USER_BLACK, "User blacklisted", userBlack);
}
// 2.2 业务级(带业务线前缀)
String bizPrefix = bizType + ":";
ListEntry bizWhite = fetchFromRedis(redisKey(ListType.BUSINESS_WHITE, bizPrefix + key));
if (bizWhite != null) {
localCache.put(cacheKey(key, bizType), bizWhite);
return new ListDecision(Decision.ALLOW, ListType.BUSINESS_WHITE, "Business whitelisted", bizWhite);
}
ListEntry bizBlack = fetchFromRedis(redisKey(ListType.BUSINESS_BLACK, bizPrefix + key));
if (bizBlack != null) {
localCache.put(cacheKey(key, bizType), bizBlack);
return new ListDecision(Decision.BLOCK, ListType.BUSINESS_BLACK, "Business blacklisted", bizBlack);
}
// 2.3 全局级
ListEntry globalWhite = fetchFromRedis(redisKey(ListType.GLOBAL_WHITE, key));
if (globalWhite != null) {
localCache.put(cacheKey(key, bizType), globalWhite);
return new ListDecision(Decision.ALLOW, ListType.GLOBAL_WHITE, "Global whitelisted", globalWhite);
}
ListEntry globalBlack = fetchFromRedis(redisKey(ListType.GLOBAL_BLACK, key));
if (globalBlack != null) {
localCache.put(cacheKey(key, bizType), globalBlack);
return new ListDecision(Decision.BLOCK, ListType.GLOBAL_BLACK, "Global blacklisted", globalBlack);
}
// 3. 未命中任何名单 - 默认通过,但不缓存(避免缓存穿透)
return new ListDecision(Decision.ALLOW, null, "Not in any list", null);
}
/**
* 批量查询 - 用于一次请求涉及多个维度(userId + IP + deviceId + address)
*/
public Map<String, ListDecision> checkMulti(Map<String, String> dimensions, String bizType) {
EnumMap<ListType, Set<String>> typeToKeys = new EnumMap<>(ListType.class);
// ... 批量 Redis Pipeline 查询,减少 RTT
return null; // simplified
}
private ListEntry fetchFromRedis(String redisKey) {
Map<String, String> hash = redis.hgetall(redisKey);
if (hash == null || hash.isEmpty()) {
return null;
}
return new ListEntry(
hash.get("key"),
ListType.valueOf(hash.get("type")),
hash.get("reason"),
Long.parseLong(hash.get("expireAt")),
hash.get("operator"),
hash
);
}
private String redisKey(ListType type, String key) {
return REDIS_KEY_PREFIX + type.name().toLowerCase() + ":" + key;
}
private String cacheKey(String key, String bizType) {
return bizType + ":" + key;
}
private boolean isExpired(ListEntry entry) {
return entry.expireAt() > 0 && System.currentTimeMillis() > entry.expireAt();
}
private ListDecision toDecision(ListEntry entry) {
return switch (entry.type()) {
case GLOBAL_WHITE, BUSINESS_WHITE, USER_WHITE ->
new ListDecision(Decision.ALLOW, entry.type(), "Cached whitelist", entry);
case GLOBAL_BLACK, BUSINESS_BLACK, USER_BLACK ->
new ListDecision(Decision.BLOCK, entry.type(), "Cached blacklist", entry);
};
}
}3.2 灰名单过渡引擎(Graylist Transition Engine)
package com.大型加密货币交易所.risk.graylist;
import lombok.extern.slf4j.Slf4j;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Pipeline;
import java.time.Instant;
import java.util.Map;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 灰名单过渡引擎
*
* 核心职责:
* 1. 维护观察对象的状态机(Observation -> Gray -> Black/White)
* 2. 基于行为评分自动晋升/降级
* 3. 观察期窗口动态计算
* 4. 与 Rule Engine 和 ML Model 联动
*/
@Slf4j
public class GraylistTransitionEngine {
private final Jedis jedis;
private final RiskScoringService scoringService;
private final MultiLevelListService listService;
private final ScheduledExecutorService scheduler;
// 灰名单评分阈值
private static final double THETA_OBSERVE = 0.3; // 进入观察
private static final double THETA_GRAY = 0.6; // 进入灰名单
private static final double THETA_BLACK = 0.9; // 进入黑名单
private static final double THETA_RECOVER = 0.2; // 恢复正常
public GraylistTransitionEngine(Jedis jedis,
RiskScoringService scoringService,
MultiLevelListService listService) {
this.jedis = jedis;
this.scoringService = scoringService;
this.listService = listService;
this.scheduler = Executors.newScheduledThreadPool(4);
// 启动灰名单扫描任务:每 30 秒扫描一次即将过期的观察对象
scheduler.scheduleWithFixedDelay(this::scanAndTransition, 10, 30, TimeUnit.SECONDS);
}
/**
* 上报一次行为事件,可能触发状态迁移
*
* @param userId 用户 ID
* @param eventType 事件类型:LOGIN / WITHDRAW / TRADE / DEVICE_CHANGE
* @param features 行为特征
*/
public void onBehaviorEvent(String userId, String eventType, Map<String, Double> features) {
// 1. 计算当前综合风险评分
double score = scoringService.calculateBehaviorScore(userId, eventType, features);
// 2. 获取当前状态
GrayState currentState = getCurrentState(userId);
// 3. 状态机转换
GrayState newState = transition(currentState, score, userId);
if (newState != currentState) {
log.info("Graylist transition: userId={}, {} -> {}, score={}",
userId, currentState, newState, score);
applyTransition(userId, currentState, newState, score);
}
// 4. 无论是否迁移,都更新评分历史(用于趋势分析)
recordScoreHistory(userId, score);
}
/**
* 状态机转换逻辑
*/
private GrayState transition(GrayState current, double score, String userId) {
return switch (current) {
case NORMAL -> {
if (score >= THETA_OBSERVE) {
yield GrayState.OBSERVED;
}
yield GrayState.NORMAL;
}
case OBSERVED -> {
if (score >= THETA_BLACK) {
yield GrayState.BLACKLISTED;
} else if (score >= THETA_GRAY) {
yield GrayState.GRAYLISTED;
} else if (score < THETA_RECOVER) {
yield GrayState.NORMAL;
}
yield GrayState.OBSERVED;
}
case GRAYLISTED -> {
if (score >= THETA_BLACK) {
yield GrayState.BLACKLISTED;
} else if (score < THETA_RECOVER) {
// 需要连续多次低于阈值才真正恢复,防止震荡
if (isConsistentlyLow(userId, 3)) {
yield GrayState.WHITELISTED; // 或者 NORMAL
}
}
yield GrayState.GRAYLISTED;
}
case BLACKLISTED -> {
// 黑名单通常人工解除,极少自动恢复
if (score < THETA_RECOVER && isAppealApproved(userId)) {
yield GrayState.GRAYLISTED; // 先回灰名单观察
}
yield GrayState.BLACKLISTED;
}
case WHITELISTED -> {
if (score >= THETA_OBSERVE) {
// 白名单用户出现异常,降级到观察
yield GrayState.OBSERVED;
}
yield GrayState.WHITELISTED;
}
};
}
/**
* 执行状态迁移的后继动作
*/
private void applyTransition(String userId, GrayState from, GrayState to, double score) {
String redisKey = "risk:gray:" + userId;
Pipeline pipe = jedis.pipelined();
// 更新状态
pipe.hset(redisKey, "state", to.name());
pipe.hset(redisKey, "lastTransition", String.valueOf(Instant.now().getEpochSecond()));
pipe.hset(redisKey, "score", String.valueOf(score));
// 设置 TTL:观察期和灰名单有过期时间
long ttl = calculateObservationWindow(to, score);
if (ttl > 0) {
pipe.expire(redisKey, ttl);
}
// 执行名单操作
switch (to) {
case BLACKLISTED -> {
// 同步写入黑名单,并触发风控告警
pipe.sadd("risk:blacklist:pending", userId);
// 发送告警消息到 Kafka/SNS
publishAlert(userId, "AUTO_BLACKLIST", "Score reached threshold: " + score);
}
case GRAYLISTED -> {
// 应用灰名单限制策略
pipe.hset(redisKey, "withdrawLimit", "0.5"); // 提现限额降至 50%
pipe.hset(redisKey, "require2FA", "true"); // 强制 2FA
pipe.hset(redisKey, "delayWithdraw", "86400"); // 提现延迟 24h
pipe.hset(redisKey, "scrutinyLevel", "HIGH"); // 提高 scrutiny
}
case NORMAL, WHITELISTED -> {
// 清理限制
pipe.del(redisKey + ":restrictions");
}
case OBSERVED -> {
pipe.hset(redisKey, "scrutinyLevel", "MEDIUM");
}
}
pipe.sync();
}
/**
* 动态计算观察窗口:分数越高,观察期越长
*/
private long calculateObservationWindow(GrayState state, double score) {
return switch (state) {
case OBSERVED -> (long) (3600 * (1 + score)); // 1~2 小时
case GRAYLISTED -> (long) (86400 * (1 + score * 2)); // 1~3 天
case BLACKLISTED -> -1; // 永久
case WHITELISTED -> 2592000; // 30 天有效期
case NORMAL -> 0;
};
}
/**
* 定时扫描:处理即将过期的灰名单用户,决定是否续期或释放
*/
private void scanAndTransition() {
// 实际实现:扫描 Redis 中即将过期的 key,或者通过 Sorted Set 按时间排序
// 这里简化示意
log.debug("Scanning graylist for transitions...");
}
private GrayState getCurrentState(String userId) {
String state = jedis.hget("risk:gray:" + userId, "state");
return state != null ? GrayState.valueOf(state) : GrayState.NORMAL;
}
private boolean isConsistentlyLow(String userId, int consecutiveTimes) {
// 检查最近 consecutiveTimes 次评分是否都低于恢复阈值
// 从 Redis 的 ZSET 中读取评分历史
return false; // simplified
}
private boolean isAppealApproved(String userId) {
// 查询申诉系统状态
return false; // simplified
}
private void recordScoreHistory(String userId, double score) {
String key = "risk:gray:history:" + userId;
long now = Instant.now().getEpochSecond();
jedis.zadd(key, now, now + ":" + score);
jedis.expire(key, 604800); // 保留 7 天
}
private void publishAlert(String userId, String type, String message) {
// 发送到 Kafka / SNS / PagerDuty
}
public enum GrayState {
NORMAL, // 正常
OBSERVED, // 观察中
GRAYLISTED, // 灰名单
BLACKLISTED, // 黑名单
WHITELISTED // 白名单
}
public interface RiskScoringService {
double calculateBehaviorScore(String userId, String eventType, Map<String, Double> features);
}
}3.3 Redis + Lua 原子频控实现
package com.大型加密货币交易所.risk.ratelimit;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.stream.Collectors;
/**
* 基于 Redis + Lua 的原子频控实现
*
* 为什么必须用 Lua?
* 1. Redis 的 GET + INCR + EXPIRE 不是原子的,并发下会超限
* 2. Lua 脚本在 Redis 单线程中执行,天然保证原子性
* 3. 减少网络 RTT(一次请求完成判断+计数+过期设置)
*/
public class RedisLuaRateLimiter {
private final JedisPool jedisPool;
// 1. 滑动窗口限流 Lua 脚本
private final String slidingWindowScript;
// 2. 令牌桶限流 Lua 脚本
private final String tokenBucketScript;
// 3. 漏桶限流 Lua 脚本
private final String leakyBucketScript;
public RedisLuaRateLimiter(JedisPool jedisPool) {
this.jedisPool = jedisPool;
this.slidingWindowScript = loadScript("sliding_window.lua");
this.tokenBucketScript = loadScript("token_bucket.lua");
this.leakyBucketScript = loadScript("leaky_bucket.lua");
}
private String loadScript(String resourceName) {
try (BufferedReader reader = new BufferedReader(
new InputStreamReader(
getClass().getResourceAsStream("/lua/" + resourceName),
StandardCharsets.UTF_8))) {
return reader.lines().collect(Collectors.joining("\n"));
} catch (Exception e) {
throw new RuntimeException("Failed to load Lua script: " + resourceName, e);
}
}
/**
* 滑动窗口限流
*
* @param key 限流 key:user:123:api:withdraw
* @param limit 窗口内最大请求数
* @param windowMs 窗口大小(毫秒)
* @return true = 允许通过,false = 被限流
*/
public boolean slidingWindowAllow(String key, int limit, long windowMs) {
try (Jedis jedis = jedisPool.getResource()) {
long now = System.currentTimeMillis();
// 清除窗口外的旧记录,添加当前请求,返回当前窗口内数量
Object result = jedis.eval(slidingWindowScript,
Collections.singletonList(key),
Collections.singletonList(String.valueOf(limit)),
Collections.singletonList(String.valueOf(windowMs)),
Collections.singletonList(String.valueOf(now))
);
// Lua 返回 1 表示允许,0 表示拒绝
return Long.valueOf(1L).equals(result);
}
}
/**
* 令牌桶限流
*
* @param key 限流 key
* @param capacity 桶容量(最大突发)
* @param rate 令牌产生速率(每秒)
* @param requested 本次请求需要的令牌数(默认为 1)
* @return true = 允许通过
*/
public boolean tokenBucketAllow(String key, int capacity, double rate, int requested) {
try (Jedis jedis = jedisPool.getResource()) {
long now = System.currentTimeMillis();
Object result = jedis.eval(tokenBucketScript,
Collections.singletonList(key),
Collections.singletonList(String.valueOf(capacity)),
Collections.singletonList(String.valueOf(rate)),
Collections.singletonList(String.valueOf(requested)),
Collections.singletonList(String.valueOf(now))
);
return Long.valueOf(1L).equals(result);
}
}
/**
* 漏桶限流(严格平滑)
*/
public boolean leakyBucketAllow(String key, int capacity, double leakRate) {
try (Jedis jedis = jedisPool.getResource()) {
long now = System.currentTimeMillis();
Object result = jedis.eval(leakyBucketScript,
Collections.singletonList(key),
Collections.singletonList(String.valueOf(capacity)),
Collections.singletonList(String.valueOf(leakRate)),
Collections.singletonList(String.valueOf(now))
);
return Long.valueOf(1L).equals(result);
}
}
}Lua 脚本:滑动窗口(sliding_window.lua)
-- KEYS[1]: 限流 key
-- ARGV[1]: limit (最大请求数)
-- ARGV[2]: window (窗口大小,毫秒)
-- ARGV[3]: now (当前时间戳,毫秒)
local key = KEYS[1]
local limit = tonumber(ARGV[1])
local window = tonumber(ARGV[2])
local now = tonumber(ARGV[3])
local windowStart = now - window
-- 1. 移除窗口外的旧记录
redis.call('ZREMRANGEBYSCORE', key, 0, windowStart)
-- 2. 获取当前窗口内的请求数
local current = redis.call('ZCARD', key)
-- 3. 判断是否超限
if current >= limit then
return 0 -- 拒绝
end
-- 4. 添加当前请求,设置 key 过期时间(窗口的 2 倍,防止边缘丢失)
redis.call('ZADD', key, now, now .. ':' .. redis.call('INCR', key .. ':seq'))
redis.call('PEXPIRE', key, window * 2)
return 1 -- 允许Lua 脚本:令牌桶(token_bucket.lua)
-- KEYS[1]: 限流 key
-- ARGV[1]: capacity (桶容量)
-- ARGV[2]: rate (每秒产生令牌数)
-- ARGV[3]: requested (本次请求令牌数)
-- ARGV[4]: now (当前时间戳,毫秒)
local key = KEYS[1]
local capacity = tonumber(ARGV[1])
local rate = tonumber(ARGV[2])
local requested = tonumber(ARGV[3])
local now = tonumber(ARGV[4])
-- 读取当前状态
local tokens = redis.call('GET', key .. ':tokens')
local lastTime = redis.call('GET', key .. ':last_time')
if tokens == false then
tokens = capacity
lastTime = now
else
tokens = tonumber(tokens)
lastTime = tonumber(lastTime)
-- 计算时间差产生的令牌
local delta = (now - lastTime) / 1000.0
local added = delta * rate
tokens = math.min(capacity, tokens + added)
end
-- 检查是否足够
if tokens < requested then
return 0 -- 拒绝
end
-- 消耗令牌,更新状态
tokens = tokens - requested
redis.call('SET', key .. ':tokens', tokens)
redis.call('SET', key .. ':last_time', now)
redis.call('PEXPIRE', key .. ':tokens', 60000)
redis.call('PEXPIRE', key .. ':last_time', 60000)
return 1 -- 允许3.4 阶梯限流组件(Tiered Rate Limiter)
package com.大型加密货币交易所.risk.ratelimit;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.FlowRuleManager;
import com.google.common.util.concurrent.RateLimiter;
import lombok.extern.slf4j.Slf4j;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* 阶梯限流组件:多级、多维度的复合限流策略
*
* 设计层级(从严格到宽松):
* 1. 用户级 (User) - 最严格,保护单个用户不被盗刷
* 2. 设备级 (Device) - 防止设备农场/模拟器
* 3. IP 级 (IP) - 防止单 IP 批量攻击
* 4. 业务级 (Business) - 保护具体业务接口
* 5. 全局级 (Global) - 保护整个系统不过载
*
* 实现混合:
* - 单机维度:Guava RateLimiter(令牌桶)
* - 分布式维度:Redis + Lua(滑动窗口/令牌桶)
* - 自适应维度:Sentinel(动态规则 + 热点参数)
*/
@Slf4j
public class TieredRateLimiter {
private final RedisLuaRateLimiter redisLimiter;
private final Map<String, RateLimiter> localLimiters = new ConcurrentHashMap<>();
// Sentinel 规则缓存
private volatile List<FlowRule> sentinelRules = new ArrayList<>();
public TieredRateLimiter(RedisLuaRateLimiter redisLimiter) {
this.redisLimiter = redisLimiter;
initSentinelRules();
}
/**
* 执行全层级限流检查
*
* @param context 限流上下文
* @return 限流结果
*/
public RateLimitResult check(RateLimitContext context) {
long start = System.nanoTime();
try {
// 层级 1: 用户级限流(最严格)
if (!checkUserLevel(context)) {
return RateLimitResult.rejected("USER_RATE_LIMIT",
"User-level rate limit exceeded", getRetryAfter(context.getUserId()));
}
// 层级 2: 设备级限流
if (context.getDeviceId() != null && !checkDeviceLevel(context)) {
return RateLimitResult.rejected("DEVICE_RATE_LIMIT",
"Device-level rate limit exceeded", getRetryAfter(context.getDeviceId()));
}
// 层级 3: IP 级限流
if (context.getIp() != null && !checkIpLevel(context)) {
return RateLimitResult.rejected("IP_RATE_LIMIT",
"IP-level rate limit exceeded", getRetryAfter(context.getIp()));
}
// 层级 4: 业务级限流
if (!checkBusinessLevel(context)) {
return RateLimitResult.rejected("BUSINESS_RATE_LIMIT",
"Business-level rate limit exceeded", 30);
}
// 层级 5: 全局级限流(Sentinel 兜底)
if (!checkGlobalLevel(context)) {
return RateLimitResult.rejected("GLOBAL_RATE_LIMIT",
"System overloaded, please retry later", 60);
}
return RateLimitResult.allowed();
} finally {
long latency = (System.nanoTime() - start) / 1_000_000;
if (latency > 10) {
log.warn("Rate limit check slow: {}ms, context={}", latency, context);
}
}
}
private boolean checkUserLevel(RateLimitContext ctx) {
String userKey = "rl:user:" + ctx.getUserId() + ":" + ctx.getAction();
return switch (ctx.getAction()) {
case "WITHDRAW" ->
// 提现:每用户每 24h 最多 5 次
redisLimiter.slidingWindowAllow(userKey, 5, 86_400_000);
case "LOGIN" ->
// 登录:每用户每 1h 最多 10 次失败尝试(成功后重置)
redisLimiter.slidingWindowAllow(userKey + ":fail", 10, 3_600_000);
case "API_CALL" ->
// API:每用户每秒 20 次(令牌桶允许突发)
redisLimiter.tokenBucketAllow(userKey, 40, 20.0, 1);
case "KYC_SUBMIT" ->
// KYC 提交:每用户每 7 天 1 次
redisLimiter.slidingWindowAllow(userKey, 1, 604_800_000);
default -> true;
};
}
private boolean checkDeviceLevel(RateLimitContext ctx) {
String deviceKey = "rl:device:" + ctx.getDeviceId();
// 设备级:每设备每小时最多注册 3 个账号
if ("REGISTER".equals(ctx.getAction())) {
return redisLimiter.slidingWindowAllow(deviceKey + ":reg", 3, 3_600_000);
}
// 设备级:每设备每 5 分钟最多 5 次提现尝试
if ("WITHDRAW".equals(ctx.getAction())) {
return redisLimiter.slidingWindowAllow(deviceKey + ":withdraw", 5, 300_000);
}
return true;
}
private boolean checkIpLevel(RateLimitContext ctx) {
String ipKey = "rl:ip:" + ctx.getIp();
// IP 基础限流:每分钟 60 次 API 调用
boolean baseAllowed = redisLimiter.tokenBucketAllow(ipKey + ":api", 120, 60.0, 1);
if (!baseAllowed) return false;
// 高风险 IP(代理/VPN):每分钟 10 次
if (ctx.isHighRiskIp()) {
return redisLimiter.tokenBucketAllow(ipKey + ":api:risk", 20, 10.0, 1);
}
return true;
}
private boolean checkBusinessLevel(RateLimitContext ctx) {
// 使用 Guava RateLimiter 作为单机业务保护
String bizKey = ctx.getBusiness() + ":" + ctx.getAction();
RateLimiter limiter = localLimiters.computeIfAbsent(bizKey, k -> {
// 根据业务线动态配置速率
double permitsPerSecond = getBusinessRate(ctx.getBusiness());
return RateLimiter.create(permitsPerSecond);
});
// 尝试获取令牌,不阻塞(0 超时)
return limiter.tryAcquire();
}
private boolean checkGlobalLevel(RateLimitContext ctx) {
// Sentinel 全局兜底:保护系统整体不被打垮
try {
com.alibaba.csp.sentinel.Entry entry = com.alibaba.csp.sentinel.SphU.entry(
"global:" + ctx.getBusiness());
entry.exit();
return true;
} catch (BlockException ex) {
log.warn("Global Sentinel block: business={}", ctx.getBusiness());
return false;
}
}
private double getBusinessRate(String business) {
return switch (business) {
case "SPOT" -> 5000.0;
case "FUTURES" -> 3000.0;
case "WITHDRAW" -> 500.0;
case "LOGIN" -> 2000.0;
default -> 1000.0;
};
}
private int getRetryAfter(String dimension) {
// 实际实现:查询 Redis 中该维度的下次可用时间
return 60;
}
private void initSentinelRules() {
List<FlowRule> rules = new ArrayList<>();
// 全局提现限流:QPS 10000
FlowRule withdrawRule = new FlowRule();
withdrawRule.setResource("global:WITHDRAW");
withdrawRule.setGrade(com.alibaba.csp.sentinel.slots.block.RuleConstant.FLOW_GRADE_QPS);
withdrawRule.setCount(10000);
withdrawRule.setLimitApp("default");
rules.add(withdrawRule);
// 全局登录限流:QPS 50000
FlowRule loginRule = new FlowRule();
loginRule.setResource("global:LOGIN");
loginRule.setGrade(com.alibaba.csp.sentinel.slots.block.RuleConstant.FLOW_GRADE_QPS);
loginRule.setCount(50000);
loginRule.setLimitApp("default");
rules.add(loginRule);
FlowRuleManager.loadRules(rules);
this.sentinelRules = rules;
}
// ========== 数据模型 ==========
public record RateLimitContext(
String userId,
String deviceId,
String ip,
String action, // WITHDRAW / LOGIN / API_CALL / REGISTER / KYC_SUBMIT
String business, // SPOT / FUTURES / MARGIN / EARN
boolean isHighRiskIp
) {}
public record RateLimitResult(
boolean allowed,
String code,
String message,
int retryAfterSeconds
) {
static RateLimitResult allowed() {
return new RateLimitResult(true, "ALLOWED", "OK", 0);
}
static RateLimitResult rejected(String code, String message, int retryAfter) {
return new RateLimitResult(false, code, message, retryAfter);
}
}
}3.5 集成 Sentinel 的热点参数限流
package com.大型加密货币交易所.risk.ratelimit;
import com.alibaba.csp.sentinel.Entry;
import com.alibaba.csp.sentinel.SphU;
import com.alibaba.csp.sentinel.slots.block.BlockException;
import com.alibaba.csp.sentinel.slots.block.RuleConstant;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowItem;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRule;
import com.alibaba.csp.sentinel.slots.block.flow.param.ParamFlowRuleManager;
import java.util.Arrays;
import java.util.Collections;
/**
* Sentinel 热点参数限流:针对特定参数值(如特定用户、特定地址)的精准限流
*
* 场景:某个用户账号被盗,攻击者疯狂发起提现请求。
* 热点参数限流可以在不影响到其他用户的情况下,
* 单独对该用户进行限流或拉黑。
*/
public class SentinelHotParamRateLimiter {
public SentinelHotParamRateLimiter() {
initHotParamRules();
}
private void initHotParamRules() {
// 规则:对 withdraw 接口的第 0 个参数(userId)进行热点限流
ParamFlowRule rule = new ParamFlowRule("withdraw_api")
.setParamIdx(0) // 第 0 个参数是 userId
.setCount(5) // 默认每个 userId 每秒 5 次
.setDurationInSec(1);
// 热点例外:特定 userId 可以有不同的阈值
ParamFlowItem hotItem1 = new ParamFlowItem()
.setObject("12345") // userId = 12345
.setCount(1); // 每秒最多 1 次(被标记为可疑的用户)
ParamFlowItem hotItem2 = new ParamFlowItem()
.setObject("VIP_999") // VIP 用户
.setCount(50); // 每秒 50 次
rule.setParamFlowItemList(Arrays.asList(hotItem1, hotItem2));
ParamFlowRuleManager.loadRules(Collections.singletonList(rule));
}
public boolean tryWithdraw(String userId, String address, long amount) {
Entry entry = null;
try {
// entryWithArgs 可以携带参数用于热点参数限流
entry = SphU.entry("withdraw_api", userId);
// 执行业务逻辑
processWithdraw(userId, address, amount);
return true;
} catch (BlockException ex) {
// 被热点参数限流拦截
logHotParamBlock(userId, ex);
return false;
} finally {
if (entry != null) {
entry.exit();
}
}
}
private void processWithdraw(String userId, String address, long amount) {
// 提现业务逻辑
}
private void logHotParamBlock(String userId, BlockException ex) {
System.out.println("Hot param blocked: userId=" + userId + ", rule=" + ex.getRule());
}
}4. 业界案例
4.1 阿里巴巴:双 11 全链路限流与热点降级
背景:双 11 期间,淘宝/天猫面临每秒数百万笔交易的峰值,且存在"热点商品"问题——某款 iPhone 可能被数百万用户同时点击,形成热点 Key,压垮单台 Redis 或数据库分片。
解决方案:
-
Sentinel 多层级限流:
- 接口级:每个 API 有全局 QPS 上限(如商品详情页 100 万 QPS)
- 应用级:每个微服务实例有线程池上限,防止雪崩
- 热点参数级:对商品 ID 维度限流,单个商品 ID 的请求被分散到多个本地缓存节点
-
热点探测与本地缓存:
- Sentinel 自动探测热点参数(如前 10 个被访问最多的商品 ID)
- 热点数据从 Redis 降级到应用本地缓存(Caffeine),减少 90% 的 Redis 访问量
- 热点数据变更时,通过 MetaQ 消息广播失效本地缓存
-
黑名单的 ZSET 实现:
- 恶意买家名单存储在 Tair(阿里自研 KV)的 ZSET 中
- 使用
ZREVRANGEBYSCORE快速查询某用户是否在黑名单中 - 黑名单有 TTL,自动过期释放误杀用户
踩过的坑:
- 本地缓存不一致:某用户被加入黑名单后,由于本地缓存未同步,该用户仍在 5 分钟内可以下单。解决方案:黑名单变更强制走广播失效(而非等待 TTL),并增加数据库兜底校验(最终一致性)。
- 限流粒度太粗:早期按 IP 限流导致 NAT 出口用户被误杀。解决方案:引入用户 ID + IP + 设备指纹的多维联合限流。
4.2 字节跳动:反爬与内容安全的灰名单体系
背景:字节系的抖音、TikTok 面临全球最大的爬虫和内容滥用攻击。爬虫特征:行为模式高度拟人,传统黑名单(IP/账号)容易被绕过。
解决方案:
-
动态灰名单(Dynamic Graylist):
- 新注册用户默认进入观察池,前 7 天的所有行为被记录到 ClickHouse
- 机器学习模型(XGBoost + 图神经网络)每日计算用户异常得分
- 得分 0.6~0.8 进入灰名单:限制功能(不能评论、不能私信、内容限流)
- 得分 > 0.8 进入黑名单:封号并上报设备指纹
-
设备指纹 + 关联图谱:
- 收集 200+ 设备维度特征(Canvas 指纹、WebGL、字体列表、时区、电池 API)
- 构建设备-账号-IP异构图,识别"一人多号"和"一号多设备"
- 图中度中心性高的节点自动进入灰名单观察
-
自适应频控:
- 普通用户:点赞每分钟 60 次
- 灰名单用户:点赞每分钟 10 次,且每次点赞前需要滑动验证码
- 黑名单关联设备:所有操作直接拒绝
-
阶梯限流的 gRPC 拦截器:
// 自定义限流元数据 message RateLimitMeta { string user_tier = 1; // NORMAL / GRAY / BLACK string device_trust = 2; // HIGH / MEDIUM / LOW string action_type = 3; // LIKE / COMMENT / FOLLOW int32 base_quota = 4; // 基础配额 float multiplier = 5; // 系数:NORMAL=1.0, GRAY=0.2, BLACK=0.0 }
踩过的坑:
- 灰名单震荡:用户反复在 NORMAL 和 GRAY 之间切换,体验极差。解决方案:引入磁滞(Hysteresis)机制——升级阈值 0.6,降级阈值 0.3,中间 0.3~0.6 区间保持原状态。
- 隐私合规:欧盟 GDPR 要求设备指纹收集需明确 consent。解决方案:欧盟用户走弱指纹策略(仅收集 20 个特征),其他区域走强指纹。
4.3 补充:LinkedIn 的 anti-abuse rate limiting
LinkedIn 面对爬虫和自动化工具,采用ChronoGuard系统:
- 时间序列特征:不仅限流"请求次数",还限流"请求间隔的熵值"——人类点击间隔服从对数正态分布,而机器人往往均匀分布。
- Graph-based blacklisting:如果一个账号与多个已知黑名单账号有强关联(共享 IP、设备、支付卡),则该账号自动进入灰名单,限制其联系请求发送量。
5. 业务场景对照与注意事项
5.1 大型加密货币交易所 风控场景映射
| 业务场景 | 黑名单应用 | 白名单应用 | 灰名单应用 | 频控策略 |
|---|---|---|---|---|
| 提现 (Withdraw) | 制裁地址(OFAC/UN)直接阻断;被盗账户冻结 | VIP 用户提高单笔限额;KYC 通过用户降低审核 | 新设备首次提现:延迟 24h + 邮件确认;大额提现:人工审核队列 | 用户级:24h 5 次;地址级:同地址 24h 接收 3 笔;全局:10k QPS |
| 登录 (Login) | 已知攻击 IP/代理 IP 库;泄露凭证账户 | 内部员工 IP 段;已知可信设备 | 异地登录/新设备:强制 2FA + 邮件通知 | 用户级:1h 10 次失败;IP 级:1min 60 次;全局:50k QPS |
| 交易下单 (Trade) | 市场操纵账户(wash trading) | 做市商账户:手续费减免 + 频控放宽 | 新注册账户:前 30 天限制杠杆倍数 | 用户级:每秒 10 单;IP 级:每秒 100 单;全局:100 万 QPS |
| KYC 提交 | 伪造证件特征库;已知欺诈身份 | 企业认证用户 | 高风险国籍/地区用户:增强尽调 | 每用户 7 天 1 次;人工审核队列长度限流 |
| API Key 调用 | 异常调用模式(固定间隔刷数据) | Partner API:独立限流配额 | 新 API Key:前 7 天限制调用频率,观察模式 | 按 API Key 限流;按 IP 限流;全局 API Gateway 限流 |
| 充币 (Deposit) | 暗网/混币器地址黑名单(Chainalysis 数据) | 已知合规交易所地址 | 大额充币:延迟确认 + 来源分析 | 地址级:无严格频控,但大额触发 AML 审查 |
5.2 常见误区 vs 正确做法
| ❌ 常见误区 | ✅ 正确做法 |
|---|---|
| 黑名单直接返回"拒绝",暴露风控逻辑 | 静默拒绝(Shadow Ban)或返回通用错误码,延迟响应时间防止时序攻击 |
| 名单存储在数据库,每次查询走 DB | L1 本地缓存 + L2 Redis,DB 仅用于持久化和冷启动加载 |
| 限流只限制 QPS,不考虑业务语义 | 区分"读限流"和"写限流",写操作限流更严格;区分"正常流量"和"失败流量"(登录失败单独计数) |
| 黑名单永久有效,不设置 TTL | 名单必须有过期机制和申诉通道,防止误杀长期无法恢复 |
| 灰名单只是"弱版黑名单" | 灰名单是独立策略集合:降低限额、增加摩擦(friction)、延迟执行,而非简单放行或拒绝 |
| 限流 key 只用 userId | 多维 key:userId + deviceId + IP + sessionId,防止盗用身份绕过 |
| 全局限流一刀切 | 按业务线、用户等级、地域分级,VIP 用户和系统监控流量不受全局限流影响 |
| 名单更新同步阻塞主线程 | 名单更新走异步消息(Kafka/RabbitMQ),本地缓存最终一致性 |
5.3 选型建议
| 场景 | 推荐方案 | 不推荐 |
|---|---|---|
| 高频名单查询(>10k QPS) | Caffeine/Guava 本地缓存 + Redis Pub/Sub 同步 | 直接查数据库 |
| 精准限流(验证码/提现) | Redis + Lua 滑动窗口 | 令牌桶(边界突发问题) |
| API 网关限流(允许突发) | Guava RateLimiter / Sentinel 令牌桶 | 漏桶(过于严格) |
| 流量整形(固定输出速率) | 漏桶 / Nginx limit_req zone | 令牌桶 |
| 动态热点防护 | Sentinel 热点参数限流 | 固定规则 |
| 全局系统保护 | Sentinel QPS 限流 + 自适应降载 | 单点 Redis(会成为瓶颈) |
6. FAQ 与高频追问
Q1:滑动窗口和令牌桶的核心区别是什么?在什么场景下必须选滑动窗口?
答:
核心区别:
- 滑动窗口保证的是"在最近 N 时间单位内,请求数不超过 M",是绝对精确的。不允许任何突发超出限额。
- 令牌桶保证的是"长期平均速率不超过 r,但允许最多 C 的突发",是相对宽松的。允许瞬时突发。
必须选滑动窗口的场景:
- 严格计数场景:发送短信验证码("每手机号每 60 秒最多 1 条"),绝不能允许 1.01 秒内发 2 条。
- 资损场景:提现次数限制("每用户每天最多 5 笔"),不能用令牌桶导致窗口边界多提一笔。
- 合规场景:API 调用配额(OAuth rate limit),超出即违规,不允许 burst。
选令牌桶的场景:
- API 网关限流:用户正常操作有突发(如页面刷新同时触发 5 个 API),允许短突发但限制长期平均。
- 带宽控制:网络流量整形,允许文件下载开始时快速填充缓冲区。
追问深挖:面试官可能问"Redis 滑动窗口的内存开销怎么优化?"
- 答:不用 ZSET 存储每个请求的时间戳,改用 ** Sliding Window Log 的近似算法**(如分桶计数,将 1 分钟分为 6 个 10 秒桶,只记录 6 个整数),牺牲少量精度换取 O(1) 内存。Sentinel 的滑动窗口就是这么实现的。
Q2:分布式环境下,多个服务节点如何保证限流的严格一致性?Redis 挂了怎么办?
答:
三层降级策略:
-
正常态(Redis 健康):
- 所有限流判断走 Redis + Lua 原子操作,严格一致性
- 使用 Redis Cluster,分片存储不同维度的限流 key
-
降级态(Redis 慢/部分不可用):
- 切换到本地计数器(每个 JVM 实例维护一个内存计数器)
- 由于失去了全局一致性,本地限流阈值需要按实例数均分:全局 10000 QPS,10 个实例则每个实例限 1000 QPS
- 引入gossip 协议或广播机制,让实例间共享部分状态(如黑名单更新)
-
兜底态(Redis 完全不可用):
- 启动静态名单:服务启动时从本地配置文件加载最核心的黑名单(制裁地址、已知攻击 IP)
- 开启全局限流开关:Nginx/Envoy 层硬限制(如单 IP 最大连接数),保护后端
- 进入只读模式或排队模式:写操作(提现、下单)进入消息队列延迟处理,读操作继续服务
关键设计:
- 限流组件必须有 health check 和熔断机制,自动感知 Redis 状态
- 本地缓存的预热机制:启动时从 Redis 加载热点数据,避免冷启动穿透
- 影子模式:降级期间,本地限流的同时异步尝试恢复 Redis 连接,一旦恢复平滑切换
Q3:黑名单更新后,本地缓存的脏读怎么解决?要求"更新后 100ms 内全局生效"如何实现?
答:
100ms 内全局生效的架构:
名单管理中心 (Admin Service)
|
| 1. 写入 MySQL(持久化)
| 2. 写入 Redis( SET key value EX 3600 )
| 3. 发布 Redis Pub/Sub 消息:{action: "INVALIDATE", key: "user:123", type: "BLACKLIST"}
v
Redis Cluster ----Pub/Sub----> 所有应用节点
|
v
本地缓存 Caffeine/Guava
|
v
收到消息后立即 invalidate(key)
关键实现细节:
-
Pub/Sub 可靠性:Redis Pub/Sub 不保证消息必达(客户端断连期间的消息丢失)。解决方案:
- 使用 Redis Stream 或 Kafka 作为可靠消息通道
- 每个消费者维护消费位点,断连后从上次位点续读
- 兜底:本地缓存设置短 TTL(如 30 秒),最坏情况 30 秒后自动失效
-
批量失效:如果一次性更新 10 万个黑名单,不能发 10 万条消息。解决方案:
- 消息格式支持 pattern invalidate:
{action: "INVALIDATE_PATTERN", pattern: "risk:list:black:*"} - 本地缓存遍历所有 key,匹配 pattern 的立即失效
- 消息格式支持 pattern invalidate:
-
写穿透保护:更新期间,查询请求可能打到已失效的本地缓存。解决方案:
- 延迟双删:先删缓存 -> 写 Redis -> 等 100ms -> 再发 invalidate 消息 -> 再等 500ms -> 第三次确认删除
- 或者使用 Cache Aside + 版本号:每次名单条目带版本号,本地缓存只缓存最新版本
-
100ms 量化分解:
- 写 Redis:1ms
- 发 Kafka 消息:5ms
- Kafka 消费 + 本地失效:10ms
- 网络传播 + 处理:20ms
- 兜底 TTL:30s
- 实际 P99 通常在 50ms 内
Q4:灰名单中的"观察期"设计有哪些陷阱?如何防止用户永远卡在灰名单中无法恢复?
答:
五大陷阱与对策:
| 陷阱 | 现象 | 对策 |
|---|---|---|
| 震荡(Oscillation) | 用户评分在阈值上下波动,反复进出灰名单 | 引入磁滞带:升级阈值 0.6,降级阈值 0.3,0.3~0.6 之间保持状态不变 |
| 冷冻(Freezing) | 用户进入灰名单后,系统不再评估其新行为,永远卡住 | 强制定期重评:灰名单用户每天至少重新计算一次评分,无论是否有新行为 |
| 证据衰减(Evidence Decay) | 用户 3 个月前的一次异常至今仍影响评分 | 引入时间衰减函数:w(t) = exp(-λt),老证据权重指数下降 |
| 观察期无限延长 | 每次新异常都重置观察期 TTL,导致永不过期 | 观察期上限:无论多少次异常,最大观察期不超过 30 天 |
| 灰名单泛滥 | 阈值设置过低,大量正常用户进入灰名单 | 基线校准:定期分析灰名单转化率(灰->黑 / 灰->白),转化率 < 10% 说明阈值过松 |
恢复机制设计:
// 灰名单自动恢复的条件(满足任一即可)
public boolean canRecoverFromGray(String userId) {
GrayRecord record = graylistDao.find(userId);
// 条件 1: 观察期自然结束且期间无新异常
if (record.getObservationEnd().isBefore(Instant.now())
&& record.getNewAnomaliesDuringGray() == 0) {
return true;
}
// 条件 2: 连续 N 天行为评分低于恢复阈值
List<Double> recentScores = record.getLastNDaysScores(7);
if (recentScores.size() >= 7
&& recentScores.stream().allMatch(s -> s < THETA_RECOVER)) {
return true;
}
// 条件 3: 用户主动完成增强验证(人脸 + 视频 + 手持证件)
if (record.hasCompletedEnhancedVerification()
&& record.getEnhancedVerificationResult() == PASSED) {
return true;
}
// 条件 4: 人工审核通过(客服/风控运营介入)
if (record.getManualReviewResult() == APPROVED) {
return true;
}
return false;
}追问深挖:"如果灰名单用户申诉,怎么防止攻击者批量申诉绕过?"
- 答:申诉本身也要限流——每个用户每月最多申诉 1 次,申诉需人脸识别 + 活体检测,申诉材料进入人工审核队列(审核员每日处理上限)。
Q5:在交易所场景中,黑名单误杀一个合规用户(如某国政要亲属)会造成什么后果?如何设计误杀防护?
答:
误杀的代价:
- 监管风险:OFAC 误封可能是"宁可错杀",但误封本国合规用户可能触发监管调查和罚款(如 FCA/MAS 对不公平对待客户的处罚)。
- 声誉风险:KOL 用户在 Twitter 上发声,引发舆论危机。
- 法律风险:某些司法管辖区(欧盟)要求解释自动化决策权(GDPR Article 22),用户有权知道为什么被拉黑。
- 资金风险:用户资产被冻结期间的利息损失可能触发赔偿。
误杀防护的六层设计:
Layer 1: 自动黑名单前置拦截
|
v
Layer 2: 高风险操作人工审核队列(>10k USDT 提现必须人审)
|
v
Layer 3: 灰名单自动降级机制(误杀用户可在灰名单中恢复)
|
v
Layer 4: 申诉通道 + 证据保全(用户可提交材料自证清白)
|
v
Layer 5: 样本回溯审计(每日抽查 1% 黑名单决策,人工复核)
|
v
Layer 6: 误杀补偿与上报(确认误杀后,补偿 + 根因分析 + 规则修复)
具体措施:
-
白名单覆盖机制:
- 已知的高价值客户(通过 KYC Level 3 的企业账户)默认进入保护白名单
- 白名单用户触发黑名单规则时,不直接阻断,而是进入优先人工审核队列(15 分钟内有人处理)
-
双轨制执行:
- 硬黑名单(制裁名单):机器自动执行,无人工干预
- 软黑名单(模型/规则命中):触发增强验证,用户可以"自证清白"完成交易
-
样本审计(Sample Audit):
- 每日随机抽取 1% 的黑名单命中案例,由二级风控人工复核
- 如果人工认为误杀率 > 5%,自动回退该规则并告警
-
A/B Test 与影子模式:
- 新黑名单规则上线时,先走影子模式(只记录决策但不执行),观察 7 天
- 误杀率 < 0.1% 且命中率 > 80% 才切换为执行模式
-
解释性输出(Explainability):
- 每个黑名单决策记录触发规则 ID、特征值、阈值、模型得分
- 用户申诉时,风控人员可快速定位原因(如"触发规则 R-472:IP 归属地与注册地不一致,且 24h 内 3 次改绑手机")
-
熔断与回滚:
- 规则支持秒级下线:通过配置中心推送,所有节点 5 秒内停止执行该规则
- 支持批量恢复:确认误杀后,一键将受影响用户从黑名单移出并补偿
Q6(附加):如何应对基于"慢速攻击"(Low-and-Slow Attack)的绕过?
答:
慢速攻击特征:攻击者不暴力冲撞,而是精确控制请求速率略低于限流阈值,长期执行。
例如:
- 限流阈值:每 IP 每分钟 60 次登录
- 攻击模式:每 1.1 秒 1 次登录,持续 24 小时 = 78500 次尝试
检测与防御:
-
行为模式分析:
- 正常用户登录间隔服从对数正态分布(大部分在 1 秒~1 小时,极少固定间隔)
- 攻击者往往使用固定间隔或均匀分布
- 计算请求间隔的熵值和变异系数(CV),CV < 0.1 且熵值低则标记为机器行为
-
长期滑动窗口:
- 不仅限流"每分钟",还限流"每小时"、"每天"
- 每小时 100 次且每天 500 次,攻击者即使绕过分钟级限制,也会触发小时级/天级限制
-
关联限流:
- 单 IP 未超限,但该 IP 下的 100 个用户各发起 10 次登录 → 总共 1000 次
- 实现:维护 IP -> User Set 的映射,当某 IP 关联的独立用户数在 1 小时内超过 20 个,触发 IP 级限流
-
挑战-响应(Challenge):
- 对慢速攻击不直接阻断,而是增加摩擦:要求验证码、滑动验证、设备指纹校验
- 攻击者成本上升后自然放弃
一句话总结:黑白灰名单是风控的"交通信号灯"(红停绿行黄观察),频控限流是"道路限速牌"(不同车道不同限速)。真正的高可用体系不是单一机制的堆叠,而是本地缓存的极速判定 + Redis 的分布式一致性 + 灰名单的智能过渡 + 阶梯限流的多维防护的有机协同,核心目标是在毫秒级内做出"不漏杀、不误杀、不压垮"的最优决策。