// 示例：个人用户限流实现
@Component
public class UserRateLimiter {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    // 用户全局限流（所有通道）
    public boolean isUserAllowed(String userId) {
        String key = "rate_limit:user:" + userId;
        return checkAndIncrement(key, getUserGlobalLimit(userId));
    }
    
    // 用户通道限流（特定通道）
    public boolean isUserChannelAllowed(String userId, String channelId) {
        String key = "rate_limit:user:" + userId + ":channel:" + channelId;
        return checkAndIncrement(key, getUserChannelLimit(userId, channelId));
    }
    
    // 用户业务类型限流
    public boolean isUserBusinessAllowed(String userId, String businessType) {
        String key = "rate_limit:user:" + userId + ":business:" + businessType;
        return checkAndIncrement(key, getUserBusinessLimit(userId, businessType));
    }
    
    private boolean checkAndIncrement(String key, int limit) {
        Long current = redisTemplate.opsForValue().increment(key, 1);
        
        if (current == 1) {
            // 设置过期时间（1分钟）
            redisTemplate.expire(key, 60, TimeUnit.SECONDS);
        }
        
        return current <= limit;
    }
    
    private int getUserGlobalLimit(String userId) {
        // 根据用户等级获取限流阈值
        User user = userService.getUserById(userId);
        switch (user.getLevel()) {
            case VIP: return 1000;  // VIP用户每分钟1000条
            case PREMIUM: return 500; // 高级用户每分钟500条
            case STANDARD: return 100; // 标准用户每分钟100条
            default: return 10; // 普通用户每分钟10条
        }
    }
    
    private int getUserChannelLimit(String userId, String channelId) {
        // 根据用户和通道类型获取限流阈值
        User user = userService.getUserById(userId);
        switch (channelId) {
            case "sms":
                return user.getLevel() == UserLevel.VIP ? 100 : 10;
            case "email":
                return user.getLevel() == UserLevel.VIP ? 200 : 50;
            case "push":
                return user.getLevel() == UserLevel.VIP ? 500 : 100;
            default:
                return 10;
        }
    }
}

关键设计要点：

多级限流：支持用户全局、通道、业务类型多级限流
动态阈值：根据用户等级动态调整限流阈值
实时统计：实时统计用户发送频率
自动过期：自动清理过期的统计信息

企业用户限流

// 示例：企业用户限流实现
@Component
public class EnterpriseRateLimiter {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    // 企业配额管理
    public boolean isEnterpriseAllowed(String enterpriseId, String businessType) {
        // 检查企业配额
        EnterpriseQuota quota = quotaService.getEnterpriseQuota(enterpriseId);
        if (quota == null || !quota.isEnabled()) {
            return false;
        }
        
        // 检查业务类型配额
        BusinessQuota businessQuota = quota.getBusinessQuota(businessType);
        if (businessQuota == null || businessQuota.getLimit() <= 0) {
            return false;
        }
        
        String key = "rate_limit:enterprise:" + enterpriseId + ":business:" + businessType;
        Long current = redisTemplate.opsForValue().increment(key, 1);
        
        if (current == 1) {
            // 设置过期时间（根据配额周期）
            redisTemplate.expire(key, businessQuota.getPeriod(), TimeUnit.SECONDS);
        }
        
        return current <= businessQuota.getLimit();
    }
    
    // 企业通道限流
    public boolean isEnterpriseChannelAllowed(String enterpriseId, String channelId) {
        EnterpriseQuota quota = quotaService.getEnterpriseQuota(enterpriseId);
        if (quota == null) {
            return false;
        }
        
        ChannelQuota channelQuota = quota.getChannelQuota(channelId);
        if (channelQuota == null || channelQuota.getLimit() <= 0) {
            return false;
        }
        
        String key = "rate_limit:enterprise:" + enterpriseId + ":channel:" + channelId;
        Long current = redisTemplate.opsForValue().increment(key, 1);
        
        if (current == 1) {
            redisTemplate.expire(key, channelQuota.getPeriod(), TimeUnit.SECONDS);
        }
        
        return current <= channelQuota.getLimit();
    }
}

