gRPC Client Middleware.

最新推荐文章于 2024-09-02 20:38:05 发布
最新推荐文章于 2024-09-02 20:38:05 发布
阅读量267 收藏 1
点赞数
原文链接：http://www.cnblogs.com/kingreatwill/p/9501086.html
版权

　　中间件想必大家不陌生，今天给大家介绍如何实现中间件以及实现gRPC的客户端中间件。

什么是中间件？

   https://docs.microsoft.com/zh-cn/aspnet/core/fundamentals/middleware/index?view=aspnetcore-2.1&tabs=aspnetcore2x

中间件管道

 先定义管道Pipeline

/// <summary>
    /// Built pipeline for gRPC
    /// </summary>
    public class Pipeline
    {
        private PipelineDelagate processChain;

        internal Pipeline(PipelineDelagate middlewareChain)
        {
            processChain = middlewareChain;
        }

        internal Task RunPipeline(MiddlewareContext context)
        {
            return processChain(context);
        }
    }

然后实现PipelineBuilder

/// <summary>
    /// PipelineBuilder
    /// </summary>
    public class PipelineBuilder
    {
        private List<Func<PipelineDelagate, PipelineDelagate>> middlewares = new List<Func<PipelineDelagate, PipelineDelagate>>();

        /// <summary>
        /// Add a middleware
        /// </summary>
        public PipelineBuilder Use(Func<PipelineDelagate, PipelineDelagate> middleware)
        {
            middlewares.Add(middleware);
            return this;
        }

        /// <summary>
        /// Use
        /// </summary>
        public PipelineBuilder Use<T>(params object[] args)
        {
            middlewares.Add(d => WrapClass<T>(d, args));
            return this;
        }

        /// <summary>
        /// UseWhen
        /// </summary>
        public PipelineBuilder UseWhen<T>(Func<MiddlewareContext, bool> condition, params object[] args)
        {
            middlewares.Add(d =>
            {
                return async ctx => { if (condition(ctx)) { await WrapClass<T>(d, args)(ctx); } };
            });
            return this;
        }

        /// <summary>
        /// Use
        /// </summary>
        public PipelineBuilder Use(Func<MiddlewareContext, PipelineDelagate, Task> middleware)
        {
            middlewares.Add(d =>
            {
                return ctx => { return middleware(ctx, d); };
            });
            return this;
        }

        private PipelineDelagate WrapClass<T>(PipelineDelagate next, params object[] args)
        {
            var ctorArgs = new object[args.Length + 1];
            ctorArgs[0] = next;
            Array.Copy(args, 0, ctorArgs, 1, args.Length);
            var type = typeof(T);
            var instance = Activator.CreateInstance(type, ctorArgs);
            MethodInfo method = type.GetMethod("Invoke");
            return (PipelineDelagate)method.CreateDelegate(typeof(PipelineDelagate), instance);
        }

        /// <summary>
        /// Build
        /// </summary>
        public Pipeline Build()
        {
            PipelineDelagate pipeline = ExecuteMainHandler;
            middlewares.Reverse();
            foreach (var middleware in middlewares)
            {
                pipeline = middleware(pipeline);
            }
            return new Pipeline(pipeline);
        }

        internal static Task ExecuteMainHandler(MiddlewareContext context)
        {
            return context.HandlerExecutor();
        }
    }
MiddlewareContext 和 委托定义
/// <summary>
    /// MiddlewareContext
    /// </summary>
    public class MiddlewareContext
    {
        public IMethod Method { get; set; }
        
        public object Request { get; set; }
       
        public object Response { get; set; }

        public string Host { get; set; }

        public CallOptions Options { get; set; }

        internal Func<Task> HandlerExecutor { get; set; }
    }


    public delegate Task PipelineDelagate(MiddlewareContext context);

到这里管道建设完成，那个如何在gRPC中使用呢？

