MVC 5基于角色的权限授权实现方案咨询（ASP.NET Identity 2.0）

嘿，我刚好在MVC5 + ASP.NET Identity 2.0里做过类似的基于角色/权限的授权功能，给你分享一套完整的实现方案，完全符合你的需求——不用Session，权限存在数据库，还能避免重复查询：

我们会从基础角色授权入手，再扩展到细粒度权限控制，最后解决权限缓存的问题。

1. 基础角色授权（用原生Authorize特性） #

ASP.NET Identity 2.0自带了角色管理功能，如果你只需要粗粒度的角色控制（比如管理员、编辑、普通用户），直接用原生的[Authorize]特性就够了：

用法示例 #

// 限制整个控制器只能被Admin角色访问
[Authorize(Roles = "Admin")]
public class AdminController : Controller
{
    // 单独限制某个Action只能被Admin或Editor访问
    [Authorize(Roles = "Admin,Editor")]
    public ActionResult ManageUsers()
    {
        return View();
    }
}

角色分配 #

你可以在用户注册或后台管理时给用户分配角色：

// 给指定用户添加Admin角色
await UserManager.AddToRoleAsync(userId, "Admin");
// 移除角色
await UserManager.RemoveFromRoleAsync(userId, "Editor");

2. 扩展Identity实现细粒度权限控制 #

如果需要更精细的权限（比如CanCreateProduct、CanDeleteOrder这类具体操作权限），就需要扩展Identity的模型，把权限数据存在数据库里。

第一步：定义权限相关实体 #

首先创建数据库对应的实体类（假设你用Code First）：

// 权限表：存储所有可用权限
public class Permission
{
    public int Id { get; set; }
    public string Name { get; set; } // 权限唯一标识，比如"CanCreateProduct"
    public string Description { get; set; } // 权限描述，比如"允许创建商品"
}

// 角色-权限关联表：给角色分配权限
public class RolePermission
{
    public string RoleId { get; set; }
    public int PermissionId { get; set; }
    public virtual IdentityRole Role { get; set; }
    public virtual Permission Permission { get; set; }
}

// 用户-权限关联表：给单个用户直接分配权限（可选，根据你的业务需求）
public class UserPermission
{
    public string UserId { get; set; }
    public int PermissionId { get; set; }
    public virtual ApplicationUser User { get; set; }
    public virtual Permission Permission { get; set; }
}

然后在ApplicationDbContext中添加对应的DbSet：

public class ApplicationDbContext : IdentityDbContext<ApplicationUser>
{
    public ApplicationDbContext() : base("DefaultConnection", throwIfV1Schema: false) { }

    public DbSet<Permission> Permissions { get; set; }
    public DbSet<RolePermission> RolePermissions { get; set; }
    public DbSet<UserPermission> UserPermissions { get; set; }

    // 配置关联表的复合主键
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {
        base.OnModelCreating(modelBuilder);
        modelBuilder.Entity<RolePermission>()
            .HasKey(rp => new { rp.RoleId, rp.PermissionId });
        modelBuilder.Entity<UserPermission>()
            .HasKey(up => new { up.UserId, up.PermissionId });
    }
}

第二步：登录时将权限存入Claims #

ASP.NET Identity的认证票是加密存在Cookie里的，我们可以把用户的权限作为Claims添加到认证票中，这样每次请求都能直接从ClaimsPrincipal获取权限，不用反复查数据库。

修改AccountController的Login方法：

[HttpPost]
[AllowAnonymous]
[ValidateAntiForgeryToken]
public async Task<ActionResult> Login(LoginViewModel model, string returnUrl)
{
    if (!ModelState.IsValid)
    {
        return View(model);
    }

    var user = await UserManager.FindAsync(model.Email, model.Password);
    if (user != null)
    {
        // 获取用户的所有权限：角色权限+用户直接权限合并去重
        var userPermissions = await GetUserPermissionsAsync(user.Id);
        
        // 创建Identity认证对象
        var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
        
        // 将权限添加为Claims
        foreach (var perm in userPermissions)
        {
            identity.AddClaim(new Claim("Permission", perm.Name));
        }
        
        // 登录（将认证票写入Cookie）
        AuthenticationManager.SignIn(new AuthenticationProperties { IsPersistent = model.RememberMe }, identity);
        return RedirectToLocal(returnUrl);
    }
    
    ModelState.AddModelError("", "无效的用户名或密码");
    return View(model);
}