关键设计要点：

配额管理：支持企业级配额管理
灵活配置：支持不同业务类型和通道的独立配置
周期控制：支持不同时间周期的配额控制
实时监控：实时监控企业使用情况

IP维度限流

基于IP地址的限流策略防止恶意刷量：

基础IP限流

// 示例：基础IP限流实现
@Component
public class IpRateLimiter {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    // IP全局限流
    public boolean isIpAllowed(String ipAddress) {
        String key = "rate_limit:ip:" + ipAddress;
        return checkAndIncrement(key, getIpGlobalLimit());
    }
    
    // IP通道限流
    public boolean isIpChannelAllowed(String ipAddress, String channelId) {
        String key = "rate_limit:ip:" + ipAddress + ":channel:" + channelId;
        return checkAndIncrement(key, getIpChannelLimit(channelId));
    }
    
    // IP业务类型限流
    public boolean isIpBusinessAllowed(String ipAddress, String businessType) {
        String key = "rate_limit:ip:" + ipAddress + ":business:" + businessType;
        return checkAndIncrement(key, getIpBusinessLimit(businessType));
    }
    
    private boolean checkAndIncrement(String key, int limit) {
        // 使用Lua脚本保证原子性
        String script = 
            "local current = redis.call('incr', KEYS[1]) " +
            "if current == 1 then " +
            "  redis.call('expire', KEYS[1], 60) " +
            "end " +
            "return current";
            
        Long current = (Long) redisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Collections.singletonList(key)
        );
        
        return current <= limit;
    }
    
    private int getIpGlobalLimit() {
        // 全局IP限流：每分钟100条
        return 100;
    }
    
    private int getIpChannelLimit(String channelId) {
        // 不同通道的IP限流
        switch (channelId) {
            case "sms": return 50;   // 短信每分钟50条
            case "email": return 100; // 邮件每分钟100条
            case "push": return 200;  // 推送每分钟200条
            default: return 20;
        }
    }
    
    private int getIpBusinessLimit(String businessType) {
        // 不同业务类型的IP限流
        switch (businessType) {
            case "verification": return 30;  // 验证码每分钟30条
            case "marketing": return 10;     // 营销每分钟10条
            case "notification": return 50;  // 通知每分钟50条
            default: return 5;
        }
    }
}

关键设计要点：

原子操作：使用Lua脚本保证计数操作的原子性
多维度限流：支持IP全局、通道、业务类型限流
差异化阈值：根据不同维度设置不同的限流阈值
实时统计：实时统计IP访问频率

智能IP防护

// 示例：智能IP防护实现
@Component
public class SmartIpProtection {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    // IP行为分析
    public IpRiskLevel analyzeIpRisk(String ipAddress) {
        String behaviorKey = "ip_behavior:" + ipAddress;
        String riskKey = "ip_risk:" + ipAddress;
        
        // 获取IP行为数据
        Map<String, String> behaviorData = redisTemplate.opsForHash().entries(behaviorKey);
        
        // 分析行为模式
        int sendCount = parseInt(behaviorData.get("send_count"), 0);
        int failCount = parseInt(behaviorData.get("fail_count"), 0);
        int complaintCount = parseInt(behaviorData.get("complaint_count"), 0);
        long lastActivity = parseLong(behaviorData.get("last_activity"), System.currentTimeMillis());
        
        // 计算风险分数
        double riskScore = calculateRiskScore(sendCount, failCount, complaintCount, 
                                            System.currentTimeMillis() - lastActivity);
        
        // 更新风险等级
        IpRiskLevel riskLevel = determineRiskLevel(riskScore);
        redisTemplate.opsForValue().set(riskKey, riskLevel.name(), 1, TimeUnit.HOURS);
        
        return riskLevel;
    }
    
