一、问题背景：权限缓存的"脏数据"困境

你是否遇到过这样的场景：

1. 管理员在后台修改了某个用户的角色权限
2. 用户重新登录后发现权限没有变化
3. 只有重启服务或等待缓存过期，权限才会生效

这就是典型的权限缓存一致性问题。为了提高系统性能，我们通常会将用户权限信息缓存到本地，但当管理员修改权限后，其他节点的缓存并不会自动更新，导致用户获取到过期的权限数据。

真实案例：某电商平台在大促期间，管理员紧急调整了部分运营人员的权限，但由于缓存未及时刷新，导致权限变更延迟生效，影响了订单处理效率。

二、核心概念：缓存一致性模型

2.1 缓存更新策略对比

2.2 事件总线架构

┌──────────────────────────────────────────────────────────────────┐
│                     事件总线架构图                               │
├──────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌──────────────┐                                              │
│  │  管理员操作  │                                              │
│  └──────┬───────┘                                              │
│         │ 修改权限                                               │
│         ▼                                                       │
│  ┌──────────────┐    发布事件    ┌──────────────┐              │
│  │ 权限服务     │──────────────►│  事件总线     │              │
│  │ (更新DB)     │               │  (MQ/Kafka)  │              │
│  └──────────────┘               └──────┬───────┘              │
│                                        │                        │
│          ┌─────────────────────────────┼─────────────────────┐  │
│          │                             │                     │  │
│          ▼                             ▼                     ▼  │
│  ┌──────────────┐           ┌──────────────┐      ┌──────────────┐│
│  │  节点A       │           │   节点B      │      │   节点C      ││
│  │  清除缓存    │           │  清除缓存    │      │  清除缓存    ││
│  └──────────────┘           └──────────────┘      └──────────────┘│
│                                                                 │
└──────────────────────────────────────────────────────────────────┘

三、实现方案：事件总线广播 + 本地缓存失效

3.1 方案架构设计

┌──────────────────────────────────────────────────────────────────┐
│                    权限缓存一致性架构                            │
├──────────────────────────────────────────────────────────────────┤
│                                                                 │
│  ┌───────────────────────────────────────────────────────────┐  │
│  │                    事件生产者                              │  │
│  │  ┌─────────────┐    ┌─────────────┐    ┌─────────────┐   │  │
│  │  │ 角色变更    │    │ 用户权限    │    │ 权限规则    │   │  │
│  │  │ 事件        │    │ 变更事件    │    │ 变更事件    │   │  │
│  │  └──────┬──────┘    └──────┬──────┘    └──────┬──────┘   │  │
│  └─────────┼──────────────────┼──────────────────┼───────────┘  │
│            │                  │                  │               │
│            ▼                  ▼                  ▼               │
│  ┌───────────────────────────────────────────────────────────┐  │
│  │                   事件总线 (Redis Pub/Sub)                │  │
│  └───────────────────────────────────────────────────────────┘  │
│                              │                                  │
│          ┌───────────────────┼───────────────────┐              │
│          │                   │                   │              │
│          ▼                   ▼                   ▼              │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐     │
│  │   事件消费者  │    │   事件消费者  │    │   事件消费者  │     │
│  │  (节点A)     │    │  (节点B)     │    │  (节点C)     │     │
│  └──────┬───────┘    └──────┬───────┘    └──────┬───────┘     │
│         │                   │                   │               │
│         ▼                   ▼                   ▼               │
│  ┌──────────────┐    ┌──────────────┐    ┌──────────────┐     │
│  │  本地缓存    │    │  本地缓存    │    │  本地缓存    │     │
│  │  失效处理    │    │  失效处理    │    │  失效处理    │     │
│  └──────────────┘    └──────────────┘    └──────────────┘     │
└──────────────────────────────────────────────────────────────────┘

