netcore 之动态代理（微服务专题）

动态代理配合rpc技术调用远程服务，不用关注细节的实现，让程序就像在本地调用以用。

因此动态代理在微服务系统中是不可或缺的一个技术。网上看到大部分案例都是通过反射自己实现，且相当复杂。编写和调试相当不易，我这里提供里一种简便的方式来实现动态代理。

1、创建我们的空白.netcore项目 

通过vs2017轻易的创建出一个.netcore项目

2、编写Startup.cs文件

默认Startup 没有构造函数，自行添加构造函数，带有  IConfiguration 参数的，用于获取项目配置，但我们的示例中未使用配置

  public Startup(IConfiguration configuration)
        {
            Configuration = configuration;
            //注册编码提供程序
            Encoding.RegisterProvider(CodePagesEncodingProvider.Instance);
        }

在ConfigureServices 配置日志模块，目前core更新的很快，日志的配置方式和原来又很大出入，最新的配置方式如下

  // For more information on how to configure your application, visit https://go.microsoft.com/fwlink/?LinkID=398940
        public void ConfigureServices(IServiceCollection services  )
        {
            services.AddLogging(loggingBuilder=> {
                loggingBuilder.AddConfiguration(Configuration.GetSection("Logging"));
                loggingBuilder.AddConsole();
                loggingBuilder.AddDebug();
            });

        }

添加路由过滤器，监控一个地址，用于调用我们的测试代码。netcore默认没有UTF8的编码方式，所以要先解决UTF8编码问题，否则将在输出中文时候乱码。

这里注意 Map  内部传递了参数 applicationBuilder ，千万不要 使用Configure(IApplicationBuilder app, IHostingEnvironment env ) 中的app参数，否则每次请求api/health时候都将调用这个中间件（app.Run会短路期后边所有的中间件），

 app.Map("/api/health", (applicationBuilder) =>
            {

                applicationBuilder.Run(context =>
               {
                   return context.Response.WriteAsync(uName.Result, Encoding.UTF8);
               });
            });

3、代理

netcore 已经为我们完成了一些工作，提供了DispatchProxy 这个类

#region 程序集 System.Reflection.DispatchProxy, Version=4.0.4.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a
// C:Program FilesdotnetsdkNuGetFallbackFoldermicrosoft.netcore.app2.2.0
ef
etcoreapp2.2System.Reflection.DispatchProxy.dll
#endregion

namespace System.Reflection
{
    //
    public abstract class DispatchProxy
    {
        //
        protected DispatchProxy();

        //
        // 类型参数:
        //   T:
        //
        //   TProxy:
        public static T Create<T, TProxy>() where TProxy : DispatchProxy;
        //
        // 参数:
        //   targetMethod:
        //
        //   args:
        protected abstract object Invoke(MethodInfo targetMethod, object[] args);
    }
}

这个类提供了一个实例方法，一个静态方法：

Invoke(MethodInfo targetMethod, object[] args) ^{（注解1）}

Create<T, TProxy>()^{（注解2）}

Create 创建代理的实例对象，实例对象在调用方法时候会自动执行Invoke

首先我们创建一个动态代理类  ProxyDecorator<T>：DispatchProxy  需要继承DispatchProxy  。

在DispatchProxy 的静态方法  Create<T, TProxy>()中要求 TProxy : DispatchProxy

ProxyDecorator 重写  DispatchProxy的虚方法invoke 

我们可以在ProxyDecorator 类中添加一些其他方法，比如：异常处理，MethodInfo执行前后的处理。

重点要讲一下 

ProxyDecorator 中需要传递一个 T类型的变量 decorated 。

因为  DispatchProxy.Create<T, ProxyDecorator<T>>(); 会创建一个新的T的实例对象 ，这个对象是代理对象实例，我们将 decorated 绑定到这个代理实例上

接下来这个代理实例在执行T类型的任何方法时候都会用到 decorated，因为 [decorated] 会被传给  targetMethod.Invoke(decorated, args)   （targetMethod 来自注解1） ，invoke相当于执行

这样说的不是很明白，我们直接看代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection;
using System.Text;
using System.Threading.Tasks;

namespace TestWFW
{
    public class ProxyDecorator<T> : DispatchProxy
    {
        //关键词 RealProxy
        private T decorated;
        private event Action<MethodInfo, object[]> _afterAction;   //动作之后执行
        private event Action<MethodInfo, object[]> _beforeAction;   //动作之前执行

        //其他自定义属性，事件和方法
        public ProxyDecorator()
        {

        }


        /// <summary>
        /// 创建代理实例
        /// </summary>
        /// <param name="decorated">代理的接口类型</param>
        /// <returns></returns>
        public T Create(T decorated)
        {

            object proxy = Create<T, ProxyDecorator<T>>();   //调用DispatchProxy 的Create  创建一个新的T
            ((ProxyDecorator<T>)proxy).decorated = decorated;       //这里必须这样赋值，会自动未proxy 添加一个新的属性

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//其他的请如法炮制

　　　　　　　　　　return (T)proxy;
        }

        /// <summary>
        /// 创建代理实例
        /// </summary>
        /// <param name="decorated">代理的接口类型</param>
        /// <param name="beforeAction">方法执行前执行的事件</param>
        /// <param name="afterAction">方法执行后执行的事件</param>
        /// <returns></returns>
        public T Create(T decorated, Action<MethodInfo, object[]> beforeAction, Action<MethodInfo, object[]> afterAction)
        {

            object proxy = Create<T, ProxyDecorator<T>>();   //调用DispatchProxy 的Create  创建一个新的T
            ((ProxyDecorator<T>)proxy).decorated = decorated;
            ((ProxyDecorator<T>)proxy)._afterAction = afterAction;
            ((ProxyDecorator<T>)proxy)._beforeAction = beforeAction;
            //((GenericDecorator<T>)proxy)._loggingScheduler = TaskScheduler.FromCurrentSynchronizationContext();
            return (T)proxy;
        }



