實現一個基於動態代理的 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 == 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

實現一個基於動態代理的 AOP

實現一個基於動態代理的 AOP

Intro

效果演示

整體結構

ProxyGenerator

AbstractAspect

MethodInvocationContext

代理方法邏輯

More

Reference

實現一個基於動態代理的 AOP

.NET 下基於動態代理的 AOP 框架實現揭祕

AOP底層實現原理，動態代理如何動態

【乾貨】JDK動態代理的實現原理以及如何手寫一個JDK動態代理

基於動態代理 Mock Dubbo 服務的實現方案

Spring之AOP的實現（JDK動態代理：只能代理介面，不能代理類）

Java 動態代理(AOP實現機制)

mybatis原始碼學習：基於動態代理實現查詢全過程

聊聊高並發（三十二）實現一個基於鏈表的無鎖Set集合

開心一下-實現一個基於Java的中文編程語言2

實現一個可動態擴充套件的，按鈕突出可變的，安卓底部選單導航欄

實現自己的動態代理，類似JDK動態代理

springboot 實現對bean動態代理原始碼分析

定製併發類（三）實現一個基於優先順序的Executor類

定製併發類（十）實現一個基於優先順序的傳輸佇列

Java框架學習_Spring（三）Spring_AOP底層實現：JDK動態代理和Cglib動態代理

golang簡單實現一個基於TLS/SSL的 TCP伺服器和客戶端

這裡實現一個基於陣列的執行緒安全的迴圈佇列

jQuery——實現一個3D動態輪播圖

使用Scala實現一個基於性質的測試庫

實現一個基於動態代理的 AOP

實現一個基於動態代理的 AOP

Intro

效果演示

整體結構

ProxyGenerator

AbstractAspect

MethodInvocationContext

代理方法邏輯

More

Reference

相關推薦