Fireasy3 揭秘 -- 使用 SourceGeneraor 实现动态代理(AOP)

夏结希

目录

• Fireasy3 揭秘 -- 依赖注入与服务发现
  
• Fireasy3 揭秘 -- 自动服务部署
  
• Fireasy3 揭秘 -- 使用 SourceGeneraor 改进服务发现
  
• Fireasy3 揭秘 -- 使用 SourceGeneraor 实现动态代理(AOP)
  
• Fireasy3 揭秘 -- 使用 Emit 构建程序集
  
• Fireasy3 揭秘 -- 使用缓存提高反射性能
  
• Fireasy3 揭秘 -- 动态类型及扩展支持
  
• Fireasy3 揭秘 -- 线程数据共享的实现
  
• Fireasy3 揭秘 -- 配置管理及解析处理
  
• Fireasy3 揭秘 -- 数据库适配器
  
• Fireasy3 揭秘 -- 解决数据库之间的语法差异
  
• Fireasy3 揭秘 -- 获取数据库的架构信息
  
• Fireasy3 揭秘 -- 数据批量插入的实现
  
• Fireasy3 揭秘 -- 使用包装器对数据读取进行兼容
  
• Fireasy3 揭秘 -- 数据行映射器
  
• Fireasy3 揭秘 -- 数据转换器的实现
  
• Fireasy3 揭秘 -- 通用序列生成器和雪花生成器的实现
  
• Fireasy3 揭秘 -- 命令拦截器的实现
  
• Fireasy3 揭秘 -- 数据库主从同步的实现
  
• Fireasy3 揭秘 -- 大数据分页的策略
  
• Fireasy3 揭秘 -- 数据按需更新及生成实体代理类
  
• Fireasy3 揭秘 -- 用对象池技术管理上下文
  
• Fireasy3 揭秘 -- Lambda 表达式解析的原理
  
• Fireasy3 揭秘 -- 扩展选择的实现
  
• Fireasy3 揭秘 -- 按需加载与惰性加载的区别与实现
  
• Fireasy3 揭秘 -- 自定义函数的解析与绑定
  
• Fireasy3 揭秘 -- 与 MongoDB 进行适配
  
• Fireasy3 揭秘 -- 模块化的实现原理
  

　　实现 AOP（面向切面编程）的实现方式有很多种，但无外乎静态纺织和动态编织两种。
　　动态编织 在 Fireasy 2 中使用 Emit 实现了动态编织。Emit 的缺点很明显，首先就是要求对 IL 语言必须比较熟悉且考虑较全面，其次由于是动态编织，需要使用内存缓存来对代理类进行管理。
　　静态编织 是指在代码编译时就将拦截器相关的代码插入到代码内部，运行时不耗用时间和内存空间。常用的有 MSBuild（如PostSharp） 和 Code Analyzers（本文中用到的 ISourceGenerator）。
　　首先，定义拦截器的接口，Initialize/InitializeAsync 方法用于首次初始化，Intercept/InterceptAsync 用于拦截方法的执行和属性的访问。如下：

1.     /// <summary>
2.     /// 提供对类成员进行拦截的方法。
3.     /// </summary>
4.     public interface IInterceptor
5.     {
6.         /// <summary>
7.         /// 使用上下文对象对当前的拦截器进行初始化。
8.         /// </summary>
9.         /// <param name="context">包含拦截定义的上下文。</param>
10.         void Initialize(InterceptContext context);
12.         /// <summary>
13.         /// 将自定义方法注入到当前的拦截点。
14.         /// </summary>
15.         /// <param name="info">拦截调用信息。</param>
16.         void Intercept(InterceptCallInfo info);
17.     }
19.     /// <summary>
20.     /// 提供对类成员进行拦截的异步方法。
21.     /// </summary>
22.     public interface IAsyncInterceptor
23.     {
24.         /// <summary>
25.         /// 使用上下文对象对当前的拦截器进行初始化。
26.         /// </summary>
27.         /// <param name="context">包含拦截定义的上下文。</param>
28.         ValueTask InitializeAsync(InterceptContext context);
30.         /// <summary>
31.         /// 将自定义方法注入到当前的拦截点。
32.         /// </summary>
33.         /// <param name="info">拦截调用信息。</param>
34.         ValueTask InterceptAsync(InterceptCallInfo info);
35.     }

复制代码

