AOP（Aspect Oriented Programming），即面向切面编程。可以在不修改之前的代码为基础，动态增加新功能。.NET5中提供了5种AOP的Filter，分别是
- ActionFilter（方法）
- ResourceFilter（资源）
- ExceptionFilter（异常）
- ResultFilter（结果）
- AuthorizationFilter（鉴权授权）
1. ActionFilter
ActionFilter在方法的执行前后可执行相应操作。
1.1 ActionFilter基本使用
(1) 自定义一个CustomActionFilterAttribute，并且继承Attribute，实现IActionFilter的OnActionExecuting和 OnActionExecuted方法。OnActionExecuting在方法执行前执行，OnActionExecuted在方法执行后执行。
public class CustomActionFilterAttribute : Attribute, IActionFilter
{
public void OnActionExecuting(ActionExecutingContext context)
{
Console.WriteLine("执行OnActionExecuting");
}
public void OnActionExecuted(ActionExecutedContext context)
{
Console.WriteLine("执行OnActionExecuted");
}
}
(2) 在Controller的方法上添加特性标记。
public class HomeController : Controller
{
private readonly ILogger _logger;
public HomeController(ILogger logger)
{
_logger = logger;
}
[CustomActionFilter]
public IActionResult Index()
{
Console.WriteLine("执行控制器中的Index");
return View();
}
// ...
}
}
打印的结果为：
执行OnActionExecuting
执行控制器中的Index
执行OnActionExecuted
1.2 ActionFilter的多种使用
除上述来使用ActionFilter，也可通过继承ActionFilterAttribute（系统提供的实现），根据自己的需要，覆写不同的方法，达到自己的诉求。
public class CustomActionFilterSystemAttribute : ActionFilterAttribute
{
public override void OnActionExecuting(ActionExecutingContext context)
{
Console.WriteLine("执行OnActionExecuting");
}
public override void OnActionExecuted(ActionExecutedContext context)
{
Console.WriteLine("执行OnActionExecuted");
}
}
异步版本的实现，通过实现IAsyncActionFilter接口来实现。
public class CustomActionFilterAsyncAttribute : Attribute, IAsyncActionFilter
{
public Task OnActionExecutionAsync(ActionExecutingContext context, ActionExecutionDelegate next)
{
return Task.Run(() => {
Console.WriteLine("执行OnActionExecutionAsync");
});
}
}
1.3 ActionFilter的应用
可以用来记录日志，通过log4net将日志写入文件，ILogger依赖注入。当构造函数有了参数后控制器方法上的[CustomActionFilter]特性就不能这么写了，应该写为[TypeFilter(typeof(CustomActionFilterAttribute))].
public class CustomActionFilterAttribute : Attribute, IActionFilter
{
private ILogger _logger = null;
public CustomActionFilterAttribute(ILogger logger)
{
_logger = logger;
}
public void OnActionExecuting(ActionExecutingContext context)
{
_logger.LogInformation(JsonConvert.SerializeObject(context.HttpContext.Request.Query));
_logger.LogInformation("执行CustomActionFilterAttribute.OnActionExecuting");
}
public void OnActionExecuted(ActionExecutedContext context)
{
_logger.LogInformation(JsonConvert.SerializeObject(context.Result));
_logger.LogInformation("执行CustomActionFilterAttribute.OnActionExecuted");
}
}
1.4 ActionFilter的多种注册
（1）[CustomActionFilter]---Fitler必须有无参数构造函数。
（2）[TypeFilter(typeof(CustomActionFilterAttribute))]，可以没有无参数构造函数，可以支持依赖注入。
（3）[ServiceFilter(typeof(CustomActionFilterAttribute))]，可以没有无参数构造函数，可以支持依赖注入，但是必须要注册服务。
1.5 FilterFactory扩展定制
为什么写上TypeFilter这样的特性就可以支持依赖注入呢？它是由IOC容器来完成的。
（1）现在我们自定义一个特性类CustomFilterFactory，继承Attribute,实现接口IFilterFactory，并实现接口中的方法。
public class CustomFilterFactory : Attribute, IFilterFactory
{
private readonly Type _type = null;
public bool IsReusable => true;
public CustomFilterFactory(Type type)
{
_type = type;
}
public IFilterMetadata CreateInstance(IServiceProvider serviceProvider)
{
object oInstance = serviceProvider.GetService(_type);
return (IFilterMetadata)oInstance;
}
}
（2）在Startup类的ConfigureServices中注册。
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews();
services.AddTransient();
}
（3）最后再将 [CustomFilterFactory(typeof(CustomActionFilterAttribute))]标记到控制器的Action方法上就行了，和[TypeFilter(typeof(CustomActionFilterAttribute))]效果一样。
1.6 Filter的生效范围
- 标记在Action上，就只对当前Action生效。
- 标记在Controller上，就对Controller上中的所有Action生效。
- 全局注册，对于当前整个项目中的Action都生效，在ConfigureServices中增加以下代码即可
services.AddMvc(option =>
{
option.Filters.Add(); //全局注册：
});
1.7 Filter的执行顺序
如果定义三个actionFilter，分别注册全局，控制器、Action;执行顺序如何呢？
<1> 控制器实例化
<2> 全局注册的Filter - OnActionExecuting
<3> 控制器注册的Filter - OnActionExecuting
<4> Actioin注册的Filter - OnActionExecuting
<5> 执行Action内部的逻辑
<6> Action注册的Filter - OnActionExecuted
<7> 控制器注册的Filter - OnActionExecuted
<8> 全局注册的Filter - OnActionExecuted
如果想要改变执行顺序，需要在注册Filter的时候，指定Order的值，执行顺序会按照值从小到大执行。例如在方法上添加[CustomActionActionFilterAtrribute(Order = -1)]，不添加则Order值为0。
1.8 Filter匿名
如果全局注册，Filter生效于所有的Acion，如果有部分Action我希望不生效怎么办呢？这就需要匿名，可以避开Filter的检查。
下面自定义Filter匿名。
（1）自定义一个特性类CustomAllowAnonymousAttributet，将[CustomAllowAnonymous]特性添加到需要避开的方法上。
（2）在需要匿名的Filter内部，检查是否需要匿名（检查是否标记的有匿名特性）,如果有就直接避开。
public void OnActionExecuting(ActionExecutingContext context)
{
if(context.ActionDescriptor.EndpointMetadata.Any(item=>item.GetType() == typeof(CustomAllowAnonymousAttribute)))
{
return;
}
// ......
}
2. ResourceFilter
ResourceFilter就是为了缓存而存在的。
public class CustomResourceFilterAttribute : Attribute, IResourceFilter
{
private static Dictionary CacheDictionary = new Dictionary();
public void OnResourceExecuting(ResourceExecutingContext context)
{
//在这里就判断是否有缓存，只要是key 不变，缓存就不变
string key = context.HttpContext.Request.Path;
if (CacheDictionary.Any(item => item.Key == key))
{
//断路器，只要是对Result赋值，就不继续往后走了；
context.Result = CacheDictionary[key] as IActionResult;
}
Console.WriteLine("执行OnResourceExecuting");
}
public void OnResourceExecuted(ResourceExecutedContext context)
{
string key = context.HttpContext.Request.Path;
CacheDictionary[key] = context.Result;
Console.WriteLine("执行OnResourceExecuted");
}
}
[CustomResourceFilter]
public IActionResult IndexResource()
{
ViewBag.Date = DateTime.Now;
return View();
}
3. ExceptionFilter
ExceptionFilter用来处理异常。
（1）自定义一个CustomExceptionFilterAttribute ,实现IExceptionFilter接口。
（2）实现方法，先判断，异常是否被处理过，如果没有被处理过，就处理。如果是ajax请求，就返回JosnResult，如果不是Ajax请求，就返回错误页面。
（3）全局注册使用（和之前的ActionFilter全局注册一样）。
public class CustomExceptionFilterAttribute : Attribute, IExceptionFilter
{
private IModelMetadataProvider _modelMetadataProvider = null;
public CustomExceptionFilterAttribute(IModelMetadataProvider modelMetadataProvider)
{
_modelMetadataProvider = modelMetadataProvider;
}
public void OnException(ExceptionContext context)
{
if (!context.ExceptionHandled) //异常是否被处理过
{
//在这里处理 如果是Ajax请求===返回Json
if (this.IsAjaxRequest(context.HttpContext.Request))//header看看是不是XMLHttpRequest
{
context.Result = new JsonResult(new
{
Result = false,
Msg = context.Exception.Message
});//中断式---请求到这里结束了，不再继续Action
}
else
{
//跳转到异常页面
var result = new ViewResult { ViewName = "~/Views/Shared/Error.cshtml" };
result.ViewData = new ViewDataDictionary(_modelMetadataProvider, context.ModelState);
result.ViewData.Add("Exception", context.Exception);
context.Result = result; //断路器---只要对Result赋值--就不继续往后了；
}
context.ExceptionHandled = true;
}
}
private bool IsAjaxRequest(HttpRequest request)
{
string header = request.Headers["X-Requested-With"];
return "XMLHttpRequest".Equals(header);
}
}
ExceptionFilter能捕捉到哪些异常？
- 控制器实例化异常 [True]
- 异常发生在Try-cache中 [False]
- 在视图中发生异常 [False]
- Service层发生异常 [True]
- 在Action中发生异常 [True]
- 请求错误路径异常 [True] 可以使用中间件来支持，只要不是200的状态，就都可以处理。
4. ResultFilter
ResultFilter在return 返回时调用。
它的应用，比如双语言系统，其实就需要两个视图根据语言的不同，来选择不同的视图来渲染。因为在渲染视图之前，会进入到OnResultExecuting方法，就可以在这个方法中确定究竟使用哪一个视图文件。
（1）自定义一个类，继承Attribute,实现IResultFilter接口，实现方法
（2）标记在Action方法头上
（3）执行顺序：视图执行前，渲染视图，视图执行后
public class CustomResultFilterAttribute : Attribute, IResultFilter
{
private IModelMetadataProvider _modelMetadataProvider = null;
public CustomResultFilterAttribute(IModelMetadataProvider modelMetadataProvider)
{
_modelMetadataProvider = modelMetadataProvider;
}
///
/// 渲染视图之前执行
///
///
public void OnResultExecuting(ResultExecutingContext context)
{
//在这里就可以有一个判断，符合某个情况，就使用哪一个视图；
Console.WriteLine("渲染视图之前执行");
string view = context.HttpContext.Request.Query["View"];//也可以是配置文件
if (view == "1") //中文
{
var result = new ViewResult { ViewName = "~/Views/Seventh/IndexOne.cshtml" };
result.ViewData = new ViewDataDictionary(_modelMetadataProvider, context.ModelState);
context.Result = result;
}
else
{
var result = new ViewResult { ViewName = "~/Views/Seventh/IndexOne-2.cshtml" };
result.ViewData = new ViewDataDictionary(_modelMetadataProvider, context.ModelState);
context.Result = result;
}
}
///
/// 渲染视图之后执行
///
///
public void OnResultExecuted(ResultExecutedContext context)
{
Console.WriteLine("渲染视图之后执行");
}
}
5. AuthorizationFilter
AuthorizationFilter用来做鉴权授权。通过中间件来支持。
5.1 鉴权授权
（1）在Startup中方法Configure的app.UseRouting()之后，在app.UseEndpoints()之前，增加鉴权授权。 鉴权app.UseAuthentication(),授权app.UseAuthorization()。
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, ILoggerFactory loggerFactory)
{
......
// 鉴权 监测用户是否登录
app.UseAuthentication();
// 授权 监测有没有权限访问后续页面
app.UseAuthorization();
......
}
（2）在Startup中方法ConfigureServices内添加注册。
public void ConfigureServices(IServiceCollection services)
{
......
services.AddAuthentication(CookieAuthenticationDefaults.AuthenticationScheme)
.AddCookie(options =>
{
options.LoginPath = new PathString("/Home/Login"); //如果授权失败就跳转到登录
});
......
}
（3）在指定Action上加上[Authorize]特性做鉴权授权。也可以全局标记。
[Authorize]
public IActionResult Index()
{
return View();
}
[AllowAnonymous] //避开权限检查
public IActionResult Login()
{
return View();
}
[HttpPost]
[AllowAnonymous]
public IActionResult Login(string name, string password, string verify)
{
string verifyCode = base.HttpContext.Session.GetString("CheckCode");
//if (verifyCode != null && verifyCode.Equals(verify, StringComparison.CurrentCultureIgnoreCase))
//{
#region 鉴权：鉴权，检测有没有登录，登录的是谁，赋值给User
//rolelist 是登录成功后用户的角色---是来自于数据库的查询；不同的用户会查询出不同的角色；
var rolelist = new List() {
"Admin",
"Teacher",
"Student"
};
//ClaimTypes.Role就是做权限认证的标识；
var claims = new List()//鉴别你是谁，相关信息
{
new Claim(ClaimTypes.Role,"Admin"),
new Claim(ClaimTypes.Name,name),
new Claim("password",password),//可以写入任意数据
new Claim("Account","admin"),
new Claim("role","admin"),
new Claim("admin","admin"),
new Claim("User","admin")
};
foreach (var role in rolelist)
{
claims.Add(new Claim(ClaimTypes.Role, role));
}
ClaimsPrincipal userPrincipal = new ClaimsPrincipal(new ClaimsIdentity(claims, "Customer"));
HttpContext.SignInAsync(CookieAuthenticationDefaults.AuthenticationScheme, userPrincipal, new AuthenticationProperties
{
ExpiresUtc = DateTime.UtcNow.AddMinutes(30),//过期时间：30分钟
}).Wait();
#endregion
var user = HttpContext.User;
return base.Redirect("/Home/Index");
}
else
{
base.ViewBag.Msg = "账号密码错误";
}
#endregion
//}
//else
//{
// base.ViewBag.Msg = "验证码错误";
//}
return View();
}
5.1 鉴权授权-角色授权
即用户角色不同，在访问页面时需要做不同的拦截。
（1）一个特性标记到方法上，通过逗号分隔不同角色，只要是有一个角色符合就能够访问，角色之间是或者的关系。
[Authorize(Roles = "Admin,Teacher,Student")]
（2）多个特性标记，多个角色之前是且的关系，必须要包含所有的角色，才能够访问。
[Authorize(Roles = "Admin")]
[Authorize(Roles = "Teacher")]
[Authorize(Roles = "Student")]
5.2 鉴权授权-策略授权
上面的角色授权是在代码中写死了角色，但我们更希望能够用处理逻辑来完成校验，就需要策略授权。
（1）添加CustomAuthorizationRequirement类继承自IAuthorizationRequirement，用来传递策略名称。
public class CustomAuthorizationRequirement : IAuthorizationRequirement
{
public string Name { get; set; }
public CustomAuthorizationRequirement(string policyname)
{
this.Name = policyname;
}
}
（2）添加CustomAuthorizationHandler类专用做检验逻辑， 继承自泛型抽象类AuthorizationHandler。
protected override Task HandleRequirementAsync(AuthorizationHandlerContext context,
CustomAuthorizationRequirement requirement)
{
if (requirement.Name == "Policy01")
{
///策略1的逻辑
}
if (requirement.Name == "Policy02")
{
///策略1的逻辑
}
//其实这里可以去数据库里面去做一些查询，然后根据用户的信息，做计算；如果符合就context.Succeed(requirement);
//否则就Task.CompletedTask;
//context.User 鉴权成功（登录成功以后），用户的信息；
var role = context.User.FindFirst(c => c.Value.Contains("admin"));
if (role != null)
{
context.Succeed(requirement); //验证通过了
}
return Task.CompletedTask; //验证不通过
}
（3）添加注册,并支持多种策略。
services.AddSingleton();
services.AddAuthorization(option =>
{
option.AddPolicy("customPolicy01", policy =>
{
policy.AddRequirements(new CustomAuthorizationRequirement("Policy01"));
});
});
services.AddAuthorization(option =>
{
option.AddPolicy("customPolicy02", policy =>
{
policy.AddRequirements(new CustomAuthorizationRequirement("Policy02"));
});
});
（4）标记到使用的方法上。
[Authorize(policy: "customPolicy01")]
public IActionResult IndexPolicy()
{
return View();
}