實作一個基于動態代理的 AOP

Intro

上次看基于動態代理的 AOP 框架實作，立了一個 Flag，自己寫一個簡單的 AOP 實作示例，今天過來填坑了

目前的實作是基于 Emit 來做的，后面有時間再寫一個基于 Roslyn 來實作的示例

效果演示

演示代碼：

切面邏輯定義:

public class TryInvokeAspect : AbstractAspect
{
    public override void Invoke(MethodInvocationContext methodInvocationContext, Action next)
    {
        Console.WriteLine($"begin invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
        try
        {
            next();
        }
        catch (Exception e)
        {
            Console.WriteLine($"Invoke {methodInvocationContext.ProxyMethod.DeclaringType?.FullName}.{methodInvocationContext.ProxyMethod.Name} exception");
            Console.WriteLine(e);
        }
        Console.WriteLine($"end invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
    }
}

public class TryInvoke1Aspect : AbstractAspect
{
    public override void Invoke(MethodInvocationContext methodInvocationContext, Action next)
    {
        Console.WriteLine($"begin invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
        try
        {
            next();
        }
        catch (Exception e)
        {
            Console.WriteLine($"Invoke {methodInvocationContext.ProxyMethod.DeclaringType?.FullName}.{methodInvocationContext.ProxyMethod.Name} exception");
            Console.WriteLine(e);
        }
        Console.WriteLine($"end invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
    }
}

public class TryInvoke2Aspect : AbstractAspect
{
    public override void Invoke(MethodInvocationContext methodInvocationContext, Action next)
    {
        Console.WriteLine($"begin invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
        try
        {
            next();
        }
        catch (Exception e)
        {
            Console.WriteLine($"Invoke {methodInvocationContext.ProxyMethod.DeclaringType?.FullName}.{methodInvocationContext.ProxyMethod.Name} exception");
            Console.WriteLine(e);
        }
        Console.WriteLine($"end invoke method {methodInvocationContext.ProxyMethod.Name} in {GetType().Name}...");
    }
}

測驗服務定義

// 測驗介面定義
public interface ITestService
{
    [TryInvokeAspect]
    void Test();

    [TryInvokeAspect]
    [TryInvoke1Aspect]
    [TryInvoke2Aspect]
    void Test1(int a, string b);

    [TryInvokeAspect]
    string Test2();

    [TryInvokeAspect]
    int Test3();
}
// 測驗介面實體定義
public class TestService : ITestService
{
    [TryInvokeAspect]
    public virtual string TestProp { get; set; }

    public void Test()
    {
        Console.WriteLine("test invoked");
    }

    public virtual void Test1(int a, string b)
    {
        Console.WriteLine($"a:{a}, b:{b}");
    }

    [TryInvoke1Aspect]
    public virtual string Test2()
    {
        return "Hello";
    }

    [TryInvokeAspect]
    public virtual int Test3()
    {
        return 1;
    }
}

測驗代碼：

//var testService = ProxyGenerator.Instance.CreateInterfaceProxy<ITestService>();
var testService = ProxyGenerator.Instance.CreateInterfaceProxy<ITestService, TestService>();
// var testService = ProxyGenerator.Instance.CreateClassProxy<TestService>();
// testService.TestProp = "12133";
testService.Test();
Console.WriteLine();
testService.Test1(1, "str");

var a = testService.Test2();

var b = testService.Test3();
Console.WriteLine($"a:{a}, b:{b}");
Console.ReadLine();

輸出效果：

整體結構

ProxyGenerator

ProxyGenerator 代理生成器，用來創建代理物件

public class ProxyGenerator
{
    public static readonly ProxyGenerator Instance = new ProxyGenerator();

    public object CreateInterfaceProxy(Type interfaceType)
    {
        var type = ProxyUtil.CreateInterfaceProxy(interfaceType);
        return Activator.CreateInstance(type);
    }

    public object CreateInterfaceProxy(Type interfaceType, Type implementationType)
    {
        var type = ProxyUtil.CreateInterfaceProxy(interfaceType, implementationType);
        return Activator.CreateInstance(type);
    }

    public object CreateClassProxy(Type classType, params Type[] interfaceTypes)
    {
        var type = ProxyUtil.CreateClassProxy(classType, interfaceTypes);
        return Activator.CreateInstance(type);
    }

    public object CreateClassProxy(Type classType, Type implementationType, params Type[] interfaceTypes)
    {
        var type = ProxyUtil.CreateClassProxy(implementationType, interfaceTypes);
        return Activator.CreateInstance(type);
    }
}

為了更方便的使用泛型，定義了幾個擴展方法：

public static class Extensions
{
    public static TInterface CreateInterfaceProxy<TInterface>(this ProxyGenerator proxyGenerator) =>
        (TInterface)proxyGenerator.CreateInterfaceProxy(typeof(TInterface));

    public static TInterface CreateInterfaceProxy<TInterface, TImplement>(this ProxyGenerator proxyGenerator) where TImplement : TInterface =>
        (TInterface)proxyGenerator.CreateInterfaceProxy(typeof(TInterface), typeof(TImplement));

    public static TClass CreateClassProxy<TClass>(this ProxyGenerator proxyGenerator) where TClass : class =>
        (TClass)proxyGenerator.CreateClassProxy(typeof(TClass));

    public static TClass CreateClassProxy<TClass, TImplement>(this ProxyGenerator proxyGenerator) where TImplement : TClass =>
        (TClass)proxyGenerator.CreateClassProxy(typeof(TClass), typeof(TImplement));
}

AbstractAspect

AbstractAspect 切面抽象類，繼承了 Attribute，可以繼承它來實作自己的切面邏輯

public abstract class AbstractAspect : Attribute
{
    public abstract void Invoke(MethodInvocationContext methodInvocationContext, Action next);
}

MethodInvocationContext

MethodInvocationContext 方法執行背景關系，包含了執行方法時的原始方法資訊以及代理方法資訊，方法引數，方法回傳值

public class MethodInvocationContext
{
    public MethodInfo ProxyMethod { get; }

    public MethodInfo MethodBase { get; }

    public object ProxyTarget { get; }

    public object Target { get; }

    public object[] Parameters { get; }

    public object ReturnValue { get; set; }

    public MethodInvocationContext(MethodInfo method, MethodInfo methodBase, object proxyTarget, object target, object[] parameters)
    {
        ProxyMethod = method;
        MethodBase = methodBase;
        ProxyTarget = proxyTarget;
        Target = target;
        Parameters = parameters;
    }
}

代理方法邏輯

生成代理的方法在上一節已經介紹，主要就是通過 Emit 生成代理類，要寫一些 Emit 代碼， Emit 不在今天的討論范圍內，這里不多介紹，生成代理方法的時候，會檢查方法上的 Attribute ，如果是切面邏輯就注冊切面邏輯，最后像 asp.net core 中間件一樣組裝在一起拼成一個委托，

核心代碼如下：

// var invocation = new MethodInvocationContext(method, methodBase, this, parameters);
var localAspectInvocation = il.DeclareLocal(typeof(MethodInvocationContext));
il.Emit(OpCodes.Ldloc, localCurrentMethod);
il.Emit(OpCodes.Ldloc, localMethodBase);
il.Emit(OpCodes.Ldarg_0);
il.Emit(OpCodes.Ldloc, localTarget);
il.Emit(OpCodes.Ldloc, localParameters);
// 創建一個 MethodInvocationContext 實體
il.New(typeof(MethodInvocationContext).GetConstructors()[0]); 
il.Emit(OpCodes.Stloc, localAspectInvocation);

// AspectDelegate.InvokeAspectDelegate(invocation);
il.Emit(OpCodes.Ldloc, localAspectInvocation);
var invokeAspectDelegateMethod =
    typeof(AspectDelegate).GetMethod(nameof(AspectDelegate.InvokeAspectDelegate));
// 執行方法以及注冊的切面邏輯
il.Call(invokeAspectDelegateMethod);
il.Emit(OpCodes.Nop);

if (method.ReturnType != typeof(void))
{
    // 獲取方法回傳值
    il.Emit(OpCodes.Ldloc, localAspectInvocation);
    var getMethod = typeof(MethodInvocationContext).GetProperty("ReturnValue").GetGetMethod();
    il.EmitCall(OpCodes.Callvirt, getMethod, Type.EmptyTypes);

    if (method.ReturnType.IsValueType)
    {
        // 如果是值型別，做一下型別轉換
        il.EmitCastToType(typeof(object), method.ReturnType);
    }
	
    il.Emit(OpCodes.Stloc, localReturnValue);
    il.Emit(OpCodes.Ldloc, localReturnValue);
}

il.Emit(OpCodes.Ret);

注冊并執行切面邏輯代碼實作：

// 快取方法體執行的委托，包含切面邏輯的執行和方法的呼叫
private static readonly ConcurrentDictionary<string, Action<MethodInvocationContext>> _aspectDelegates = new ConcurrentDictionary<string, Action<MethodInvocationContext>>();

public static void InvokeAspectDelegate(MethodInvocationContext context)
{
    var action = _aspectDelegates.GetOrAdd($"{context.ProxyMethod.DeclaringType}.{context.ProxyMethod}", m =>
    {
        // 獲取切面邏輯，這里根據切面型別做了一個去重
        var aspects = new List<AbstractAspect>(8);
        if (context.MethodBase != null)
        {
            // 獲取類方法上的切面邏輯
            foreach (var aspect in context.MethodBase.GetCustomAttributes<AbstractAspect>())
            {
                if (!aspects.Exists(x => x.GetType() == aspect.GetType()))
                {
                    aspects.Add(aspect);
                }
            }
        }
        // 獲取介面方法上的切面
        var methodParameterTypes = context.ProxyMethod.GetParameters().Select(p => p.GetType()).ToArray();
        foreach (var implementedInterface in context.ProxyTarget.GetType().GetImplementedInterfaces())
        {
            var method = implementedInterface.GetMethod(context.ProxyMethod.Name, methodParameterTypes);
            if (null != method)
            {
                foreach (var aspect in method.GetCustomAttributes<AbstractAspect>())
                {
                    if (!aspects.Exists(x => x.GetType() == aspect.GetType()))
                    {
                        aspects.Add(aspect);
                    }
                }
            }
        }

        // 構建切面邏輯執行管道，類似于 asp.net core 里的請求管道， 以原始方法呼叫作為中間件的最后一步
        var builder = PipelineBuilder.Create<MethodInvocationContext>(x => x.Invoke());
        foreach (var aspect in aspects)
        {
            // 注冊切面邏輯
            builder.Use(aspect.Invoke);
        }
        // 構建方法執行委托
        return builder.Build();
    });
    // 執行委托
    action.Invoke(context);

    // 檢查回傳值，防止切面邏輯管道的中斷執行導致值型別回傳值沒有賦值
    if (context.ProxyMethod.ReturnType != typeof(void))
    {
        if (context.ReturnValue =https://www.cnblogs.com/weihanli/p/= null && context.ProxyMethod.ReturnType.IsValueType)
        {
            // 為值型別回傳值設定默認值作為回傳值
            context.ReturnValue = Activator.CreateInstance(context.ProxyMethod.ReturnType);
        }
    }
}

以上基本可以實作一個 AOP 功能，但是從擴展性以及功能上來說都還比較欠缺，基于 Attribute 的方式固然可以實作功能，但是太不靈活，如果我要在一個無法修改的介面上的某一個方法做一個切面邏輯，顯然只使用 Attribute 是做不到的，還是 Fluent-API 的方式比較靈活，

想做一層 AOP 的抽象，切面邏輯通過 Fluent-API 的方式來注冊，大概的 API 可能是這樣的：

var settings = FluentAspects.For<ITestService>();
setting.PropertySetter(x=>x.TestProp)
    .InterceptWith<TryInterceptor>()
    .InterceptWith<TryInterceptor1>();
setting.Method(x=> x.Test2())
    .InterceptWith<TryInterceptor>()
    .InterceptWith<TryInterceptor1>();

然后基于 AspectCore 和 Castle.Core 來實作具體的 AOP 功能，暫時先想一下，爭取盡快的發布一個基本可用的版本，然后之前基于 EF Core 的自動審計也可以基于 AOP 來實作了，這樣就不需要顯示繼承 AuditDbContext 了~

文章所有原始碼可以在 Github 上獲取到，Github 地址： https://github.com/WeihanLi/SamplesInPractice/tree/master/AopSample

Reference

讓 .NET 輕松構建中間件模式代碼
讓 .NET 輕松構建中間件模式代碼--支持中間件管道的中斷和分支
NET 下基于動態代理的 AOP 框架實作揭秘
EF Core 資料變更自動審計設計
AopSample
AspectCore

轉載請註明出處，本文鏈接：https://www.uj5u.com/net/40688.html

標籤：.NET Core

上一篇：asp.net core web api + Element-UI的Vue管理后臺

下一篇：abp(net core)+easyui+efcore實作倉儲管理系統——入庫管理之九(四十五)

實作一個基于動態代理的 AOP

實作一個基于動態代理的 AOP

Intro

效果演示

整體結構

ProxyGenerator

AbstractAspect

MethodInvocationContext

代理方法邏輯

More

Reference