// 从数据库获取用户权限的方法
private async Task<List<Permission>> GetUserPermissionsAsync(string userId)
{
    // 获取用户所属角色的权限
    var rolePermissions = await db.RolePermissions
        .Include(rp => rp.Permission)
        .Where(rp => db.Roles.Any(r => r.Id == rp.RoleId && r.Users.Any(u => u.UserId == userId)))
        .Select(rp => rp.Permission)
        .ToListAsync();
    
    // 获取用户直接拥有的权限
    var directPermissions = await db.UserPermissions
        .Include(up => up.Permission)
        .Where(up => up.UserId == userId)
        .Select(up => up.Permission)
        .ToListAsync();
    
    // 合并去重
    return rolePermissions.Union(directPermissions).ToList();
}

3. 自定义PermissionAuthorize特性验证权限 #

原生的[Authorize]只支持角色验证，我们需要自定义一个特性来验证用户是否拥有指定权限：

public class PermissionAuthorizeAttribute : AuthorizeAttribute
{
    private readonly string[] _requiredPermissions;

    // 支持传入多个权限，满足其中一个即可
    public PermissionAuthorizeAttribute(params string[] requiredPermissions)
    {
        _requiredPermissions = requiredPermissions;
    }

    protected override bool AuthorizeCore(HttpContextBase httpContext)
    {
        // 先验证用户是否已登录
        if (!base.AuthorizeCore(httpContext))
        {
            return false;
        }

        // 从当前用户的Claims中检查是否有指定权限
        var user = httpContext.User as ClaimsPrincipal;
        return _requiredPermissions.Any(perm => user.HasClaim("Permission", perm));
    }

    protected override void HandleUnauthorizedRequest(AuthorizationContext filterContext)
    {
        if (filterContext.HttpContext.User.Identity.IsAuthenticated)
        {
            // 已登录但无权限，返回403禁止访问
            filterContext.Result = new HttpStatusCodeResult(HttpStatusCode.Forbidden);
        }
        else
        {
            // 未登录，跳转到登录页
            base.HandleUnauthorizedRequest(filterContext);
        }
    }
}

用法示例 #

// 限制只有拥有CanCreateProduct权限的用户才能访问
[PermissionAuthorize("CanCreateProduct")]
public ActionResult CreateProduct()
{
    return View();
}

// 拥有CanEditProduct或CanDeleteProduct权限即可访问
[PermissionAuthorize("CanEditProduct", "CanDeleteProduct")]
public ActionResult ManageProduct(int id)
{
    var product = db.Products.Find(id);
    return View(product);
}

4. 权限更新后的处理 #

因为权限存在Cookie的Claims中，当用户的权限在后台被修改后，需要让用户重新登录来更新Claims。如果你想更友好，可以在后台修改权限后主动清除用户的认证票：

// 在后台权限修改的代码中添加：
var authenticationManager = HttpContext.GetOwinContext().Authentication;
authenticationManager.SignOut(DefaultAuthenticationTypes.ApplicationCookie);
// 提示用户重新登录即可

5. 进阶：内存缓存优化权限查询（可选） #

如果担心登录时查询数据库的性能，可以把用户权限缓存到内存中，避免重复查询：

private async Task<List<Permission>> GetUserPermissionsAsync(string userId)
{
    var cacheKey = $"UserPermissions_{userId}";
    var cache = MemoryCache.Default;
    
    // 先查缓存
    if (cache.Contains(cacheKey))
    {
        return cache[cacheKey] as List<Permission>;
    }
    
    // 缓存不存在时查数据库
    var rolePermissions = await db.RolePermissions
        .Include(rp => rp.Permission)
        .Where(rp => db.Roles.Any(r => r.Id == rp.RoleId && r.Users.Any(u => u.UserId == userId)))
        .Select(rp => rp.Permission)
        .ToListAsync();
    
    var directPermissions = await db.UserPermissions
        .Include(up => up.Permission)
        .Where(up => up.UserId == userId)
        .Select(up => up.Permission)
        .ToListAsync();
    
    var permissions = rolePermissions.Union(directPermissions).ToList();
    
    // 缓存1小时，可根据业务调整过期时间
    cache.Add(cacheKey, permissions, DateTimeOffset.Now.AddHours(1));
    
    return permissions;
}

当后台修改用户权限时，记得清除对应的缓存：

var cacheKey = $"UserPermissions_{userId}";
MemoryCache.Default.Remove(cacheKey);

内容的提问来源于stack exchange，提问作者waqas baig