3.2 事件定义

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class PermissionEvent {
    
    /**
     * 事件类型
     */
    private EventType eventType;
    
    /**
     * 目标用户ID（可为空，表示全部用户）
     */
    private Long userId;
    
    /**
     * 目标角色ID（可为空，表示全部角色）
     */
    private Long roleId;
    
    /**
     * 事件时间戳
     */
    private Long timestamp;
    
    /**
     * 操作类型枚举
     */
    public enum EventType {
        ROLE_CREATED,
        ROLE_UPDATED,
        ROLE_DELETED,
        USER_ROLE_ASSIGNED,
        USER_ROLE_REMOVED,
        PERMISSION_UPDATED,
        CACHE_CLEAR_ALL
    }
}

3.3 事件生产者

@Component
@Slf4j
public class PermissionEventProducer {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    /**
     * Redis Pub/Sub 频道名称
     */
    private static final String CHANNEL_NAME = "permission-events";
    
    /**
     * 发布角色变更事件
     */
    public void publishRoleEvent(PermissionEvent.EventType eventType, Long roleId) {
        PermissionEvent event = PermissionEvent.builder()
            .eventType(eventType)
            .roleId(roleId)
            .timestamp(System.currentTimeMillis())
            .build();
        
        publishEvent(event);
        log.info("Published role event: {} for roleId: {}", eventType, roleId);
    }
    
    /**
     * 发布用户角色变更事件
     */
    public void publishUserRoleEvent(PermissionEvent.EventType eventType, Long userId, Long roleId) {
        PermissionEvent event = PermissionEvent.builder()
            .eventType(eventType)
            .userId(userId)
            .roleId(roleId)
            .timestamp(System.currentTimeMillis())
            .build();
        
        publishEvent(event);
        log.info("Published user-role event: {} for userId: {}, roleId: {}", 
            eventType, userId, roleId);
    }
    
    /**
     * 发布权限规则变更事件
     */
    public void publishPermissionEvent(PermissionEvent.EventType eventType) {
        PermissionEvent event = PermissionEvent.builder()
            .eventType(eventType)
            .timestamp(System.currentTimeMillis())
            .build();
        
        publishEvent(event);
        log.info("Published permission event: {}", eventType);
    }
    
    /**
     * 发布缓存清除事件
     */
    public void publishCacheClearEvent(Long userId) {
        PermissionEvent event = PermissionEvent.builder()
            .eventType(PermissionEvent.EventType.CACHE_CLEAR_ALL)
            .userId(userId)
            .timestamp(System.currentTimeMillis())
            .build();
        
        publishEvent(event);
        log.info("Published cache clear event for userId: {}", userId);
    }
    
    private void publishEvent(PermissionEvent event) {
        try {
            String json = objectMapper.writeValueAsString(event);
            redisTemplate.convertAndSend(CHANNEL_NAME, json);
        } catch (JsonProcessingException e) {
            log.error("Failed to serialize permission event", e);
            throw new RuntimeException("Failed to publish permission event", e);
        }
    }
    
    @Autowired
    private ObjectMapper objectMapper;
}

3.4 事件消费者

@Component
@Slf4j
public class PermissionEventConsumer {
    
    @Autowired
    private PermissionCacheManager cacheManager;
    
    /**
     * 订阅权限事件
     */
    @EventListener
    public void handlePermissionEvent(PermissionEvent event) {
        log.info("Received permission event: {}", event.getEventType());
        
        switch (event.getEventType()) {
            case ROLE_CREATED:
            case ROLE_UPDATED:
                // 清除该角色相关的所有用户缓存
                cacheManager.invalidateByRoleId(event.getRoleId());
                break;
                
            case ROLE_DELETED:
                // 清除该角色相关的所有用户缓存
                cacheManager.invalidateByRoleId(event.getRoleId());
                break;
                
            case USER_ROLE_ASSIGNED:
            case USER_ROLE_REMOVED:
                // 清除特定用户的缓存
                cacheManager.invalidateByUserId(event.getUserId());
                break;
                
            case PERMISSION_UPDATED:
                // 清除所有权限缓存
                cacheManager.invalidateAll();
                break;
                
            case CACHE_CLEAR_ALL:
                if (event.getUserId() != null) {
                    // 清除特定用户缓存
                    cacheManager.invalidateByUserId(event.getUserId());
                } else {
                    // 清除所有缓存
                    cacheManager.invalidateAll();
                }
                break;
                
            default:
                log.warn("Unknown event type: {}", event.getEventType());
        }
    }
}