        protected override object Invoke(MethodInfo targetMethod, object[] args)
        {
            if (targetMethod == null) throw new Exception("无效的方法");
         
            try
            {
                //_beforeAction 事件
                if (_beforeAction != null)
                {
                    this._beforeAction(targetMethod, args);
                }


                object result = targetMethod.Invoke(decorated, args);
     　　　　　　　　System.Diagnostics.Debug.WriteLine(result);　　　　　　//打印输出面板
                var resultTask = result as Task;
                if (resultTask != null)
                {
                    resultTask.ContinueWith(task =>    //ContinueWith   创建一个延续，该延续接收调用方提供的状态信息并执行 当目标系统 tasks。 
                    {
                        if (task.Exception != null)
                        {
                            LogException(task.Exception.InnerException ?? task.Exception, targetMethod);
                        }
                        else
                        {
                            object taskResult = null;
                            if (task.GetType().GetTypeInfo().IsGenericType &&
                                task.GetType().GetGenericTypeDefinition() == typeof(Task<>))
                            {
                                var property = task.GetType().GetTypeInfo().GetProperties().FirstOrDefault(p => p.Name == "Result");
                                if (property != null)
                                {
                                    taskResult = property.GetValue(task);
                                }
                            }
                            if (_afterAction != null)
                            {
                                this._afterAction(targetMethod, args);
                            }
                        }
                    });
                }
                else
                {
                    try
                    {
                        // _afterAction 事件
                        if (_afterAction != null)
                        {
                            this._afterAction(targetMethod, args);
                        }
                    }
                    catch (Exception ex)
                    {
                        //Do not stop method execution if exception  
                        LogException(ex);
                    }
                }

                return result;
            }
            catch (Exception ex)
            {
                if (ex is TargetInvocationException)
                {
                    LogException(ex.InnerException ?? ex, targetMethod);
                    throw ex.InnerException ?? ex;
                }
                else
                {
                    throw ex;
                }
            }

        }


        /// <summary>
        /// aop异常的处理
        /// </summary>
        /// <param name="exception"></param>
        /// <param name="methodInfo"></param>
        private void LogException(Exception exception, MethodInfo methodInfo = null)
        {
            try
            {
                var errorMessage = new StringBuilder();
                errorMessage.AppendLine($"Class {decorated.GetType().FullName}");
                errorMessage.AppendLine($"Method {methodInfo?.Name} threw exception");
                errorMessage.AppendLine(exception.Message);

                //_logError?.Invoke(errorMessage.ToString());  记录到文件系统
            }
            catch (Exception)
            {
                // ignored  
                //Method should return original exception  
            }
        }
    }
}

代码比较简单，相信大家都看的懂，关键的代码和核心的系统代码已经加粗和加加粗+红 标注出来了

DispatchProxy<T> 类中有两种创建代理实例的方法

我们看一下第一种比较简单的创建方法

        // This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
        public void Configure(IApplicationBuilder app, IHostingEnvironment env )
        {
            if (env.IsDevelopment())
            {
                app.UseDeveloperExceptionPage();
            }



            // 添加健康检查路由地址
            app.Map("/api/health", (applicationBuilder) =>
            {

                applicationBuilder.Run(context =>
               {
                   IUserService userService = new UserService();
                   //执行代理
                   var serviceProxy = new ProxyDecorator<IUserService>();
                   IUserService user = serviceProxy.Create(userService);  //
                   Task<string> uName = user.GetUserName(222);
                   context.Response.ContentType = "text/plain;charset=utf-8";

                   return context.Response.WriteAsync(uName.Result, Encoding.UTF8);
               });
            });
}

代码中 UserService 和 IUserService 是一个class和interface  自己实现即可 ，随便写一个接口，并用类实现，任何一个方法就行，下面只是演示调用方法时候会执行什么，这个方法本身在岩石中并不重要。

 由于ProxyDecorator 中并未注入相关事件，所以我们在调用 user.GetUserName(222) 时候看不到任何特别的输出。下面我们演示一个相对复杂的调用方式。

    // 添加健康检查路由地址
            app.Map("/api/health2", (applicationBuilder) =>
            {
                applicationBuilder.Run(context =>
                {
                    IUserService userService = new UserService();
                    //执行代理
                    var serviceProxy = new ProxyDecorator<IUserService>();
                    IUserService user = serviceProxy.Create(userService, beforeEvent, afterEvent);  //
                    Task<string> uName = user.GetUserName(222);
                    context.Response.ContentType = "text/plain;charset=utf-8";

                    return context.Response.WriteAsync(uName.Result, Encoding.UTF8);

                });
            });

 IUserService user = serviceProxy.Create(userService, beforeEvent, afterEvent); 在创建代理实例时候传递了beforEvent 和 afterEvent，这两个事件处理
函数是我们在业务中定义的

void beforeEvent(MethodInfo methodInfo, object[] arges)
{
System.Diagnostics.Debug.WriteLine("方法执行前");
}

void afterEvent(MethodInfo methodInfo, object[] arges)
{
System.Diagnostics.Debug.WriteLine("执行后的事件");
}

在代理实例执行接口的任何方法的时候都会执行  beforeEvent,和 afterEvent 这两个事件(请参考Invoke(MethodInfo targetMethod, object[] args) 方法的实现)

在我们的示例中将会在vs的 输出 面板中看到 

方法执行前

“方法输出的值”

执行后事件

我们看下运行效果图：

 

 这是 user.GetUserName(222) 的运行结果

 控制台输出结果