2020/01/31, ASP.NET Core 3.1, VS2019, Autofac.Extras.DynamicProxy 4.5.0, Castle.Core.AsyncInterceptor 1.7.0
摘要：基于ASP.NET Core 3.1 WebApi搭建后端多层网站架构【9.2-使用Castle.Core实现动态代理拦截器】
介绍了如何对业务层方法进行拦截，捕获业务方法发生的错误，然后统一进行日志记录，避免在每个业务方法中进行try catch捕获异常
本章节介绍了如何对业务层方法进行拦截，捕获业务方法发生的错误，然后统一进行日志记录，避免在每个业务方法中进行try catch捕获异常。借助Autofac和Castle.Core实现动态代理拦截器，其中使用Castle.Core.AsyncInterceptor包实现异步拦截器。
添加包引用
向MS.Component.Aop类库中添加以下包引用：
<ItemGroup>
<PackageReference Include="Autofac.Extras.DynamicProxy" Version="4.5.0" />
<PackageReference Include="Castle.Core.AsyncInterceptor" Version="1.7.0" />
</ItemGroup>
- Autofac.Extras.DynamicProxy包和Autofac.Extensions.DependencyInjection包中的autofac版本最好一致，否则可能会出现代理拦截器注册失败的情况
- 可以先按我的包版本使用，确保拦截器无问题，再把包更新到最新版
- Autofac.Extras.DynamicProxy包是使用Autofac和Castle.Core实现动态代理拦截器
- Castle.Core.AsyncInterceptor包是实现异步拦截器（否则只能对同步方法进行拦截）
-
MS.Component.Aop类库要依赖MS.WebCore类库。
编写服务拦截器
在MS.Component.Aop类库中添加LogAop文件夹，在该文件夹下新建AopHandledException.cs、LogInterceptor.cs、LogInterceptorAsync.cs
AopHandledException.cs
using System;
namespace MS.Component.Aop
{
/// <summary>
/// 使用自定义的Exception，用于在aop中已经处理过的异常，在其他地方不用重复记录日志
/// </summary>
public class AopHandledException : ApplicationException
{
public string ErrorMessage { get; private set; }
public Exception InnerHandledException { get; private set; }
//无参数构造函数
public AopHandledException()
{
}
//带一个字符串参数的构造函数，作用：当程序员用Exception类获取异常信息而非 MyException时把自定义异常信息传递过去
public AopHandledException(string msg) : base(msg)
{
this.ErrorMessage = msg;
}
//带有一个字符串参数和一个内部异常信息参数的构造函数
public AopHandledException(string msg, Exception innerException) : base(msg)
{
this.InnerHandledException = innerException;
this.ErrorMessage = msg;
}
public string GetError()
{
return ErrorMessage;
}
}
}
这里自定义了一个AopHandledException异常类型，目的是为了：
- 拦截器捕获异常后已经进行了日志记录，这个异常可能需要继续抛出去，此时用AopHandledException异常类型包一层异常，这样后面再捕获到的异常就能判断是从Aop中抛出来的异常了，不再重复记录日志
LogInterceptor.cs
using Castle.DynamicProxy;
namespace MS.Component.Aop
{
public class LogInterceptor : IInterceptor
{
private readonly LogInterceptorAsync _logInterceptorAsync;
public LogInterceptor(LogInterceptorAsync logInterceptorAsync)
{
_logInterceptorAsync = logInterceptorAsync;
}
public void Intercept(IInvocation invocation)
{
_logInterceptorAsync.ToInterceptor().Intercept(invocation);
}
}
}
这个是主拦截器，继承自IInterceptor，不管是同步方法还是异步方法，都将会走其中的Intercept方法，然后会在LogInterceptorAsync中再去区分是异步方法还是同步方法
LogInterceptorAsync.cs
using Castle.DynamicProxy;
using Microsoft.Extensions.Logging;
using MS.Common.Extensions;
using System;
using System.Linq;
using System.Threading.Tasks;
namespace MS.Component.Aop
{
public class LogInterceptorAsync : IAsyncInterceptor
{
private readonly ILogger<LogInterceptorAsync> _logger;
public LogInterceptorAsync(ILogger<LogInterceptorAsync> logger)
{
_logger = logger;
}
/// <summary>
/// 同步方法拦截时使用
/// </summary>
/// <param name="invocation"></param>
public void InterceptSynchronous(IInvocation invocation)
{
try
{
//调用业务方法
invocation.Proceed();
LogExecuteInfo(invocation, invocation.ReturnValue.ToJsonString());//记录日志
}
catch (Exception ex)
{
LogExecuteError(ex, invocation);
throw new AopHandledException();
}
}
/// <summary>
/// 异步方法返回Task时使用
/// </summary>
/// <param name="invocation"></param>
public void InterceptAsynchronous(IInvocation invocation)
{
try
{
//调用业务方法
invocation.Proceed();
LogExecuteInfo(invocation, invocation.ReturnValue.ToJsonString());//记录日志
}
catch (Exception ex)
{
LogExecuteError(ex, invocation);
throw new AopHandledException();
}
}
/// <summary>
/// 异步方法返回Task<T>时使用
/// </summary>
/// <typeparam name="TResult"></typeparam>
/// <param name="invocation"></param>
public void InterceptAsynchronous<TResult>(IInvocation invocation)
{
//调用业务方法
invocation.ReturnValue = InternalInterceptAsynchronous<TResult>(invocation);
}
private async Task<TResult> InternalInterceptAsynchronous<TResult>(IInvocation invocation)
{
try
{
//调用业务方法
invocation.Proceed();
Task<TResult> task = (Task<TResult>)invocation.ReturnValue;
TResult result = await task;//获得返回结果
LogExecuteInfo(invocation, result.ToJsonString());
return result;
}
catch (Exception ex)
{
LogExecuteError(ex, invocation);
throw new AopHandledException();
}
}
#region helpMethod
/// <summary>
/// 获取拦截方法信息（类名、方法名、参数）
/// </summary>
/// <param name="invocation"></param>
/// <returns></returns>
private string GetMethodInfo(IInvocation invocation)
{
//方法类名
string className = invocation.Method.DeclaringType.Name;
//方法名
string methodName = invocation.Method.Name;
//参数
string args = string.Join(", ", invocation.Arguments.Select(a => (a ?? "").ToString()).ToArray());
if (string.IsNullOrWhiteSpace(args))
{
return $"{className}.{methodName}";
}
else
{
return $"{className}.{methodName}:{args}";
}
}
private void LogExecuteInfo(IInvocation invocation, string result)
{
_logger.LogDebug("方法{0}，返回值{1}", GetMethodInfo(invocation), result);
}
private void LogExecuteError(Exception ex, IInvocation invocation)
{
_logger.LogError(ex, "执行{0}时发生错误！", GetMethodInfo(invocation));
}
#endregion
}
}
这里是对方法拦截的主要实现：
- InterceptSynchronous是同步方法拦截时使用
- InterceptAsynchronous是异步方法返回Task时使用
- InterceptAsynchronous是异步方法返回Task（包含返回值）时使用
-
invocation.Proceed();这句话即是调用真正的业务方法，所以在该方法之前可以做一些权限判断的内容，在该方法之后可以获取记录业务返回结果 - 可以在invocation参数中获取方法名称、传递的参数等信息
- 如果做了用户登录，可以通过构造函数依赖注入IHttpContextAccessor以拿到执行业务者的信息（其实使用NLog记录日志时，NLog也能获取到登录用户的信息，就是NetUserIdentity这个参数）
- 在拦截器中，我对每个业务方法都以Debug的日志等级记录了调用业务方法的返回结果
至此对业务方法进行拦截，以Debug的日志等级记录了调用业务方法的返回结果，并捕获所有业务方法的异常已经完成。
封装Ioc注册
在MS.Component.Aop类库中添加AopServiceExtensions.cs类：
using Autofac;
using Autofac.Extras.DynamicProxy;
using System;
using System.Reflection;
namespace MS.Component.Aop
{
public static class AopServiceExtension
{
/// <summary>
/// 注册aop服务拦截器
/// 同时注册了各业务层接口与实现
/// </summary>
/// <param name="builder"></param>
/// <param name="serviceAssemblyName">业务层程序集名称</param>
public static void AddAopService(this ContainerBuilder builder, string serviceAssemblyName)
{
//注册拦截器，同步异步都要
builder.RegisterType<LogInterceptor>().AsSelf();
builder.RegisterType<LogInterceptorAsync>().AsSelf();
//注册业务层，同时对业务层的方法进行拦截
builder.RegisterAssemblyTypes(Assembly.Load(serviceAssemblyName))
.AsImplementedInterfaces().InstancePerLifetimeScope()
.EnableInterfaceInterceptors()//引用Autofac.Extras.DynamicProxy;
.InterceptedBy(new Type[] { typeof(LogInterceptor) })//这里只有同步的，因为异步方法拦截器还是先走同步拦截器
;
//业务层注册拦截器也可以使用[Intercept(typeof(LogInterceptor))]加在类上，但是上面的方法比较好，没有侵入性
}
}
}
说明：
- 在AddAopService方法中，传递了业务层程序集名称，使用Autofac统一注册业务层所有的接口和实现（这样就不用每个接口都写一次注册了），注册类型为InstancePerLifetimeScope
- 注册业务的同时，开启了代理拦截器：EnableInterfaceInterceptors
- 开启代理拦截器的同时，InterceptedBy传递了要使用哪些拦截器进行拦截，这里只有同步的，因为异步方法拦截器还是先走同步拦截器
- 业务层注册拦截器也可以使用[Intercept(typeof(LogInterceptor))]加在类上，但是上面的方法比较好，没有侵入性
获取业务层程序集名称
在MS.Services中添加ServiceExtensions.cs类：
using System.Reflection;
namespace MS.Services
{
public static class ServiceExtensions
{
/// <summary>
/// 获取程序集名称
/// </summary>
/// <returns></returns>
public static string GetAssemblyName()
{
return Assembly.GetExecutingAssembly().GetName().Name;
}
}
}
用于获取业务层的程序集名称，提供给Autofac进行批量的注册接口和实现。
注册Aop服务
在MS.WebApi应用程序中，Startup.cs:
在ConfigureContainer方法里删掉原先对IBaseService、IRoleService的接口注册，使用刚写的Aop注册，给业务层批量注册同时开启代理拦截：
//using MS.Services;
//以上代码添加至using
//注册aop拦截器
//将业务层程序集名称传了进去，给业务层接口和实现做了注册，也给业务层各方法开启了代理
builder.AddAopService(ServiceExtensions.GetAssemblyName());
完成后，代码如下图所示
至此，业务层方法的代理拦截都完成了，执行业务时，会在控制台显示每次业务的调用返回结果，如果遇到异常，会统一捕获并记录日志然后把异常包装一次再抛出去
启动项目，打开Postman测试接口：
可以看到返回结果显示出来了，可以打断点看看程序到底怎么通过拦截器的。
这里只是实现了业务层方法拦截，异常日志的捕获，可以做更多例如权限验证的拦截器。
项目完成后，如下图所示