    // 动态限流调整
    public int getDynamicLimit(String ipAddress, String channelId) {
        IpRiskLevel riskLevel = getIpRiskLevel(ipAddress);
        int baseLimit = getBaseIpLimit(channelId);
        
        switch (riskLevel) {
            case HIGH_RISK:
                return baseLimit / 10; // 高风险IP限制为原来的1/10
            case MEDIUM_RISK:
                return baseLimit / 2;  // 中风险IP限制为原来的1/2
            case LOW_RISK:
                return baseLimit;      // 低风险IP使用基础限流
            default:
                return baseLimit;
        }
    }
    
    private double calculateRiskScore(int sendCount, int failCount, int complaintCount, 
                                    long inactiveTime) {
        double score = 0.0;
        
        // 发送频率权重
        if (sendCount > 1000) {
            score += 30;
        } else if (sendCount > 100) {
            score += 10;
        }
        
        // 失败率权重
        if (sendCount > 0) {
            double failRate = (double) failCount / sendCount;
            if (failRate > 0.5) {
                score += 40;
            } else if (failRate > 0.1) {
                score += 20;
            }
        }
        
        // 投诉权重
        score += complaintCount * 5;
        
        // 不活跃时间权重（长时间不活跃后突然活跃）
        if (inactiveTime > 86400000 && sendCount > 50) { // 超过1天不活跃
            score += 20;
        }
        
        return Math.min(score, 100); // 最大100分
    }
    
    private IpRiskLevel determineRiskLevel(double riskScore) {
        if (riskScore >= 80) {
            return IpRiskLevel.HIGH_RISK;
        } else if (riskScore >= 50) {
            return IpRiskLevel.MEDIUM_RISK;
        } else if (riskScore >= 20) {
            return IpRiskLevel.LOW_RISK;
        } else {
            return IpRiskLevel.NORMAL;
        }
    }
    
    public enum IpRiskLevel {
        NORMAL, LOW_RISK, MEDIUM_RISK, HIGH_RISK
    }
}

关键实现要点：

行为分析：分析IP的行为模式和历史记录
风险评分：基于多维度数据计算风险评分
动态调整：根据风险等级动态调整限流阈值
持续学习：持续学习和优化风险评估模型

业务类型维度限流

基于业务类型的限流策略满足不同业务场景的需求：

业务类型分类

// 示例：业务类型限流实现
@Component
public class BusinessTypeRateLimiter {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    // 业务类型全局限流
    public boolean isBusinessTypeAllowed(String businessType) {
        String key = "rate_limit:business:" + businessType;
        return checkAndIncrement(key, getBusinessTypeLimit(businessType));
    }
    
    // 业务类型通道限流
    public boolean isBusinessTypeChannelAllowed(String businessType, String channelId) {
        String key = "rate_limit:business:" + businessType + ":channel:" + channelId;
        return checkAndIncrement(key, getBusinessTypeChannelLimit(businessType, channelId));
    }
    
    // 业务类型用户等级限流
    public boolean isBusinessTypeUserLevelAllowed(String businessType, UserLevel userLevel) {
        String key = "rate_limit:business:" + businessType + ":user_level:" + userLevel.name();
        return checkAndIncrement(key, getBusinessTypeUserLevelLimit(businessType, userLevel));
    }
    
    private boolean checkAndIncrement(String key, int limit) {
        Long current = redisTemplate.opsForValue().increment(key, 1);
        
        if (current == 1) {
            // 设置过期时间（1小时）
            redisTemplate.expire(key, 3600, TimeUnit.SECONDS);
        }
        
        return current <= limit;
    }
    
    private int getBusinessTypeLimit(String businessType) {
        // 不同业务类型的全局限流
        switch (businessType) {
            case "verification": return 10000;  // 验证码每小时10000条
            case "marketing": return 5000;      // 营销每小时5000条
            case "notification": return 50000;  // 通知每小时50000条
            case "alert": return 1000;          // 告警每小时1000条
            default: return 1000;
        }
    }
    
