如何在 ASP.NET Core 中仅在请求授权时使用自定义中间件？

Question

我在 ASP.NET Core 中开发了一个自定义中间件，但它会被每个请求触发。我的目的是仅在请求获得授权时才使用它。

Answer 1

更新：

我为您创建更多示例并编辑我的答案。如您所见，在

Next()

方法之前，我检查了每个令牌请求。如果

Authorization

请求的标头中没有

context

标记，则为

next()

，如果确实检查了令牌。

现在，您可能有一个问题，这是什么问题

await _next(context);

它非常复杂且冗长，我建议您访问此链接以了解这是什么问题。

要创建

Middlware

，您必须控制和

develop

。

1. 创建一般类作为

   Middleware

   工作一般行动就像你的行动

   Authorization

   。
2. 为

   static Extension class

   和

   Middleware

   之间的关系创建

   startup

   。
3. 最后

   Register

   在

   startup

   配置中。

现在这对您来说是很好的示例：

通用中间件：

public class RequestTokenMiddleware
    {
        private readonly RequestDelegate _next;
        private readonly SignInManager<User> _signInManager;

        public RequestTokenMiddleware(RequestDelegate next, SignInManager<User> signInManager)
        {
            _next = next;
            _signInManager = signInManager;
        }

        public async Task Invoke(HttpContext context)
        {
            try
            {
                var hasAuthorization = context.Request.Headers.ContainsKey("Authorization");
            if (!hasAuthorization)
            {
                await _next(context); 
            }
            else
            {
                var shouldBeNext = false;
                foreach (var item in context.Request.Headers)
                {
                    if (item.Key == "Authorization")
                    {
                        using (var contextBudget = BudgetUnitOfWork.Get())
                        {

                            var tokenCode = item.Value.ToString().Remove(0, 7);
                            var token = await contextBudget.Db.Token.FirstOrDefaultAsync(x => x.TokenCode == tokenCode).ConfigureAwait(false);
                            if (token == null || !token.IsValid)
                            {
                                signOut(context);
                            }
                            else
                            {
                                shouldBeNext = true;
                            }
                        }
                    }
                }
                if (shouldBeNext)
                {
                    await _next(context);
                }

            }
            }
            catch (Exception exc)
            {
                signOut(context);
            }
        }

        private async void signOut(HttpContext context)
        {
            try
            {
                await context.Response.WriteAsync(JsonConvert.SerializeObject(ResultModel.Failure(null, ResultModel.StatusType.InvalidToken)));
            }
            catch (Exception)
            {
                throw new Exception();
            }
        }
    }

这是关系的静态扩展类：

public static class ReuqestTokenMiddlewareExctention
    {
        public static IApplicationBuilder UseTokenValidator(this IApplicationBuilder applicationBuilder)
        {
            return applicationBuilder.UseMiddleware<RequestTokenMiddleware>();
        }
    }

现在注册您的

Middleware

启动：

public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory, IOptions<SetiaSettings> options)
{

     app.UseTokenValidator();
}

Answer 2

我相信你对中间件有误解。从根本上讲，中间件是将组装到应用程序管道中以管理每个请求和响应的软件。

这意味着每次都会执行中间件。

一个重要的概念是中间件如何处理每个组件。本质上是自上而下的执行，除非另有条件说明，否则所有允许的代码都将执行。

• 选择是否将请求传递到管道中的下一个组件。
• 可以在调用管道中的下一个组件之前和之后执行工作。

所以你早期的声明是你应该经历的行为，但现在你必须确保正在实例化的请求是否允许执行。您的安全方法基本上是在您的中间件中，允许进行授权。

一个例子是授权属性，但我不确定您正在使用什么授权/身份验证机制。

要明确回答您的问题，您可以按照以下路线：

做一些事情

public void ConfigureServices(IServiceCollection services)
{
    services.AddMvc();

    services.AddAuthorization(options =>
    {
        options.AddPolicy("RequireAdministratorRole", policy => policy.RequireRole("Administrator"));
    });
}

Answer 3

请参阅 github 上的自定义中间件https://github.com/Tanveer255/StudentManagmentSystem