3.5 Redis 消息监听器配置

@Configuration
public class RedisMessageListenerConfig {
    
    @Autowired
    private ObjectMapper objectMapper;
    
    /**
     * 注册消息监听器
     */
    @Bean
    public MessageListenerAdapter messageListenerAdapter(PermissionEventConsumer consumer) {
        return new MessageListenerAdapter(new RedisMessageListener(consumer, objectMapper));
    }
    
    /**
     * 注册消息容器
     */
    @Bean
    public RedisMessageListenerContainer container(RedisConnectionFactory connectionFactory,
                                                  MessageListenerAdapter listenerAdapter) {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(listenerAdapter, new PatternTopic("permission-events"));
        return container;
    }
}

/**
 * Redis 消息监听器
 */
public class RedisMessageListener {
    
    private final PermissionEventConsumer consumer;
    private final ObjectMapper objectMapper;
    
    public RedisMessageListener(PermissionEventConsumer consumer, ObjectMapper objectMapper) {
        this.consumer = consumer;
        this.objectMapper = objectMapper;
    }
    
    public void onMessage(byte[] message, byte[] pattern) {
        try {
            String json = new String(message, StandardCharsets.UTF_8);
            PermissionEvent event = objectMapper.readValue(json, PermissionEvent.class);
            consumer.handlePermissionEvent(event);
        } catch (JsonProcessingException e) {
            log.error("Failed to deserialize permission event", e);
        }
    }
}

3.6 权限缓存管理器

@Component
@Slf4j
public class PermissionCacheManager {
    
    /**
     * 权限缓存（用户ID -> 权限列表）
     */
    private final ConcurrentHashMap<Long, Set<String>> permissionCache = new ConcurrentHashMap<>();
    
    /**
     * 用户角色缓存（用户ID -> 角色列表）
     */
    private final ConcurrentHashMap<Long, Set<String>> roleCache = new ConcurrentHashMap<>();
    
    /**
     * 角色权限缓存（角色ID -> 权限列表）
     */
    private final ConcurrentHashMap<Long, Set<String>> rolePermissionCache = new ConcurrentHashMap<>();
    
    /**
     * 用户ID到角色ID的映射（用于批量失效）
     */
    private final ConcurrentHashMap<Long, Set<Long>> userRoleMapping = new ConcurrentHashMap<>();
    
    /**
     * 获取用户权限
     */
    public Set<String> getUserPermissions(Long userId) {
        return permissionCache.computeIfAbsent(userId, this::loadUserPermissions);
    }
    
    /**
     * 获取用户角色
     */
    public Set<String> getUserRoles(Long userId) {
        return roleCache.computeIfAbsent(userId, this::loadUserRoles);
    }
    
    /**
     * 根据用户ID失效缓存
     */
    public void invalidateByUserId(Long userId) {
        permissionCache.remove(userId);
        roleCache.remove(userId);
        
        // 清理用户角色映射
        Set<Long> roleIds = userRoleMapping.remove(userId);
        if (roleIds != null) {
            log.info("Invalidated cache for userId: {}, affected roles: {}", userId, roleIds);
        } else {
            log.info("Invalidated cache for userId: {}", userId);
        }
    }
    
    /**
     * 根据角色ID失效缓存
     */
    public void invalidateByRoleId(Long roleId) {
        // 找到所有关联该角色的用户并失效
        List<Long> affectedUsers = userRoleMapping.entrySet().stream()
            .filter(entry -> entry.getValue().contains(roleId))
            .map(Map.Entry::getKey)
            .collect(Collectors.toList());
        
        affectedUsers.forEach(this::invalidateByUserId);
        rolePermissionCache.remove(roleId);
        
        log.info("Invalidated cache for roleId: {}, affected users: {}", roleId, affectedUsers.size());
    }
    
    /**
     * 失效所有缓存
     */
    public void invalidateAll() {
        permissionCache.clear();
        roleCache.clear();
        rolePermissionCache.clear();
        userRoleMapping.clear();
        
        log.info("Invalidated all permission caches");
    }
    