    private int getBusinessTypeChannelLimit(String businessType, String channelId) {
        // 不同业务类型和通道的组合限流
        String combination = businessType + ":" + channelId;
        switch (combination) {
            case "verification:sms": return 5000;   // 验证码短信每小时5000条
            case "marketing:email": return 2000;    // 营销邮件每小时2000条
            case "notification:push": return 20000; // 通知推送每小时20000条
            default: return 500;
        }
    }
    
    private int getBusinessTypeUserLevelLimit(String businessType, UserLevel userLevel) {
        // 不同业务类型和用户等级的组合限流
        int baseLimit = getBusinessTypeLimit(businessType);
        switch (userLevel) {
            case VIP: return baseLimit * 2;      // VIP用户2倍限流
            case PREMIUM: return baseLimit;      // 高级用户正常限流
            case STANDARD: return baseLimit / 2; // 标准用户1/2限流
            default: return baseLimit / 10;      // 普通用户1/10限流
        }
    }
}

关键设计要点：

分类管理：按业务类型分类管理限流策略
组合限流：支持业务类型与通道、用户等级的组合限流
差异化配置：根据不同组合设置不同的限流阈值
动态调整：支持根据业务需求动态调整限流配置

防骚扰机制设计

防骚扰机制保护用户免受骚扰信息的困扰：

用户偏好设置

接收频率控制

// 示例：用户偏好设置实现
@Service
public class UserPreferenceService {
    
    @Autowired
    private UserRepository userRepository;
    
    // 设置用户接收偏好
    public void setUserPreference(String userId, NotificationPreference preference) {
        User user = userRepository.findById(userId);
        if (user == null) {
            throw new UserNotFoundException("用户不存在: " + userId);
        }
        
        user.setNotificationPreference(preference);
        userRepository.save(user);
        
        // 更新限流配置
        updateRateLimitConfig(userId, preference);
    }
    
    // 获取用户接收偏好
    public NotificationPreference getUserPreference(String userId) {
        User user = userRepository.findById(userId);
        if (user == null) {
            return getDefaultPreference(); // 返回默认偏好设置
        }
        
        NotificationPreference preference = user.getNotificationPreference();
        return preference != null ? preference : getDefaultPreference();
    }
    
    // 检查是否允许发送
    public boolean isSendingAllowed(String userId, String businessType) {
        NotificationPreference preference = getUserPreference(userId);
        
        // 检查是否在免打扰时间
        if (isInDoNotDisturbTime(preference)) {
            return false;
        }
        
        // 检查业务类型是否被禁止
        if (preference.getDisabledBusinessTypes().contains(businessType)) {
            return false;
        }
        
        // 检查发送频率限制
        return checkFrequencyLimit(userId, businessType, preference);
    }
    
    private boolean isInDoNotDisturbTime(NotificationPreference preference) {
        if (!preference.isDoNotDisturbEnabled()) {
            return false;
        }
        
        LocalTime now = LocalTime.now();
        LocalTime start = preference.getDoNotDisturbStart();
        LocalTime end = preference.getDoNotDisturbEnd();
        
        // 处理跨天情况
        if (start.isAfter(end)) {
            return now.isAfter(start) || now.isBefore(end);
        } else {
            return now.isAfter(start) && now.isBefore(end);
        }
    }
    
    private boolean checkFrequencyLimit(String userId, String businessType, 
                                      NotificationPreference preference) {
        // 获取用户该业务类型的频率限制
        FrequencyLimit limit = preference.getFrequencyLimits().get(businessType);
        if (limit == null) {
            return true; // 无限制
        }
        
        String key = "user_frequency:" + userId + ":business:" + businessType;
        Long lastSendTime = redisTemplate.opsForValue().getOperations()
            .boundValueOps(key).getAndSet(System.currentTimeMillis());
            
        if (lastSendTime == null) {
            return true; // 首次发送
        }
        
        long interval = System.currentTimeMillis() - lastSendTime;
        return interval >= limit.getMinInterval();
    }
}