　　InterceptCallInfo 是拦截的调用信息，其中，Arguments 属性是调用的入参，ReturnValue 属性是返回的值。如下：

1.     /// <summary>
2.     /// 用于通知客户端的拦截信息。无法继承此类。
3.     /// </summary>
4.     public sealed class InterceptCallInfo
5.     {
6.         /// <summary>
7.         /// 获取或设置定义的类型。
8.         /// </summary>
9.         public Type? DefinedType { get; set; }
11.         /// <summary>
12.         /// 获取或设置当前被拦截的方法或属性。
13.         /// </summary>
14.         public MemberInfo? Member { get; set; }
16.         /// <summary>
17.         /// 获取或设置方法的返回类型。
18.         /// </summary>
19.         public Type? ReturnType { get; set; }
21.         /// <summary>
22.         /// 获取或设置当前被拦截的目标对象。
23.         /// </summary>
24.         public object? Target { get; set; }
26.         /// <summary>
27.         /// 获取或设置拦截的类型。
28.         /// </summary>
29.         public InterceptType InterceptType { get; set; }
31.         /// <summary>
32.         /// 获取或设置方法的参数数组。
33.         /// </summary>
34.         public object[]? Arguments { get; set; }
36.         /// <summary>
37.         /// 获取或设置方法的返回值。
38.         /// </summary>
39.         public object? ReturnValue { get; set; }
41.         /// <summary>
42.         /// 获取或设置触发的异常信息。
43.         /// </summary>
44.         public Exception? Exception { get; set; }
46.         /// <summary>
47.         /// 获取或设置取消 Before 事件之后调用基类的方法。
48.         /// </summary>
49.         public bool Cancel { get; set; }
51.         /// <summary>
52.         /// 获取或设置是否中断后继拦截器的执行。
53.         /// </summary>
54.         public bool Break { get; set; }
55.     }

复制代码

　　最后定义一个特性 InterceptAttribute 用于指定类或方法上的拦截器类型，只需要在类、属性或方法上指定即可：

1. [InterceptAttribute(typeof(SampleInterceptor))]

复制代码

　　接下来，我们定义好注入代码的原型，以便下一步生成代码。比如方法的切面示例：

1. public override string Test(string str)
2. {
3.     //定义由 InterceptAttribute 指定的拦截器实例
4.     var interceptors = new List<IInterceptor> { new SampleInterceptor() };
5.     var info = new InterceptCallInfo();
6.     //拦截的对象为当前对象
7.     info.Target = this;
8.     //方法的入参
9.     info.Arguments = new object[] { str };
10.     //当前拦截的成员（方法）
11.     info.Member = ((MethodInfo)MethodBase.GetCurrentMethod()).GetBaseDefinition();
13.     try
14.     {
15.         //初始化
16.         _Initialize(interceptors, info);
17.         //通知拦截器方法即将被调用
18.         _Intercept(interceptors, info, InterceptType.BeforeMethodCall);
20.         //如果拦截器告知要取消执行
21.         if (info.Cancel)
22.         {
23.             //返回值，如果方法为 void，那么直接 return
24.             //在拦截器中可以给 ReturnValue 进行赋值，然后 Cancel = true
25.             return info.ReturnValue == null ? default : (string)info.ReturnValue;
26.         }
27.         //调用父方法
28.         info.ReturnValue = base.Test(str);
29.         //通知拦截器方法已调用完成
30.         _Intercept(interceptors, info, InterceptType.AfterMethodCall);
31.     }
32.     catch (System.Exception exp)
33.     {
34.         info.Exception = exp;
35.         //通知拦截器，有异常抛出
36.         _Intercept(interceptors, info, InterceptType.Catching);
37.         throw exp;
38.     }
39.     finally
40.     {
41.         //任何时候，都会走到这一步
42.         _Intercept(interceptors, info, InterceptType.Finally);
43.     }
44.     //返回值
45.     return info.ReturnValue == null ? default : (string)info.ReturnValue;
46. }

复制代码

　　属性的切面也差不多，只是对 get 和 set 分别处理。我们来看一下 _Initialize 方法要实现的目的：

1. private void _Initialize(List<IInterceptor> interceptors, InterceptCallInfo callInfo)
2. {
3.     if (!this._initMarks.Contains(callInfo.Member))
4.     {
5.         for (int i = 0; i < interceptors.Count; i++)
6.         {
7.             InterceptContext context = new InterceptContext(callInfo.Member, this);
8.             interceptors[i].Initialize(context);
9.         }
10.         this._initMarks.Add(callInfo.Member);
11.     }
12. }