首先实现自己的客户端拦截器MiddlewareCallInvoker

 public sealed class MiddlewareCallInvoker : DefaultCallInvoker
    {
        private readonly Channel grpcChannel;

        private Pipeline MiddlewarePipeline { get; set; }

        public MiddlewareCallInvoker(Channel channel) : base(channel)
        {
            this.grpcChannel = channel;
        }

        public MiddlewareCallInvoker(Channel channel, Pipeline pipeline) : this(channel)
        {
            this.MiddlewarePipeline = pipeline;
        }

        private TResponse Call<TResponse>(Func<MiddlewareContext, TResponse> call, MiddlewareContext context)
        {
         
            TResponse response = default(TResponse);
            if (MiddlewarePipeline != null)
            {
                context.HandlerExecutor = async () =>
                {
                    response = await Task.FromResult(call(context));
                    context.Response = response;
                };
                MiddlewarePipeline.RunPipeline(context).ConfigureAwait(false);
            }
            else
            {
                response = call(context);
            }
            return response;
       
        }

        public override TResponse BlockingUnaryCall<TRequest, TResponse>(Method<TRequest, TResponse> method,
            string host, CallOptions options, TRequest request)
        {
            return Call((context) => base.BlockingUnaryCall((Method<TRequest, TResponse>)context.Method, context.Host, context.Options, (TRequest)context.Request), new MiddlewareContext
            {
                Host = host,
                Method = method,
                Options = options,
                Request = request,
                Response = null
            });
        }

        public override AsyncUnaryCall<TResponse> AsyncUnaryCall<TRequest, TResponse>(
            Method<TRequest, TResponse> method, string host, CallOptions options, TRequest request)
        {
            return Call((context) => base.AsyncUnaryCall((Method<TRequest, TResponse>)context.Method, context.Host, context.Options, (TRequest)context.Request), new MiddlewareContext
            {
                Host = host,
                Method = method,
                Options = options,
                Request = request,
                Response = null
            });
        }

        public override AsyncServerStreamingCall<TResponse> AsyncServerStreamingCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string host, CallOptions options,
            TRequest request)
        {
            return Call((context) => base.AsyncServerStreamingCall((Method<TRequest, TResponse>)context.Method, context.Host, context.Options, (TRequest)context.Request), new MiddlewareContext
            {
                Host = host,
                Method = method,
                Options = options,
                Request = request,
                Response = null
            });
        }

        public override AsyncClientStreamingCall<TRequest, TResponse> AsyncClientStreamingCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string host, CallOptions options)
        {
            return Call((context) => base.AsyncClientStreamingCall((Method<TRequest, TResponse>)context.Method, context.Host, context.Options), new MiddlewareContext
            {
                Host = host,
                Method = method,
                Options = options,
                Request = null,
                Response = null
            });
        }

        public override AsyncDuplexStreamingCall<TRequest, TResponse> AsyncDuplexStreamingCall<TRequest, TResponse>(Method<TRequest, TResponse> method, string host, CallOptions options)
        {
            return Call((context) => base.AsyncDuplexStreamingCall((Method<TRequest, TResponse>)context.Method, context.Host, context.Options), new MiddlewareContext
            {
                Host = host,
                Method = method,
                Options = options,
                Request = null,
                Response = null
            });
        }
    }
到这里基于管道的中间件基本完成。接下来就是在客户端使用了
 var pipeline = new PipelineBuilder()
              //.Use<ExceptionMiddleware>()
              //.Use<TimerMiddleware>()
              //.Use<LoggingMiddleware>()
              //.Use<TimeoutMiddleware>()
              .Use<PolicyMiddleware>(new PolicyMiddlewareOptions
              {
                  RetryTimes = 2,
                  TimoutMilliseconds = 100
              })
              ;
            //pipeline.Use<LoggingMiddleware>();// pipeline.UseWhen<LoggingMiddleware>(ctx => ctx.Context.Method.EndsWith("SayHello"));
            //pipeline.Use<TimeoutMiddleware>(new TimeoutMiddlewareOptions { TimoutMilliseconds = 1000 });
            //console logger
            pipeline.Use(async (ctx, next) =>
            {
                Console.WriteLine(ctx.Request.ToString());
                await next(ctx);
                Console.WriteLine(ctx.Response.ToString());
            });

            Channel channel = new Channel("127.0.0.1:50051", ChannelCredentials.Insecure);
            MiddlewareCallInvoker callInvoker = new MiddlewareCallInvoker(channel, pipeline.Build());

            var clientApi = new Get.GetClient(callInvoker);

            var replyApi = clientApi.SayHello(new ContractsSample1.HelloApiDemo.HelloRequest { Name = " APII" });
            Console.WriteLine("Greeting: " + replyApi.Message);