// 用户通知偏好设置
public class NotificationPreference {
    private boolean doNotDisturbEnabled;      // 是否启用免打扰
    private LocalTime doNotDisturbStart;      // 免打扰开始时间
    private LocalTime doNotDisturbEnd;        // 免打扰结束时间
    private Set<String> disabledBusinessTypes; // 禁止的业务类型
    private Map<String, FrequencyLimit> frequencyLimits; // 频率限制
    private Set<String> allowedChannels;      // 允许的通知通道
    private boolean allowMarketing;           // 是否允许营销信息
    
    // 构造函数、getter和setter方法...
}

// 频率限制配置
public class FrequencyLimit {
    private long minInterval;  // 最小发送间隔（毫秒）
    private int maxPerDay;     // 每天最大发送次数
    private int maxPerHour;    // 每小时最大发送次数
    
    // 构造函数、getter和setter方法...
}

关键设计要点：

个性化设置：支持用户自定义接收偏好
时间控制：支持免打扰时间设置
业务分类：支持按业务类型设置不同偏好
频率限制：支持发送频率的个性化限制

黑名单管理

// 示例：黑名单管理实现
@Service
public class BlacklistService {
    
    @Autowired
    private RedisTemplate<String, String> redisTemplate;
    
    // 添加到黑名单
    public void addToBlacklist(String userId, String target, BlacklistType type, 
                              String reason, long duration) {
        String key = "blacklist:" + type.name() + ":" + target;
        String value = userId + ":" + reason + ":" + (System.currentTimeMillis() + duration);
        
        redisTemplate.opsForSet().add(key, value);
        redisTemplate.expire(key, duration, TimeUnit.MILLISECONDS);
        
        // 记录操作日志
        auditService.recordBlacklistOperation(userId, target, type, "ADD", reason);
    }
    
    // 从黑名单移除
    public void removeFromBlacklist(String userId, String target, BlacklistType type) {
        String key = "blacklist:" + type.name() + ":" + target;
        redisTemplate.opsForSet().remove(key, userId);
        
        // 记录操作日志
        auditService.recordBlacklistOperation(userId, target, type, "REMOVE", "");
    }
    
    // 检查是否在黑名单中
    public BlacklistCheckResult checkBlacklist(String target, BlacklistType type) {
        String key = "blacklist:" + type.name() + ":" + target;
        Set<String> entries = redisTemplate.opsForSet().members(key);
        
        if (entries == null || entries.isEmpty()) {
            return new BlacklistCheckResult(false, Collections.emptyList());
        }
        
        List<BlacklistEntry> activeEntries = new ArrayList<>();
        long currentTime = System.currentTimeMillis();
        
        for (String entry : entries) {
            String[] parts = entry.split(":");
            if (parts.length >= 3) {
                String userId = parts[0];
                String reason = parts[1];
                long expireTime = Long.parseLong(parts[2]);
                
                if (currentTime < expireTime) {
                    activeEntries.add(new BlacklistEntry(userId, reason, expireTime));
                } else {
                    // 清理过期条目
                    redisTemplate.opsForSet().remove(key, entry);
                }
            }
        }
        
        return new BlacklistCheckResult(!activeEntries.isEmpty(), activeEntries);
    }
    
    // 全局黑名单检查
    public boolean isGloballyBlocked(String target) {
        // 检查各种类型的黑名单
        for (BlacklistType type : BlacklistType.values()) {
            BlacklistCheckResult result = checkBlacklist(target, type);
            if (result.isBlocked()) {
                return true;
            }
        }
        return false;
    }
    
    public enum BlacklistType {
        USER,      // 用户黑名单
        IP,        // IP黑名单
        DEVICE,    // 设备黑名单
        CONTENT    // 内容黑名单
    }
    
    // 黑名单检查结果
    public static class BlacklistCheckResult {
        private final boolean blocked;
        private final List<BlacklistEntry> entries;
        
        public BlacklistCheckResult(boolean blocked, List<BlacklistEntry> entries) {
            this.blocked = blocked;
            this.entries = entries;
        }
        
