AOP从静态代理到动态代理 Emit实现

【前言】

　　AOP为Aspect Oriented Programming的缩写，意思是面向切面编程的技术。

　　何为切面？

　　一个和业务没有任何耦合相关的代码段，诸如：调用日志，发送邮件，甚至路由分发。一切能为代码所有且能和代码充分解耦的代码都可以作为一个业务代码的切面。

　　我们为什么要AOP？

　　那我们从一个场景举例说起：

　　如果想要采集用户操作行为，我们需要掌握用户调用的每一个接口的信息。这时候的我们要怎么做?

　　如果不采用AOP技术，也是最简单的，所有方法体第一句话先调用一个日志接口将方法信息传递记录。

　　有何问题？

　　实现业务没有任何问题，但是随之而来的是代码臃肿不堪，难以调整维护的诸多问题（可自行脑补）。

　　如果我们采用了AOP技术，我们就可以在系统启动的地方将所有将要采集日志的类注入，每一次调用方法前，AOP框架会自动调用我们的日志代码。

　　是不是省去了很多重复无用的劳动？代码也将变得非常好维护（有朝一日不需要了，只需将切面代码注释掉即可）

　　接下来我们看看AOP框架的工作原理以及实过程。

【实现思路】

　　AOP框架呢，一般通过静态代理和动态代理两种实现方式。

　　何为静态代理？

　　静态代理，又叫编译时代理，就是在编译的时候，已经存在代理类，运行时直接调用的方式。说的通俗一点，就是自己手动写代码实现代理类的方式。

　　我们通过一个例子来展现一下静态代理的实现过程：

　　我们这里有一个业务类，里面有方法Test()，我们要在Test调用前和调用后分别输出日志。

　　我们既然要将Log当作一个切面，我们肯定不能去动原有的业务代码，那样也违反了面向对象设计之开闭原则。

　　那么我们要怎么做呢？我们定义一个新类 BusinessProxy 去包装一下这个类。为了便于在多个方法的时候区分和辨认，方法也叫 Test（）

　　这样，我们如果要在所有的Business类中的方法都添加Log，我们就在BusinessProxy代理类中添加对应的方法去包装。既不破坏原有逻辑，又可以实现前后日志的功能。

　　当然，我们可以有更优雅的实现方式：

　　我们可以定义代理类，继承自业务类。将业务类中的方法定义为虚方法。那么我们可以重写父类的方法并且在加入日志以后再调用父类的原方法。

　　当然，我们还有更加优雅的实现方式：

　　我们可以使用发射的技术，写一个通用的Invoke方法，所有的方法都可以通过该方法调用。

　　我们这样便实现了一个静态代理。

　　那我们既然有了静态代理，为什么又要有动态代理呢？

　　我们仔细回顾静态代理的实现过程。我们要在所有的方法中添加切面，我们就要在代理类中重写所有的业务方法。更有甚者，我们有N个业务类，就要定义N个代理类。这是很庞大的工作量。

　　这就是动态代理出现的背景，相比都可以猜得到，动态代理就是将这一系列繁琐的步骤自动化，让程序自动为我们生成代理类。

　　何为动态代理？

　　动态代理，又成为运行时代理。在程序运行的过程中，调用了生成代理类的代码，将自动生成业务类的代理类。不需要我们手共编写，极高的提高了工作效率和调整了程序员的心态。

　　原理不必多说，就是动态生成静态代理的代码。我们要做的，就是选用一种生成代码的方式去生成。

　　今天我分享一个简单的AOP框架，代码使用Emit生成。当然，Emit 代码的写法不是今天要讲的主要内容，需要提前去学习。

　　先说效果：

　　定义一个Action特性类 ActionAttribute 继承自 ActionBaseAttribute，里面在Before和After方法中输出两条日志；

　　定义一个Action特性类 InterceptorAttribute 继承自 InterceptorBaseAttribute，里面捕获了方法调用异常，以及执行前后分别输出日志；

　　然后定义一个业务类 BusinessClass 实现了 IBusinessClass 接口，定义了各种类型的方法

