ASP.NET Core中用户声明更新方法及自定义认证下权限实时同步方案咨询

嘿，这个问题确实很常见——当管理员修改用户权限后，总不能让用户每次都重新登录才能生效对吧？我来给你几个实用的解决方案，你可以根据自己的需求来选：

方案一：权限检查时结合缓存查询数据库（简单易实现） #

你一开始考虑的直接在PermissionCheckerAttribute里查数据库是可行的，但直接每次请求都查库肯定会有性能问题，所以咱们可以加一层缓存来优化。这样既保证权限能在缓存过期后更新，又能减少数据库压力。

修改后的权限检查类代码 #

首先，你需要一个权限服务（比如IPermissionService）来封装数据库查询逻辑，然后在Attribute里通过依赖注入获取这个服务和缓存服务：

public class PermissionCheckerAttribute : AuthorizeAttribute, IAuthorizationFilter
{
    private readonly string _permissionName;

    public PermissionCheckerAttribute(string permissionName)
    {
        _permissionName = permissionName;
    }

    public async void OnAuthorization(AuthorizationFilterContext context)
    {
        // 获取依赖服务
        var permissionService = context.HttpContext.RequestServices.GetService<IPermissionService>();
        var cache = context.HttpContext.RequestServices.GetService<IDistributedCache>();
        
        var userId = context.HttpContext.User.FindFirstValue(ClaimTypes.NameIdentifier);
        if (string.IsNullOrEmpty(userId))
        {
            context.Result = new RedirectResult("/Login");
            return;
        }

        var cacheKey = $"UserPermissions_{userId}";
        List<string> userPermissions;

        // 先从缓存取权限
        var cachedPermissions = await cache.GetStringAsync(cacheKey);
        if (string.IsNullOrEmpty(cachedPermissions))
        {
            // 缓存失效，从数据库拉取最新权限
            userPermissions = await permissionService.GetUserPermissionsAsync(userId);
            // 缓存5分钟（可以根据业务调整）
            await cache.SetStringAsync(cacheKey, JsonSerializer.Serialize(userPermissions), new DistributedCacheEntryOptions
            {
                AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5)
            });
        }
        else
        {
            userPermissions = JsonSerializer.Deserialize<List<string>>(cachedPermissions);
        }

        var hasPermission = userPermissions.Contains(_permissionName);
        if (!hasPermission)
        {
            context.Result = new RedirectResult("/AccessDenied");
        }
    }
}

优缺点 #

• ✅ 优点：实现简单，无需额外复杂逻辑，缓存过期后自动获取最新权限
• ❌ 缺点：缓存过期前权限更新不会立即生效，依然有一定的数据库访问频率

方案二：使用请求中间件定期刷新Claims（平衡实时性与性能） #

这个思路是在每次请求时，定期检查用户的权限是否有变化，如果有就更新Cookie中的Claims，这样用户不用重新登录就能拿到最新权限。

步骤1：编写刷新Claims的中间件 #

public class RefreshClaimsMiddleware
{
    private readonly RequestDelegate _next;

    public RefreshClaimsMiddleware(RequestDelegate next)
    {
        _next = next;
    }