        // getter方法...
    }
    
    // 黑名单条目
    public static class BlacklistEntry {
        private final String userId;
        private final String reason;
        private final long expireTime;
        
        public BlacklistEntry(String userId, String reason, long expireTime) {
            this.userId = userId;
            this.reason = reason;
            this.expireTime = expireTime;
        }
        
        // getter方法...
    }
}

关键实现要点：

多类型支持：支持用户、IP、设备等多种黑名单类型
时效管理：支持临时和永久黑名单
自动清理：自动清理过期的黑名单条目
审计记录：记录所有黑名单操作日志

限流算法实现

选择合适的限流算法是实现高效限流的关键：

令牌桶算法

// 示例：令牌桶算法实现
@Component
public class TokenBucketRateLimiter {
    
    private final Map<String, TokenBucket> buckets = new ConcurrentHashMap<>();
    
    public boolean tryAcquire(String key, int permits, long timeoutMs) {
        TokenBucket bucket = buckets.computeIfAbsent(key, 
            k -> new TokenBucket(getRateLimit(k), getBucketCapacity(k)));
        return bucket.tryAcquire(permits, timeoutMs);
    }
    
    private static class TokenBucket {
        private final long capacity;      // 桶容量
        private final long rate;          // 令牌生成速率（每秒）
        private long tokens;              // 当前令牌数
        private long lastRefillTime;      // 上次填充时间
        
        public TokenBucket(long rate, long capacity) {
            this.rate = rate;
            this.capacity = capacity;
            this.tokens = capacity;
            this.lastRefillTime = System.currentTimeMillis();
        }
        
        public synchronized boolean tryAcquire(int permits, long timeoutMs) {
            refill(); // 先填充令牌
            
            if (tokens >= permits) {
                tokens -= permits;
                return true;
            }
            
            if (timeoutMs <= 0) {
                return false;
            }
            
            // 计算需要等待的时间
            long neededTokens = permits - tokens;
            long waitTime = (neededTokens * 1000) / rate;
            
            if (waitTime > timeoutMs) {
                return false;
            }
            
            try {
                wait(waitTime);
                refill();
                if (tokens >= permits) {
                    tokens -= permits;
                    return true;
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            
            return false;
        }
        
        private void refill() {
            long now = System.currentTimeMillis();
            long timePassed = now - lastRefillTime;
            
            if (timePassed > 0) {
                long newTokens = (timePassed * rate) / 1000;
                tokens = Math.min(capacity, tokens + newTokens);
                lastRefillTime = now;
            }
        }
    }
}

关键算法要点：

平滑限流：支持平滑的请求处理
突发处理：允许一定程度的突发请求
资源控制：有效控制资源使用
性能优化：优化算法执行性能

滑动窗口算法

// 示例：滑动窗口算法实现
@Component
public class SlidingWindowRateLimiter {
    
    private final Map<String, SlidingWindow> windows = new ConcurrentHashMap<>();
    
    public boolean tryAcquire(String key, int permits) {
        SlidingWindow window = windows.computeIfAbsent(key, 
            k -> new SlidingWindow(getWindowSize(k), getWindowInterval(k)));
        return window.tryAcquire(permits);
    }
    
    private static class SlidingWindow {
        private final long windowSize;        // 窗口大小（毫秒）
        private final long interval;          // 统计间隔（毫秒）
        private final AtomicLongArray timeSlots; // 时间槽
        private final AtomicInteger currentIndex; // 当前索引
        private final AtomicLong lastUpdateTime;  // 上次更新时间
        
        public SlidingWindow(long windowSize, long interval) {
            this.windowSize = windowSize;
            this.interval = interval;
            int slotCount = (int) (windowSize / interval) + 1;
            this.timeSlots = new AtomicLongArray(slotCount);
            this.currentIndex = new AtomicInteger(0);
            this.lastUpdateTime = new AtomicLong(System.currentTimeMillis());
        }
        