复制代码

　　它的目的是让拦截器只调用一次 Initialize 方法。而 Intercept 方法用于通知拦截器进行拦截，在拦截器里给定 Break = true 时，后续的拦截器将不会被调用。

1. private void _Intercept(List<IInterceptor> interceptors, InterceptCallInfo callInfo, InterceptType interceptType)
2. {
3.     callInfo.InterceptType = interceptType;
4.     callInfo.Break = false;
5.     for (int i = 0; i < interceptors.Count; i++)
6.     {
7.         if (callInfo.Break)
8.         {
9.             break;
10.         }
12.         interceptors[i].Intercept(callInfo);
13.     }
14. }

复制代码

　　接下来，我们用 ISourceGenretor 来实现代码的生成。
　　上篇 使用 SourceGeneraor 改进服务发现 已经讲解过 ISourceGenerator 的用法了，需要分别定义一个 ISyntaxContextReceiver 和 ISourceGenerator 的实现。
　　定义 DynamicProxySyntaxReceiver 类，用来接收语法节点，并进行分析，找出可以拦截的方法和属性，以及拦截器等内容。这里，我着重讲解一下 AnalyseClassSyntax 方法的实现，如下：

1.         /// <summary>
2.         /// 分析类型语法。
3.         /// </summary>
4.         /// <param name="model"></param>
5.         /// <param name="syntax"></param>
6.         private void AnalyseClassSyntax(SemanticModel model, ClassDeclarationSyntax syntax)
7.         {
8.             var typeSymbol = (ITypeSymbol)model.GetDeclaredSymbol(syntax)!;
9.             if (typeSymbol.IsSealed)
10.             {
11.                 return;
12.             }
14.             var interceptorMetadataOfClass = FindInterceptorMetadata(typeSymbol);
16.             var metadata = new ClassMetadata(typeSymbol);
18.             //获取所有成员
19.             foreach (var memberSymbol in typeSymbol.GetMembers())
20.             {
21.                 //如果不是方法或属性
22.                 if (memberSymbol.Kind != SymbolKind.Method && memberSymbol.Kind != SymbolKind.Property)
23.                 {
24.                     continue;
25.                 }
27.                 if (memberSymbol is IMethodSymbol method)
28.                 {
29.                     //构造器需要重载，所以也要记录下来
30.                     if (method.MethodKind == MethodKind.Constructor)
31.                     {
32.                         metadata.AddConstructor(method);
33.                         continue;
34.                     }
36.                     if (method.MethodKind != MethodKind.Ordinary)
37.                     {
38.                         continue;
39.                     }
40.                 }
42.                 //方法定义为 virtual 并且是公共的
43.                 if (!memberSymbol.IsVirtual || memberSymbol.DeclaredAccessibility != Accessibility.Public)
44.                 {
45.                     continue;
46.                 }
48.                 //查找方法上的 InterceptAttribute 特性
49.                 if (memberSymbol.GetAttributes().Any(s => s.AttributeClass!.ToDisplayString() == InterceptorAttributeName))
50.                 {
51.                     var interceptorMetadataOfMember = FindInterceptorMetadata(memberSymbol);
52.                     if (interceptorMetadataOfMember != null)
53.                     {
54.                         metadata.AddMember(memberSymbol, interceptorMetadataOfMember);
55.                     }
56.                 }
57.                 //没找到方法上的特性，则使用类上定义的 InterceptAttribute 特性
58.                 else if (interceptorMetadataOfClass != null)
59.                 {
60.                     var hasIgnoreThrowExpAttr = HasIgnoreThrowExceptionAttribute(memberSymbol);
61.                     metadata.AddMember(memberSymbol, interceptorMetadataOfClass.Clone(!hasIgnoreThrowExpAttr));
62.                 }
63.             }
65.             if (metadata.IsValid)
66.             {
67.                 _metadata.Add(FindUsings(syntax, metadata));
68.             }
69.         }

复制代码

　　FindInterceptorMetadata 方法用于查找在类或方法、属性上定义的 InterceptAttribute 特性，并记录下拦截器的类型。如下：