    public async Task InvokeAsync(HttpContext context, IPermissionService permissionService, IDistributedCache cache)
    {
        // 仅对已认证用户处理
        if (context.User.Identity.IsAuthenticated)
        {
            var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
            var lastCheckCacheKey = $"LastClaimsRefresh_{userId}";
            
            // 每隔10分钟检查一次权限（可调整）
            var lastCheckTimeStr = await cache.GetStringAsync(lastCheckCacheKey);
            var needCheck = string.IsNullOrEmpty(lastCheckTimeStr) 
                || DateTime.Parse(lastCheckTimeStr) < DateTime.Now.AddMinutes(-10);

            if (needCheck)
            {
                // 获取数据库中最新的权限
                var latestPermissions = await permissionService.GetUserPermissionsAsync(userId);
                // 获取当前Claims中的权限
                var currentPermissions = context.User.Claims
                    .Where(c => c.Type == "permission")
                    .Select(c => c.Value)
                    .ToList();

                // 如果权限有差异，更新Claims
                if (!latestPermissions.SequenceEqual(currentPermissions))
                {
                    // 保留原有非权限类的Claims（比如用户名、用户ID等）
                    var newIdentity = new ClaimsIdentity(context.User.Identity.AuthenticationType);
                    newIdentity.AddClaims(context.User.Claims.Where(c => c.Type != "permission"));
                    
                    // 添加最新权限Claims
                    foreach (var perm in latestPermissions)
                    {
                        newIdentity.AddClaim(new Claim("permission", perm));
                    }

                    // 重新生成ClaimsPrincipal并更新Cookie
                    var newPrincipal = new ClaimsPrincipal(newIdentity);
                    await context.SignInAsync(
                        CookieAuthenticationDefaults.AuthenticationScheme, 
                        newPrincipal,
                        new AuthenticationProperties
                        {
                            IsPersistent = true,
                            ExpiresUtc = DateTimeOffset.UtcNow.AddDays(60)
                        });
                }

                // 更新最后检查时间的缓存
                await cache.SetStringAsync(lastCheckCacheKey, DateTime.Now.ToString(), new DistributedCacheEntryOptions
                {
                    AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(10)
                });
            }
        }

        // 继续处理后续请求
        await _next(context);
    }
}

步骤2：注册中间件 #

在Program.cs中，把这个中间件放在认证之后、授权之前：

app.UseAuthentication();
// 添加自定义刷新Claims中间件
app.UseMiddleware<RefreshClaimsMiddleware>();
app.UseAuthorization();

优缺点 #

• ✅ 优点：权限会定期自动刷新，用户无需重新登录，性能开销可控
• ❌ 缺点：权限更新不会实时生效，需要等待检查间隔结束

方案三：实时通知+Claims刷新（适合强实时需求） #

如果你的业务要求权限修改后立即生效，那可以结合SignalR或者一个“待更新权限用户列表”来实现：

思路说明 #

1. 当管理员修改用户权限时，把该用户的ID存入一个分布式集合（比如Redis的Set，多服务器环境推荐用Redis，单服务器可以用内存字典）
2. 在请求中间件里，检查当前用户ID是否在这个集合中：
   • 如果在，就立即查询数据库获取最新权限，更新Claims，然后从集合中移除该用户ID
   • 如果不在，就跳过处理

核心代码示例（用Redis集合） #

// 管理员修改权限时的代码
public async Task UpdateUserPermissions(int userId, List<string> newPermissions)
{
    // 先更新数据库权限
    await _dbContext.UserPermissions.Where(u => u.UserId == userId).ExecuteDeleteAsync();
    _dbContext.UserPermissions.AddRange(newPermissions.Select(p => new UserPermission { UserId = userId, Permission = p }));
    await _dbContext.SaveChangesAsync();

    // 将用户ID加入待刷新集合
    await _redis.SetAddAsync("PendingClaimsRefresh", userId.ToString());
}

// 中间件中检查并刷新
public async Task InvokeAsync(HttpContext context, IPermissionService permissionService, IDatabase redis)
{
    if (context.User.Identity.IsAuthenticated)
    {
        var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
        var isPending = await redis.SetContainsAsync("PendingClaimsRefresh", userId);
        
        if (isPending)
        {
            // 刷新Claims逻辑和方案二一致
            var latestPermissions = await permissionService.GetUserPermissionsAsync(int.Parse(userId));
            // ...更新ClaimsPrincipal和Cookie...
            
            // 从待刷新集合移除
            await redis.SetRemoveAsync("PendingClaimsRefresh", userId);
        }
    }

    await _next(context);
}

优缺点 #

• ✅ 优点：权限修改后几乎实时生效
• ❌ 缺点：需要额外引入Redis等分布式存储，实现复杂度较高

总结建议 #

• 如果对权限实时性要求不高，方案一最适合，简单易维护
• 如果需要一定的实时性且不想太复杂，方案二是平衡性能和体验的选择
• 如果业务要求权限立即生效，再考虑方案三

内容的提问来源于stack exchange，提问作者Saeed sheikhhosseini