        public boolean tryAcquire(int permits) {
            long now = System.currentTimeMillis();
            updateWindow(now);
            
            long totalCount = 0;
            for (int i = 0; i < timeSlots.length(); i++) {
                totalCount += timeSlots.get(i);
            }
            
            if (totalCount + permits <= getLimit()) {
                int index = currentIndex.get();
                timeSlots.addAndGet(index, permits);
                return true;
            }
            
            return false;
        }
        
        private void updateWindow(long now) {
            long lastUpdate = lastUpdateTime.get();
            long timeDiff = now - lastUpdate;
            
            if (timeDiff >= interval) {
                int slotsToAdvance = (int) (timeDiff / interval);
                if (slotsToAdvance > 0) {
                    int current = currentIndex.get();
                    for (int i = 1; i <= Math.min(slotsToAdvance, timeSlots.length()); i++) {
                        int index = (current + i) % timeSlots.length();
                        timeSlots.set(index, 0);
                    }
                    currentIndex.set((current + slotsToAdvance) % timeSlots.length());
                    lastUpdateTime.set(now);
                }
            }
        }
        
        private long getLimit() {
            // 返回该窗口的限流阈值
            return 1000; // 示例值
        }
    }
}

关键算法要点：

精确统计：提供更精确的流量统计
时间窗口：支持灵活的时间窗口配置
实时更新：实时更新窗口数据
内存优化：优化内存使用效率

监控与告警

完善的监控告警体系是保障限流机制有效运行的关键：

实时监控

指标收集

// 示例：限流指标收集
@Component
public class RateLimitMetricsCollector {
    
    @Autowired
    private MeterRegistry meterRegistry;
    
    private final Counter allowedRequests;
    private final Counter blockedRequests;
    private final Timer requestLatency;
    private final Gauge currentRate;
    
    public RateLimitMetricsCollector(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
        
        allowedRequests = Counter.builder("rate_limit.allowed")
            .description("允许的请求数量")
            .register(meterRegistry);
            
        blockedRequests = Counter.builder("rate_limit.blocked")
            .description("被阻止的请求数量")
            .register(meterRegistry);
            
        requestLatency = Timer.builder("rate_limit.latency")
            .description("限流检查耗时")
            .register(meterRegistry);
            
        currentRate = Gauge.builder("rate_limit.current_rate")
            .description("当前请求速率")
            .register(meterRegistry, this, RateLimitMetricsCollector::getCurrentRate);
    }
    
    public void recordAllowedRequest(String dimension, String type) {
        allowedRequests.increment(Tag.of("dimension", dimension), Tag.of("type", type));
    }
    
    public void recordBlockedRequest(String dimension, String type, String reason) {
        blockedRequests.increment(
            Tag.of("dimension", dimension), 
            Tag.of("type", type), 
            Tag.of("reason", reason)
        );
    }
    
    public void recordLatency(long startTime) {
        requestLatency.record(System.currentTimeMillis() - startTime, TimeUnit.MILLISECONDS);
    }
    
    private double getCurrentRate() {
        // 计算当前请求速率
        return calculateCurrentRate();
    }
    
    // 维度特定的监控
    public void recordUserRateLimit(String userId, boolean allowed, String reason) {
        if (allowed) {
            recordAllowedRequest("user", userId);
        } else {
            recordBlockedRequest("user", userId, reason);
        }
    }
    
    public void recordIpRateLimit(String ip, boolean allowed, String reason) {
        if (allowed) {
            recordAllowedRequest("ip", ip);
        } else {
            recordBlockedRequest("ip", ip, reason);
        }
    }
    
    public void recordBusinessRateLimit(String businessType, boolean allowed, String reason) {
        if (allowed) {
            recordAllowedRequest("business", businessType);
        } else {
            recordBlockedRequest("business", businessType, reason);
        }
    }
}

关键监控要点：

多维度指标：收集用户、IP、业务类型等多维度指标
实时统计：实时统计允许和阻止的请求数量
性能监控：监控限流检查的性能耗时
告警支持：为告警系统提供必要的指标数据

仪表板设计

关键仪表板指标：

总体流量：展示平台总体的请求流量趋势
限流分布：展示各维度限流的分布情况
阻止率：展示请求被阻止的比例和趋势
性能指标：展示限流检查的性能指标
异常检测：检测和展示异常的流量模式

告警机制

阈值告警

// 示例：限流告警实现
@Component
public class RateLimitAlertManager {
    