1.         /// <summary>
2.         /// 获取拦截器的元数据。
3.         /// </summary>
4.         /// <param name="symbol"></param>
5.         /// <returns></returns>
6.         private InterceptorMetadata? FindInterceptorMetadata(ISymbol symbol)
7.         {
8.             var types = new List<ITypeSymbol>();
9.             foreach (AttributeData classAttr in symbol.GetAttributes().Where(s => s.AttributeClass!.ToDisplayString() == InterceptorAttributeName))
10.             {
11.                 var interceptorType = GetInterceptorType(classAttr.ConstructorArguments[0].Value);
12.                 if (interceptorType != null)
13.                 {
14.                     types.Add(interceptorType);
15.                 }
16.             }
18.             if (!types.Any())
19.             {
20.                 return null;
21.             }
23.             var hasIgnoreThrowExpAttr = HasIgnoreThrowExceptionAttribute(symbol);
25.             return new InterceptorMetadata(types, !hasIgnoreThrowExpAttr);
26.         }

复制代码

　　在 ClassMetadata 里，定义了可被拦截的方法、属性，以及构造器、引用的命名空间等信息，如下：

1.     /// <summary>
2.     /// 类的元数据。
3.     /// </summary>
4.     public class ClassMetadata
5.     {
6.         /// <summary>
7.         /// 初始化 <see cref="ClassMetadata"/> 类的新实例。
8.         /// </summary>
9.         /// <param name="type">类型符号。</param>
10.         public ClassMetadata(ITypeSymbol type)
11.         {
12.             Type = type;
13.         }
15.         /// <summary>
16.         /// 获取类型符号。
17.         /// </summary>
18.         public ITypeSymbol Type { get; }
20.         /// <summary>
21.         /// 获取命名空间。
22.         /// </summary>
23.         public string Namespace => Type.ContainingNamespace.ToDisplayString();
25.         /// <summary>
26.         /// 获取类型的全名。
27.         /// </summary>
28.         public string TypeFullName => Type.ToDisplayString();
30.         /// <summary>
31.         /// 获取代理类的名称。
32.         /// </summary>
33.         public string ProxyTypeName => $"{Type.Name}_proxy_";
35.         /// <summary>
36.         /// 获取代理类的全名。
37.         /// </summary>
38.         public string ProxyTypeFullName => $"{Namespace}.{ProxyTypeName}";
40.         /// <summary>
41.         /// 获取源代码名称。
42.         /// </summary>
43.         public string SourceCodeName => Type.ToDisplayString().Replace(".", "_") + ".cs";
45.         /// <summary>
46.         /// 获取构造函数列表。
47.         /// </summary>
48.         public List<IMethodSymbol> Constructors { get; } = new();
50.         /// <summary>
51.         /// 获取可拦截的方法。
52.         /// </summary>
53.         public Dictionary<IMethodSymbol, InterceptorMetadata> Methods { get; } = new();
55.         /// <summary>
56.         /// 获取可拦截的属性。
57.         /// </summary>
58.         public Dictionary<IPropertySymbol, InterceptorMetadata> Properties { get; } = new();
60.         /// <summary>
61.         /// 获取引用的命名空间列表。
62.         /// </summary>
63.         public List<string> Usings { get; } = new();
65.         /// <summary>
66.         /// 添加可拦截的成员。
67.         /// </summary>
68.         /// <param name="symbol"></param>
69.         /// <param name="metadata"></param>
70.         public void AddMember(ISymbol symbol, InterceptorMetadata metadata)
71.         {
72.             if (symbol is IMethodSymbol method)
73.             {
74.                 Methods.Add(method, metadata);
75.             }
76.             else if (symbol is IPropertySymbol property && property.Parameters.Count() == 0) //忽略索引器
77.             {
78.                 Properties.Add(property, metadata);
79.             }
80.         }
82.         /// <summary>
83.         /// 添加构造方法。
84.         /// </summary>
85.         /// <param name="symbol"></param>
86.         public void AddConstructor(IMethodSymbol symbol)
87.         {
88.             Constructors.Add(symbol);
89.         }
91.         /// <summary>
92.         /// 添加引用的命名空间列表。
93.         /// </summary>
94.         /// <param name="usings"></param>
95.         public void AddUsings(IEnumerable<string> usings)
96.         {
97.             Usings.AddRange(usings);
98.         }
100.         /// <summary>
101.         /// 若有可拦截的方法或属性，则此元数据有效。
102.         /// </summary>
103.         public bool IsValid => Methods.Any() || Properties.Any();
104.     }