　　Middleware

 public class LoggingMiddleware
    {
        private PipelineDelagate _next;

        public LoggingMiddleware(PipelineDelagate next)
        {
            _next = next;
        }

        public async Task Invoke(MiddlewareContext context)
        {
           //Before
            await _next(context);
            //End
        }
    }

　　至此已完成所有工作。希望能够帮助到大家。

如果有机会将给大家介绍gRPC跨平台网关，该网关能够实现自动将下游的gRPC服务转化成http api，只需要你的proto文件即可。如果你使用consul，甚至无需你做任务配置。

转载于:https://www.cnblogs.com/kingreatwill/p/9501086.html

a4604678
关注
【Go语言实战】(21) gin+grpc+etcd 重构 grpc-todolist 项目
面向生活编程
05-20 1557
gin+grpc+etcd重构todolist项目
Go-GolanggRPC中间件拦截器链接验证日志记录重试等
08-13
Golang gRPC中间件：拦截器链接，验证，日志记录，重试等
grpc middleware
qq_41491837的博客
01-20 481
var authFunc grpc_auth.AuthFunc { authFunc = func(ctx context.Context) (context.Context, error) { logger.Debug("platform authfun run !") token, err := tools.ParseJwtToken(ctx) if err != nil { return nil, ErrMiddlewareParseJwtFailure }
gRPC-Go基础（5）middleware
最新发布
jzpfbpx的博客
09-02 823
if err!= nil {类似于grpc_zap.UnaryServerInterceptor，我们在建立服务的时候设置拦截器。)),)),在handler之前的部分，先注册的拦截器先执行；在handler之后的部分，先注册的拦截器后执行；原因是，在ChainUnaryServer函数中，是倒序将注册的拦截器函数一个个包装，最里面的就是核心的处理逻辑，故而会展现出以上的规则。
Interceptor拦截器 -- gRPC生态里的中间件
kevin_tech的博客，微信搜「网管叨bi叨」
04-25 2178
什么是拦截器gRPC的拦截器（interceptor）类似各种Web框架里的请求中间件，请求中间件大家都知道是利用装饰器模式对最终处理请求的handler程序进行装饰，这样中间件就可以在处...
Go gRPC 中间件：提升微服务效率与可维护性的利器
gitblog_00092的博客
03-26 454
Go gRPC 中间件：提升微服务效率与可维护性的利器 go-grpc-middleware项目地址:https://gitcode.com/gh_mirrors/gog/go-grpc-middleware 在分布式系统和微服务架构中，gRPC 是一款高效、灵活的 RPC（远程过程调用）框架，由 Google 主导并开源。而 是一个针对 gRPC 的 Go 语言中间件集合，它为你的 gRPC...
为gRPC-Server添加自定义中间件
User XXX Blog
07-12 1265
1. 目标：欲自定义一个捕捉grpc-server里面的全局代码500报错（panic报错）的中间件。 2. 书写中间件： 安装插件依赖： go get github.com/grpc-ecosystem/go-grpc-middleware 中间件全部代码，其中返回值类型为固定的形式（为go-grpc-middleware插件返回最值形式）： package middlewares import ( "context" "fmt" "google.golang.org/grpc"
Go Grpc Jwt身份认证和Gateway集成以及HTTPS双向认证
dz45693的专栏
01-05 2281
书接上文Go Grpc Jwt身份认证，本文我们尝试把gateway也加进来，有关gatewa大家可以参考go学习笔记 grpc-gateway和swagger。直接开干吧 1.修改api/api.proto文件 syntax = "proto3"; package api; // 1 导入 gateway 相关的proto 以及 swagger 相关的 proto import "google/api/annotations.proto"; import "protoc-gen-swagg...
GRPC: 如何添加 API 日志拦截器/中间件？
pointgoal_io的博客
10-11 655
本文将介绍如何在 gRPC 微服务中添加 API 日志拦截器/中间件。
grpc-protobuf-starter
04-27
创建一个客户端no.sysco.middleware.workshops.impl.Client.java并运行它。 从命令行构建并运行 打开终端 克隆项目存储库： git clone https://github.com/PrakharSrivastav/grpc-protobuf-starter.git 转到项目根...
go-grpc-middleware：Golang gRPC中间件：拦截器链接，身份验证，日志记录，重试等
02-03
使用gRPC中间件 中间件：拦截器，助手，实用程序。 中间件 最近获得了对Interceptor的支持，即在将请求传递到用户的应用程序逻辑之前在gRPC服务器上执行的，或者在用户调用周围的gRPC客户端上执行的中间件。 这是实现常见模式的理想方法：身份验证，日志记录，消息，验证，重试或监视。 这些是通用的构建块，可以轻松轻松地构建多个微服务。 该存储库的目的是充当此类可重用功能的起点。 它包含其中一些本身，但也将链接到有用的外部存储库。 grpc_middleware本身提供对链接拦截器的支持，这是一个示例： import "github.com/grpc-ecosystem/go-g
开源项目-grpc-ecosystem-go-grpc-middleware.zip
09-11
开源项目-grpc-ecosystem-go-grpc-middleware.zip,gRPC Middleware - reusable auth, logging, retry, tracing libraries for Golang
grpc-middleware实现grpc调用重试
一个菜鸟的博客
07-20 417
代码】grpc-middleware实现grpc调用重试。
gRPC之gRPC Middleware
YIYIYI
12-10 1398
gRPC之gRPC Middleware
go-kit grpc调用及中间件封装
Duktig的博客
09-02 1214
go-kit grpc调用及中间件封装
GRPC开发(9)-grpc服务开发-grpc-gateway的中间件
Salted fish in hand, I have the world.
07-09 2273
其实grpc的中间件和编写http的中间件一样 http服务 处理器：Handler 定义 type Handler interface { ServeHTTP(ResponseWriter, *Request) } http服务，最重要的就是处理器：Handler ，一个接口 我们需要定义一个处理器，实现ServeHTTP方法用来响应HTTP请求 下面是对处理器：Handler 的介绍 S...
GRPC开发(8)-grpc服务开发-截取器
Salted fish in hand, I have the world.
07-09 610
截取器 截取器可以对grpc server做一些例如验证、log等前置操作 s := grpc.NewServer(grpc.UnaryInterceptor(filter)) grpc-ecosystem项目中的链式截取器的支持 不过GRPC框架中只能为每个服务设置一个截取器，因此所有的截取工作只能在一个函数中完成。 开源的grpc-ecosystem项目中的go-grpc-middleware...
grpc_node.node文件缺失
03-01
grpc_node.node文件是gRPC库在Node.js中的本机扩展模块。如果你在使用gRPC时遇到grpc_node.node文件缺失的问题，可能是由于以下原因之一： 1. 编译错误：gRPC的本机扩展模块需要在安装过程中进行编译。如果编译过程中出现错误，可能会导致grpc_node.node文件缺失。你可以尝试重新安装gRPC并确保编译过程中没有出现错误。 2. 版本不匹配：grpc_node.node文件的缺失也可能是由于gRPC版本与Node.js版本不匹配导致的。请确保你使用的gRPC版本与你的Node.js版本兼容。 3. 文件丢失或损坏：在某些情况下，grpc_node.node文件可能会被意外删除或损坏。如果你确定之前已经安装了gRPC并且文件确实丢失了，你可以尝试重新安装gRPC来恢复缺失的文件。 如果以上方法都无法解决问题，你可以尝试以下几个相关问题：
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值