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.0html

摘要:基於ASP.NET Core 3.1 WebApi搭建後端多層網站架構【9.2-使用Castle.Core實現動態代理攔截器】
介紹瞭如何對業務層方法進行攔截,捕獲業務方法發生的錯誤,而後統一進行日誌記錄,避免在每一個業務方法中進行try catch捕獲異常git

文章目錄程序員

此分支項目代碼github

本章節介紹瞭如何對業務層方法進行攔截,捕獲業務方法發生的錯誤,而後統一進行日誌記錄,避免在每一個業務方法中進行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.csLogInterceptor.csLogInterceptorAsync.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異常類型,目的是爲了:async

  • 攔截器捕獲異常後已經進行了日誌記錄,這個異常可能須要繼續拋出去,此時用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測試接口:

能夠看到返回結果顯示出來了,能夠打斷點看看程序到底怎麼經過攔截器的。

這裏只是實現了業務層方法攔截,異常日誌的捕獲,能夠作更多例如權限驗證的攔截器。

項目完成後,以下圖所示

相關文章
相關標籤/搜索