　　多余的方法不贴图了。

　　我们把上面定义的方法调用切面标签放在业务类上，表示该类下所有的方法都执行异常过滤；

　　我们把Action特性放在Test方法上，表明要在 Test（）方法的 Before 和 After 调用时记录日志；

　　我们定义测试类：

　　调用一下试试：

　　可见，全类方法标签 Interceptor 在 Test 和 GetInt 方法调用前后都打出了对应的日志；

　　Action方法标签只在 Test 方法上做了标记，那么Test 方法 Before 和 After 执行时打出了日志；

【实现过程】

　　实现的思路在上面已经有详细的讲解，可以参考静态代理的实现思路。

　　我们定义一个动态代理生成类 DynamicProxy，用于原业务代码的扫描和代理类代码的生成；

　　定义两个过滤器标签，ActionBaseAttribute，提供 Before 和 After 切面方法；InterceptorBaseAttribute，提供 Invoke “全调用”包装的切面方法；

　　Before可以获取到当前调用的方法和参数列表，After可以获取到当前方法调用以后的结果。

　　Invoke 可以拿到当前调用的对象和方法名，参数列表。在这里进行反射动态调用。

1 [AttributeUsage(AttributeTargets.Method | AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
2     public class ActionBaseAttribute : Attribute
3     {
4         public virtual void Before(string @method, object[] parameters) { }
5 
6         public virtual object After(string @method, object result) { return result; }
7     }

1 [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)]
2     public class InterceptorBaseAttribute : Attribute
3     {
4         public virtual object Invoke(object @object, string @method, object[] parameters)
5         {
6             return @object.GetType().GetMethod(@method).Invoke(@object, parameters);
7         }
8     }

　　代理生成类采用Emit的方式生成运行时IL代码。

　　先把代码放在这里：

  1 public class DynamicProxy
  2     {
  3         public static TInterface CreateProxyOfRealize<TInterface, TImp>() where TImp : class, new() where TInterface : class
  4         {
  5             return Invoke<TInterface, TImp>();
  6         }
  7 
  8         public static TProxyClass CreateProxyOfInherit<TProxyClass>() where TProxyClass : class, new()
  9         {
 10             return Invoke<TProxyClass, TProxyClass>(true);
 11         }
 12 
 13         private static TInterface Invoke<TInterface, TImp>(bool inheritMode = false) where TImp : class, new() where TInterface : class
 14         {
 15             var impType = typeof(TImp);
 16 
 17             string nameOfAssembly = impType.Name + "ProxyAssembly";
 18             string nameOfModule = impType.Name + "ProxyModule";
 19             string nameOfType = impType.Name + "Proxy";
 20 
 21             var assemblyName = new AssemblyName(nameOfAssembly);
 22 
 23             var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
 24             var moduleBuilder = assembly.DefineDynamicModule(nameOfModule);
 25 
 26             //var assembly = AppDomain.CurrentDomain.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.RunAndSave);
 27             //var moduleBuilder = assembly.DefineDynamicModule(nameOfModule, nameOfAssembly + ".dll");
 28 
 29             TypeBuilder typeBuilder;
 30             if (inheritMode)
 31                 typeBuilder = moduleBuilder.DefineType(nameOfType, TypeAttributes.Public, impType);
 32             else
 33                 typeBuilder = moduleBuilder.DefineType(nameOfType, TypeAttributes.Public, null, new[] { typeof(TInterface) });
 34 
 35             InjectInterceptor<TImp>(typeBuilder, impType.GetCustomAttribute(typeof(InterceptorBaseAttribute))?.GetType(), inheritMode);
 36 
 37             var t = typeBuilder.CreateType();
 38 
 39             //assembly.Save(nameOfAssembly + ".dll");
 40 
 41             return Activator.CreateInstance(t) as TInterface;
 42         }
 43 
 44         private static void InjectInterceptor<TImp>(TypeBuilder typeBuilder, Type interceptorAttributeType, bool inheritMode = false)
 45         {
 46             var impType = typeof(TImp);
 47             // ---- define fields ----
 48             FieldBuilder fieldInterceptor = null;
 49             if (interceptorAttributeType != null)
 50             {
 51                 fieldInterceptor = typeBuilder.DefineField("_interceptor", interceptorAttributeType, FieldAttributes.Private);
 52             }
 53             // ---- define costructors ----
 54             if (interceptorAttributeType != null)
 55             {
 56                 var constructorBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard, null);
 57                 var ilOfCtor = constructorBuilder.GetILGenerator();
 58 
 59                 ilOfCtor.Emit(OpCodes.Ldarg_0);
 60                 ilOfCtor.Emit(OpCodes.Newobj, interceptorAttributeType.GetConstructor(new Type[0]));
 61                 ilOfCtor.Emit(OpCodes.Stfld, fieldInterceptor);
 62                 ilOfCtor.Emit(OpCodes.Ret);
 63             }
 64 
 65             // ---- define methods ----
 66 
 67             var methodsOfType = impType.GetMethods(BindingFlags.Public | BindingFlags.Instance);
 68 
 69             string[] ignoreMethodName = new[] { "GetType", "ToString", "GetHashCode", "Equals" };
 70 
 71             foreach (var method in methodsOfType)
 72             {
 73                 //ignore method
 74                 if (ignoreMethodName.Contains(method.Name))
 75                     return;
 76 
 77                 var methodParameterTypes = method.GetParameters().Select(p => p.ParameterType).ToArray();
 78 
 79                 MethodAttributes methodAttributes;
 80 
 81                 if (inheritMode)
 82                     methodAttributes = MethodAttributes.Public | MethodAttributes.Virtual;
 83                 else
 84                     methodAttributes = MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final;
 85 
 86                 var methodBuilder = typeBuilder.DefineMethod(method.Name, methodAttributes, CallingConventions.Standard, method.ReturnType, methodParameterTypes);
 87 
 88                 var ilMethod = methodBuilder.GetILGenerator();
 89 
 90                 // set local field
 91                 var impObj = ilMethod.DeclareLocal(impType);                //instance of imp object
 92                 var methodName = ilMethod.DeclareLocal(typeof(string));     //instance of method name
 93                 var parameters = ilMethod.DeclareLocal(typeof(object[]));   //instance of parameters
 94                 var result = ilMethod.DeclareLocal(typeof(object));         //instance of result
 95                 LocalBuilder actionAttributeObj = null;
 96 
 97                 //attribute init
 98                 Type actionAttributeType = null;
 99                 if (method.GetCustomAttribute(typeof(ActionBaseAttribute)) != null || impType.GetCustomAttribute(typeof(ActionBaseAttribute)) != null)
100                 {
101                     //method can override class attrubute
102                     if (method.GetCustomAttribute(typeof(ActionBaseAttribute)) != null)
103                     {
104                         actionAttributeType = method.GetCustomAttribute(typeof(ActionBaseAttribute)).GetType();
105                     }
106                     else if (impType.GetCustomAttribute(typeof(ActionBaseAttribute)) != null)
107                     {
108                         actionAttributeType = impType.GetCustomAttribute(typeof(ActionBaseAttribute)).GetType();
109                     }
110 
111                     actionAttributeObj = ilMethod.DeclareLocal(actionAttributeType);
112                     ilMethod.Emit(OpCodes.Newobj, actionAttributeType.GetConstructor(new Type[0]));
113                     ilMethod.Emit(OpCodes.Stloc, actionAttributeObj);
114                 }
115 
116                 //instance imp
117                 ilMethod.Emit(OpCodes.Newobj, impType.GetConstructor(new Type[0]));
118                 ilMethod.Emit(OpCodes.Stloc, impObj);
119 
120                 //if no attribute
121                 if (fieldInterceptor != null || actionAttributeObj != null)
122                 {
123                     ilMethod.Emit(OpCodes.Ldstr, method.Name);
124                     ilMethod.Emit(OpCodes.Stloc, methodName);
125 
126                     ilMethod.Emit(OpCodes.Ldc_I4, methodParameterTypes.Length);
127                     ilMethod.Emit(OpCodes.Newarr, typeof(object));
128                     ilMethod.Emit(OpCodes.Stloc, parameters);
129 
130                     // build the method parameters
131                     for (var j = 0; j < methodParameterTypes.Length; j++)
132                     {
133                         ilMethod.Emit(OpCodes.Ldloc, parameters);
134                         ilMethod.Emit(OpCodes.Ldc_I4, j);
135                         ilMethod.Emit(OpCodes.Ldarg, j + 1);
136                         //box
137                         ilMethod.Emit(OpCodes.Box, methodParameterTypes[j]);
138                         ilMethod.Emit(OpCodes.Stelem_Ref);
139                     }
140                 }
141 
142                 //dynamic proxy action before
143                 if (actionAttributeType != null)
144                 {
145                     //load arguments
146                     ilMethod.Emit(OpCodes.Ldloc, actionAttributeObj);
147                     ilMethod.Emit(OpCodes.Ldloc, methodName);
148                     ilMethod.Emit(OpCodes.Ldloc, parameters);
149                     ilMethod.Emit(OpCodes.Call, actionAttributeType.GetMethod("Before"));
150                 }
151 
152                 if (interceptorAttributeType != null)
153                 {
154                     //load arguments
155                     ilMethod.Emit(OpCodes.Ldarg_0);//this
156                     ilMethod.Emit(OpCodes.Ldfld, fieldInterceptor);
157                     ilMethod.Emit(OpCodes.Ldloc, impObj);
158                     ilMethod.Emit(OpCodes.Ldloc, methodName);
159                     ilMethod.Emit(OpCodes.Ldloc, parameters);
160                     // call Invoke() method of Interceptor
161                     ilMethod.Emit(OpCodes.Callvirt, interceptorAttributeType.GetMethod("Invoke"));
162                 }
163                 else
164                 {
165                     //direct call method
166                     if (method.ReturnType == typeof(void) && actionAttributeType == null)
167                     {
168                         ilMethod.Emit(OpCodes.Ldnull);
169                     }
170 
171                     ilMethod.Emit(OpCodes.Ldloc, impObj);
172                     for (var j = 0; j < methodParameterTypes.Length; j++)
173                     {
174                         ilMethod.Emit(OpCodes.Ldarg, j + 1);
175                     }
176                     ilMethod.Emit(OpCodes.Callvirt, impType.GetMethod(method.Name));
177                     //box
178                     if (actionAttributeType != null)
179                     {
180                         if (method.ReturnType != typeof(void))
181                             ilMethod.Emit(Opfs.Box, method.ReturnType);
182                         else
183                             ilMethod.Emit(OpCodes.Ldnull);
184                     }
185                 }
186 
187                 //dynamic proxy action after
188                 if (actionAttributeType != null)
189                 {
190                     ilMethod.Emit(OpCodes.Stloc, result);
191                     //load arguments
192                     ilMethod.Emit(OpCodes.Ldloc, actionAttributeObj);
193                     ilMethod.Emit(OpCodes.Ldloc, methodName);
194                     ilMethod.Emit(OpCodes.Ldloc, result);
195                     ilMethod.Emit(OpCodes.Call, actionAttributeType.GetMethod("After"));
196                 }
197 
198                 // pop the stack if return void
199                 if (method.ReturnType == typeof(void))
200                 {
201                     ilMethod.Emit(OpCodes.Pop);
202                 }
203                 else
204                 {
205                     //unbox,if direct invoke,no box
206                     if (fieldInterceptor != null || actionAttributeObj != null)
207                     {
208                         if (method.ReturnType.IsValueType)
209                             ilMethod.Emit(OpCodes.Unbox_Any, method.ReturnType);
210                         else
211                             ilMethod.Emit(OpCodes.Castclass, method.ReturnType);
212                     }
213                 }
214                 // complete
215                 ilMethod.Emit(OpCodes.Ret);
216             }
217         }
218     }