    /**
     * 加载用户权限（从数据库）
     */
    private Set<String> loadUserPermissions(Long userId) {
        // 实际实现中从数据库查询
        log.debug("Loading permissions for userId: {}", userId);
        return new HashSet<>();
    }
    
    /**
     * 加载用户角色（从数据库）
     */
    private Set<String> loadUserRoles(Long userId) {
        // 实际实现中从数据库查询
        log.debug("Loading roles for userId: {}", userId);
        return new HashSet<>();
    }
    
    /**
     * 更新用户角色映射
     */
    public void updateUserRoleMapping(Long userId, Set<Long> roleIds) {
        userRoleMapping.put(userId, roleIds);
    }
}

3.7 权限服务

@Service
@Slf4j
public class PermissionService {
    
    @Autowired
    private PermissionEventProducer eventProducer;
    
    @Autowired
    private PermissionCacheManager cacheManager;
    
    @Autowired
    private RoleRepository roleRepository;
    
    @Autowired
    private UserRoleRepository userRoleRepository;
    
    /**
     * 分配角色给用户
     */
    @Transactional
    public void assignRoleToUser(Long userId, Long roleId) {
        // 检查角色是否存在
        Role role = roleRepository.findById(roleId)
            .orElseThrow(() -> new IllegalArgumentException("Role not found"));
        
        // 检查是否已存在
        if (userRoleRepository.existsByUserIdAndRoleId(userId, roleId)) {
            return;
        }
        
        // 创建用户角色关联
        UserRole userRole = UserRole.builder()
            .userId(userId)
            .roleId(roleId)
            .build();
        userRoleRepository.save(userRole);
        
        // 更新本地缓存映射
        cacheManager.updateUserRoleMapping(userId, 
            userRoleRepository.findRoleIdsByUserId(userId));
        
        // 发布事件
        eventProducer.publishUserRoleEvent(
            PermissionEvent.EventType.USER_ROLE_ASSIGNED, userId, roleId);
        
        log.info("Assigned role {} to user {}", roleId, userId);
    }
    
    /**
     * 从用户移除角色
     */
    @Transactional
    public void removeRoleFromUser(Long userId, Long roleId) {
        userRoleRepository.deleteByUserIdAndRoleId(userId, roleId);
        
        // 更新本地缓存映射
        cacheManager.updateUserRoleMapping(userId,
            userRoleRepository.findRoleIdsByUserId(userId));
        
        // 发布事件
        eventProducer.publishUserRoleEvent(
            PermissionEvent.EventType.USER_ROLE_REMOVED, userId, roleId);
        
        log.info("Removed role {} from user {}", roleId, userId);
    }
    
    /**
     * 更新角色权限
     */
    @Transactional
    public void updateRolePermissions(Long roleId, Set<String> permissions) {
        Role role = roleRepository.findById(roleId)
            .orElseThrow(() -> new IllegalArgumentException("Role not found"));
        
        role.setPermissions(permissions);
        roleRepository.save(role);
        
        // 发布事件
        eventProducer.publishRoleEvent(PermissionEvent.EventType.ROLE_UPDATED, roleId);
        
        log.info("Updated permissions for role {}", roleId);
    }
}

3.8 权限拦截器

@Component
@Slf4j
public class PermissionInterceptor implements HandlerInterceptor {
    
    @Autowired
    private PermissionCacheManager cacheManager;
    
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, 
                           Object handler) throws Exception {
        
        // 获取当前用户ID（从JWT Token中解析）
        Long userId = getCurrentUserId(request);
        if (userId == null) {
            response.setStatus(HttpServletResponse.SC_UNAUTHORIZED);
            return false;
        }
        
        // 获取请求需要的权限
        String requiredPermission = getRequiredPermission(request);
        if (requiredPermission == null) {
            return true; // 无需权限检查
        }
        
        // 检查用户是否拥有该权限
        Set<String> userPermissions = cacheManager.getUserPermissions(userId);
        if (!userPermissions.contains(requiredPermission)) {
            log.warn("User {} does not have permission: {}", userId, requiredPermission);
            response.setStatus(HttpServletResponse.SC_FORBIDDEN);
            return false;
        }
        
        return true;
    }
    
    private Long getCurrentUserId(HttpServletRequest request) {
        // 实际实现中从Token解析
        String userIdStr = request.getHeader("X-User-Id");
        return userIdStr != null ? Long.parseLong(userIdStr) : null;
    }
    
    private String getRequiredPermission(HttpServletRequest request) {
        // 根据请求路径和方法获取需要的权限
        // 实际实现中可以通过注解或配置获取
        return null;
    }
}