复制代码

　　接下来，在 DynamicProxyGenerator 类的 Execute 方法里，获取到以上记录到的元数据，分别创建 DynamicProxyClassBuilder 对象来生成代码，如下：

1.         void ISourceGenerator.Execute(GeneratorExecutionContext context)
2.         {
3.             var mappers = new Dictionary<string, string>();
5.             if (context.SyntaxContextReceiver is DynamicProxySyntaxReceiver receiver)
6.             {
7.                 var metadatas = receiver.GetMetadatas();
8.                 metadatas.ForEach(s =>
9.                 {
10.                     context.AddSource(s.SourceCodeName, new DynamicProxyClassBuilder(s).BuildSource());
11.                     mappers.Add(s.TypeFullName, s.ProxyTypeFullName);
12.                 });
14.                 //代码生成完毕后，还需要在部署器中，将父类和代理类添加到 Container 容器中
15.                 if (mappers.Count > 0)
16.                 {
17.                     context.AddSource("DynamicProxyServicesDeployer.cs", BuildDeploySourceCode(mappers));
18.                 }
19.             }
20.         }

复制代码

　　DynamicProxyClassBuilder 类的核心的实现，在这里，将对构造函数进行重载，对所有的方法、属性进行切面代码的生成。由于篇幅有限，这里只贴上类的构建方法，其他的对照原型进行参悟，也是比较容易理解的。如下：

1.         /// <summary>
2.         /// 生成源代码。
3.         /// </summary>
4.         /// <returns></returns>
5.         public SourceText BuildSource()
6.         {
7.             var sb = new StringBuilder();
8.             foreach (var u in _metadata.Usings)
9.             {
10.                 sb.AppendLine(u.ToString());
11.             }
13.             sb.AppendLine("using System.Reflection;");
15.             sb.AppendLine($@"
16. namespace {_metadata.Namespace}
17. {{
18.     public class {_metadata.ProxyTypeName} : {_metadata.TypeFullName}, IDynamicProxyImplemented
19.     {{
20.         private List<System.Reflection.MemberInfo> _initMarks = new ();
21.         
22.         {BuildConstructors()}
23.         {BuildInitializeMethod()}
24.         {BuildInterceptMethod()}
25.         {BuildMethods()}
26.         {BuildProperties()}
27.     }}
28. }}");
30.             return SourceText.From(sb.ToString(), Encoding.UTF8);
31.         }

复制代码

　　那么同样的，项目编译后，会生成一个 __DynamicProxyServicesDeployer 的部署器，目的是往 Container 里添加代理映射。如下：

1. [assembly: ServicesDeployAttribute(typeof(__DynamicProxyNs.__DynamicProxyServicesDeployer))]
3. internal class __DynamicProxyServicesDeployer : IServicesDeployer
4. {
5.     void IServicesDeployer.Configure(IServiceCollection services)
6.     {
7.         Container.TryAdd(typeof(DependencyInjectionTests.TestDynamicProxyClass), typeof(TestDynamicProxyClass_proxy_));
8.         Container.TryAdd(typeof(DynamicProxyTests.TestProxy), typeof(TestProxy_proxy_));
9.         Container.TryAdd(typeof(ObjectActivatorTests.TestServiceProxy2), typeof(TestServiceProxy2_proxy_));
10.     }
11. }

复制代码

　　单元测试就不再赘述了，可以去这里查看 动态代理单元测试 。


　　最后，奉上 Fireasy 3 的开源地址：https://gitee.com/faib920/fireasy3 ，欢迎大家前来捧场。
　　本文相关代码请参考：
　　https://gitee.com/faib920/fireasy3/src/libraries/Fireasy.Common/DynamicProxy
　　https://gitee.com/faib920/fireasy3/src/libraries/Fireasy.Common.Analyzers/DynamicProxy
　　https://gitee.com/faib920/fireasy3/tests/Fireasy.Common.Tests/DynamicProxyTests.cs
　　更多内容请移步官网 http://www.fireasy.cn 。

来源:https://www.cnblogs.com/fireasy/archive/2023/03/05/17179651.html
免责声明：由于采集信息均来自互联网，如果侵犯了您的权益，请联系我们【E-Mail:cb@itdo.tech】 我们会及时删除侵权内容，谢谢合作！