    @Autowired
    private AlertService alertService;
    
    @Autowired
    private RateLimitMetricsCollector metricsCollector;
    
    // 高频请求告警
    @Scheduled(fixedRate = 60000) // 每分钟检查一次
    public void checkHighFrequencyAlerts() {
        // 检查用户高频请求
        checkUserHighFrequency();
        
        // 检查IP高频请求
        checkIpHighFrequency();
        
        // 检查业务类型高频请求
        checkBusinessHighFrequency();
    }
    
    private void checkUserHighFrequency() {
        // 获取高频用户列表
        List<UserFrequencyStat> highFrequencyUsers = getUserHighFrequencyUsers();
        
        for (UserFrequencyStat stat : highFrequencyUsers) {
            if (stat.getFrequency() > getAlertThreshold(stat.getUserId())) {
                // 发送告警
                Alert alert = Alert.builder()
                    .type(AlertType.HIGH_FREQUENCY)
                    .level(AlertLevel.WARNING)
                    .title("用户高频请求告警")
                    .content(String.format("用户 %s 请求频率过高: %d次/分钟", 
                         stat.getUserId(), stat.getFrequency()))
                    .timestamp(System.currentTimeMillis())
                    .build();
                
                alertService.sendAlert(alert);
                
                // 记录告警日志
                log.warn("用户高频请求告警: userId={}, frequency={}", 
                        stat.getUserId(), stat.getFrequency());
            }
        }
    }
    
    private void checkIpHighFrequency() {
        // 类似用户高频检查，针对IP地址
        List<IpFrequencyStat> highFrequencyIps = getIpHighFrequencyIps();
        
        for (IpFrequencyStat stat : highFrequencyIps) {
            if (stat.getFrequency() > IP_ALERT_THRESHOLD) {
                // 发送告警和自动防护
                handleHighFrequencyIp(stat.getIp(), stat.getFrequency());
            }
        }
    }
    
    private void handleHighFrequencyIp(String ip, int frequency) {
        // 发送告警
        Alert alert = Alert.builder()
            .type(AlertType.HIGH_FREQUENCY_IP)
            .level(AlertLevel.CRITICAL)
            .title("IP高频请求告警")
            .content(String.format("IP %s 请求频率过高: %d次/分钟", ip, frequency))
            .timestamp(System.currentTimeMillis())
            .build();
            
        alertService.sendAlert(alert);
        
        // 自动加入临时黑名单
        blacklistService.addToBlacklist(
            "system", 
            ip, 
            BlacklistType.IP, 
            "高频请求自动防护", 
            TimeUnit.HOURS.toMillis(1) // 1小时临时封禁
        );
        
        log.warn("IP高频请求自动防护: ip={}, frequency={}", ip, frequency);
    }
    
    // 异常模式检测
    @Scheduled(fixedRate = 300000) // 每5分钟检查一次
    public void checkAnomalyPatterns() {
        // 检查异常的请求模式
        List<AnomalyPattern> anomalies = detectAnomalyPatterns();
        
        for (AnomalyPattern anomaly : anomalies) {
            Alert alert = Alert.builder()
                .type(AlertType.ANOMALY_PATTERN)
                .level(AlertLevel.WARNING)
                .title("异常请求模式检测")
                .content(String.format("检测到异常请求模式: %s", anomaly.getDescription()))
                .timestamp(System.currentTimeMillis())
                .relatedData(anomaly.getRelatedData())
                .build();
                
            alertService.sendAlert(alert);
            
            log.warn("异常请求模式检测: {}", anomaly.getDescription());
        }
    }
}