ASP.NET Core搭建多层网站架构【9.2-使用Castle.Core实现动态代理拦截器】

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测试接口：

可以看到返回结果显示出来了，可以打断点看看程序到底怎么通过拦截器的。

这里只是实现了业务层方法拦截，异常日志的捕获，可以做更多例如权限验证的拦截器。

项目完成后，如下图所示

巴特西