四、配置文件示例

server:
  port: 8080

spring:
  application:
    name: permission-cache-demo
  data:
    redis:
      host: localhost
      port: 6379
      timeout: 6000ms

# 缓存配置
cache:
  permission:
    ttl-minutes: 60
    max-size: 10000

# 事件总线配置
event:
  bus:
    enabled: true
    channel: permission-events

logging:
  level:
    com.example.permission: DEBUG

五、监控与告警

5.1 缓存监控指标

@Component
public class PermissionCacheMetrics {
    
    private final MeterRegistry meterRegistry;
    private final PermissionCacheManager cacheManager;
    
    public PermissionCacheMetrics(MeterRegistry meterRegistry, 
                                 PermissionCacheManager cacheManager) {
        this.meterRegistry = meterRegistry;
        this.cacheManager = cacheManager;
        registerMetrics();
    }
    
    private void registerMetrics() {
        // 缓存大小
        Gauge.builder("permission.cache.size", 
            () -> cacheManager.getCacheSize())
            .register(meterRegistry);
        
        // 缓存命中率
        Counter.builder("permission.cache.hits")
            .register(meterRegistry);
        
        Counter.builder("permission.cache.misses")
            .register(meterRegistry);
        
        // 缓存失效次数
        Counter.builder("permission.cache.invalidations")
            .tag("type", "user")
            .register(meterRegistry);
        
        Counter.builder("permission.cache.invalidations")
            .tag("type", "role")
            .register(meterRegistry);
        
        // 事件处理指标
        Counter.builder("permission.event.received")
            .register(meterRegistry);
        
        Counter.builder("permission.event.processed")
            .register(meterRegistry);
    }
}

5.2 Prometheus 告警规则

groups:
- name: permission_cache_alerts
  rules:
  - alert: PermissionCacheMissRateHigh
    expr: rate(permission_cache_misses_total[5m]) / rate(permission_cache_hits_total[5m] + permission_cache_misses_total[5m]) > 0.3
    for: 5m
    labels:
      severity: warning
    annotations:
      summary: "权限缓存命中率低"
      description: "缓存命中率低于70%"
  
  - alert: PermissionEventProcessingError
    expr: permission_event_received_total - permission_event_processed_total > 0
    for: 1m
    labels:
      severity: critical
    annotations:
      summary: "权限事件处理失败"
      description: "有未处理的权限事件"
  
  - alert: PermissionCacheSizeExceeded
    expr: permission_cache_size > 10000
    for: 10m
    labels:
      severity: warning
    annotations:
      summary: "权限缓存过大"
      description: "缓存大小超过10000"

六、最佳实践建议

6.1 缓存策略建议

6.2 注意事项

1. 事件可靠性：使用 Kafka 或 RabbitMQ 替代 Redis Pub/Sub 以保证消息可靠性
2. 幂等性设计：事件处理需要支持幂等，避免重复处理
3. 事件顺序：确保事件按正确顺序处理
4. 本地缓存大小：设置合理的缓存上限，避免内存溢出
5. 监控告警：监控缓存命中率和事件处理情况

6.3 性能优化

1. 批量失效：多个用户关联同一角色时，批量失效
2. 异步加载：缓存未命中时异步加载，返回旧数据
3. 缓存预热：系统启动时预加载热点数据
4. 分片缓存：按用户ID分片，减少锁竞争

互动话题

您在权限管理中遇到过缓存一致性问题吗？您是如何解决的？欢迎在评论区分享您的经验！