拦截ASP.NET Core授权操作，实现成功授权后自定义逻辑

嘿，我来给你梳理下怎么搞定这个需求！其实有两种靠谱的实现方式，一种是自定义中间件，另一种是直接利用OAuth认证的内置事件，我都给你拆解清楚：

1. 方案一：自定义声明同步中间件 #

这种方式比较灵活，能在请求管道里自主控制逻辑，适合需要额外做其他登录后操作的场景。

中间件代码实现 #

首先写中间件类，还要配套一个扩展方法方便注册：

public class UserClaimSyncMiddleware
{
    private readonly RequestDelegate _next;
    private readonly ILogger<UserClaimSyncMiddleware> _logger;
    private readonly IUserClaimRepository _claimRepo; // 假设你已经有操作数据库的仓储接口

    public UserClaimSyncMiddleware(RequestDelegate next, ILogger<UserClaimSyncMiddleware> logger, IUserClaimRepository claimRepo)
    {
        _next = next;
        _logger = logger;
        _claimRepo = claimRepo;
    }

    public async Task InvokeAsync(HttpContext context)
    {
        // 先检查用户是否已认证，并且是本次会话首次登录（避免每次请求都重复写库）
        if (context.User.Identity.IsAuthenticated)
        {
            var hasSynced = context.Session.GetBoolean("ClaimsSynced");
            if (!hasSynced.HasValue || !hasSynced.Value)
            {
                try
                {
                    // 提取用户核心标识和所有声明
                    var userId = context.User.FindFirstValue(ClaimTypes.NameIdentifier);
                    var claimsToSave = context.User.Claims.Select(c => new UserClaimEntity
                    {
                        UserId = userId,
                        ClaimType = c.Type,
                        ClaimValue = c.Value,
                        CreatedAt = DateTime.UtcNow
                    }).ToList();

                    // 同步到数据库：建议先清旧数据再插入新的，或者做增量更新
                    await _claimRepo.SyncUserClaimsAsync(userId, claimsToSave);

                    // 标记会话已同步，后续请求不再执行
                    context.Session.SetBoolean("ClaimsSynced", true);
                    _logger.LogInformation($"成功同步用户 {userId} 的声明到数据库");
                }
                catch (Exception ex)
                {
                    _logger.LogError(ex, "同步用户声明到数据库失败");
                    // 这里别抛出异常，不然会影响用户正常使用，记录日志即可
                }
            }
        }

        // 继续执行后续中间件
        await _next(context);
    }
}

// 扩展方法，方便在Startup里快速注册
public static class UserClaimSyncMiddlewareExtensions
{
    public static IApplicationBuilder UseUserClaimSync(this IApplicationBuilder app)
    {
        return app.UseMiddleware<UserClaimSyncMiddleware>();
    }
}

2. 方案二：利用OAuth认证的OnTokenValidated事件 #

这种方式更精准，只有在OAuth令牌验证通过（也就是用户刚登录/授权成功）时才触发，不需要自己判断是否是新登录。

在Startup.ConfigureServices里配置 #

假设你用的是OpenID Connect认证，直接在配置里加事件处理：

public void ConfigureServices(IServiceCollection services)
{
    // 注册数据库仓储
    services.AddScoped<IUserClaimRepository, UserClaimRepository>();

    // 配置认证服务（以OpenID Connect为例）
    services.AddAuthentication(options =>
    {
        options.DefaultScheme = CookieAuthenticationDefaults.AuthenticationScheme;
        options.DefaultChallengeScheme = OpenIdConnectDefaults.AuthenticationScheme;
    })
    .AddCookie()
    .AddOpenIdConnect(options =>
    {
        options.ClientId = "你的客户端ID";
        options.ClientSecret = "你的客户端密钥";
        options.Authority = "你的OAuth服务器地址";
        options.ResponseType = "code";
        options.SaveTokens = true;
        // 配置需要获取的声明范围
        options.Scope.Add("openid");
        options.Scope.Add("profile");
        options.Scope.Add("email");

        // 重点：添加Token验证成功后的事件处理
        options.Events = new OpenIdConnectEvents
        {
            OnTokenValidated = async context =>
            {
                // 从请求服务中获取仓储实例
                var claimRepo = context.HttpContext.RequestServices.GetRequiredService<IUserClaimRepository>();
                var userId = context.Principal.FindFirstValue(ClaimTypes.NameIdentifier);
                
                // 转换声明为数据库实体
                var claims = context.Principal.Claims.Select(c => new UserClaimEntity
                {
                    UserId = userId,
                    ClaimType = c.Type,
                    ClaimValue = c.Value,
                    CreatedAt = DateTime.UtcNow
                }).ToList();

                // 写入数据库
                await claimRepo.SyncUserClaimsAsync(userId, claims);
                context.Logger.LogInformation($"通过OnTokenValidated同步用户 {userId} 的声明");
            }
        };
    });

    // 如果用方案一的中间件，需要添加会话服务
    services.AddSession(options =>
    {
        options.IdleTimeout = TimeSpan.FromMinutes(30);
        options.Cookie.HttpOnly = true;
        options.Cookie.IsEssential = true;
    });

    services.AddControllersWithViews();
}

3. 中间件管道配置（重要！） #

不管用哪种方案，都要注意中间件的顺序：

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    if (env.IsDevelopment())
    {
        app.UseDeveloperExceptionPage();
    }
    else
    {
        app.UseExceptionHandler("/Home/Error");
        app.UseHsts();
    }

    app.UseHttpsRedirection();
    app.UseStaticFiles();

    // 如果用方案一，必须在UseAuthentication之前加UseSession
    app.UseSession();

    app.UseRouting();

    // 认证中间件一定要先执行，这样才能拿到用户身份
    app.UseAuthentication();
    app.UseAuthorization();

    // 如果用方案一，在这里添加自定义中间件
    app.UseUserClaimSync();

    app.UseEndpoints(endpoints =>
    {
        endpoints.MapControllerRoute(
            name: "default",
            pattern: "{controller=Home}/{action=Index}/{id?}");
    });
}

关键注意点 #

• 避免重复写入：方案一用Session标记会话已同步，方案二的OnTokenValidated事件仅在令牌验证成功时触发一次，都能有效防止每次请求都执行写库操作。
• 异常容错处理：写入数据库的操作可能因网络或数据库问题失败，一定要做好日志记录，不要抛出异常中断用户的正常登录流程。
• 保证数据一致性：同步声明时建议使用数据库事务，比如先删除用户的旧声明，再插入新的声明集合，避免出现数据不一致的情况。
• 按需过滤声明：如果不需要OAuth服务器返回的所有声明，可以添加过滤逻辑，只保存业务场景需要的声明类型，减少数据库存储压力。

你可以根据自己的业务场景选方案，要是只需要处理声明同步，方案二更省心；要是还要加其他登录后操作，方案一更灵活。

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