Android中GRPC的使用-拦截器

最新推荐文章于 2024-06-07 22:09:29 发布
最新推荐文章于 2024-06-07 22:09:29 发布
阅读量7.2k 收藏 1
点赞数 2
分类专栏： grpc Android Java 文章标签： android 服务器 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qtiao/article/details/128393577
版权
Android 同时被 3 个专栏收录
9 篇文章 0 订阅
订阅专栏
grpc
0 篇文章 0 订阅
订阅专栏
Java
0 篇文章 0 订阅
订阅专栏

        在构建GRPC应用程序时，无论是客户端应用程序，还是服务端应用程序，在远程方法执行之前后之后，都可能需要执行一些通用逻辑。在GRPC中可以拦截RPC的执行，来满足特定的需求，如日志、认证、性能度量指标等，这会使用一种名为拦截器的扩展机制。GRPC提供了简单的API，用来在客户端和服务器端的GRPC应用程序中实现拦截器。根据所拦截的RPC调用的类型，GRPC拦截器可风味两类：客户端拦截器和服务端拦截。

       注意：本篇文章的demo是基于Android中GRPC的使用-4种通信模式使用的demo上实现的。

客户端拦截器

        当客户端发起RPC来触发GRPC服务的远程方法时，可以在客户端拦截这些RPC，也可以添加多个拦截器分别对不能的需求进行拦截。拦截器流程如下所示：

源码分析

        以一元RPC为例，首先进入getOrderByUnary方法，在这个方法中，调用了getChannel().newCall，通过源码分析，getChannel的是ManagedChannelImpl的实例，在ManagedChannelImpl中，我们的过newCall可以找到Channel正真的实现类，代码如下：

realChannel = new RealChannel(nameResolver.getServiceAuthority());
    Channel channel = realChannel;
    if (builder.binlog != null) {
      channel = builder.binlog.wrapChannel(channel);
    }
    this.interceptorChannel = ClientInterceptors.intercept(channel, interceptors);

        可以看到首先实例化一个 RealChannel对象，之后再通过ClientInterceptors.intercept方法构建拦截器链，intercept实现如下：

 Preconditions.checkNotNull(channel, "channel");
    for (ClientInterceptor interceptor : interceptors) {
      channel = new InterceptorChannel(channel, interceptor);
    }
    return channel;

            通过 InterceptorChannel将当前拦截器与下一个Channel关联起来，而InterceptorChannel中的newCall方法调用了interceptor中的interceptCall，具体代码如下：

 public <ReqT, RespT> ClientCall<ReqT, RespT> newCall(
        MethodDescriptor<ReqT, RespT> method, CallOptions callOptions) {
      return interceptor.interceptCall(method, callOptions, channel);
    }

        之后通过这种链式调用 ，构建一条拦截的器请求链。我们在getOrderByUnary发现，改方法还调用了asyncUnaryCall，通过asyncUnaryCall方法的调用，最终发现调用了asyncUnaryRequestCall，代码如下：

private static <ReqT, RespT> void asyncUnaryRequestCall(
      ClientCall<ReqT, RespT> call,
      ReqT req,
      StartableListener<RespT> responseListener) {
    startCall(call, responseListener);
    try {
      call.sendMessage(req);
      call.halfClose();
    } catch (RuntimeException e) {
      throw cancelThrow(call, e);
    } catch (Error e) {
      throw cancelThrow(call, e);
    }
  }

        可以发现，首先调用了 startCall，在startCall中最后调用的是ClientCall中的start方法，而在拦截器中，我们调用了下一个拦截器中的ClientCall中的start方法，代码如下：

super.start(new ForwardingClientCallListener.SimpleForwardingClientCallListener<RespT>(responseListener) {
                        @Override
                        public void onHeaders(Metadata headers) {
                            // 服务端传递回来的header
                            Log.d(TAG," interceptCall : onHeaders = " + headers);
                            super.onHeaders(headers);
                        }

                        @Override
                        public void onClose(Status status, Metadata trailers) {
                            Log.d(TAG," interceptCall : onClose status = " + status ) ;
                            super.onClose(status, trailers);
                        }

                        @Override
                        public void onMessage(RespT message) {
                            Log.d(TAG," interceptCall : onMessage message = " + message);
                            super.onMessage(message);
                        }

                        @Override
                        public void onReady() {
                            Log.d(TAG," interceptCall : onReady");
                            super.onReady();
                        }
                    }, headers);

         最后会调用RealChannel中的ClientCall，该类的ClientCall为ClientCallImpl，至此拦截器的监听链建立完成，具体代码中的类调用关系如下所示：

 

代码实现

        添加两个拦截器的：MyClientInterceptor、MyClient2Interceptor，具体实现如下：

public class MyClientInterceptor implements ClientInterceptor {
    private final String TAG = "MyClientInterceptor";
    private static final Metadata.Key<String> TOKEN = Metadata.Key.of("token", Metadata.ASCII_STRING_MARSHALLER);

    @Override
    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {

        return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {

            @Override
            public void start(Listener<RespT> responseListener, Metadata headers) {
                // 客户端传递链路追中数据，将数据放到headers中
                Log.d(TAG," interceptCall : currentThreadName = "+Thread.currentThread().getName()+"start = " + headers );
                headers.put(TOKEN, "A2D05E5ED2414B1F8C6AEB19F40EF77C");
                try{
                    super.start(new ForwardingClientCallListener.SimpleForwardingClientCallListener<RespT>(responseListener) {
                        @Override
                        public void onHeaders(Metadata headers) {
                            // 服务端传递回来的header
                            Log.d(TAG," interceptCall : onHeaders = " + headers);
                            super.onHeaders(headers);
                        }

                        @Override
                        public void onClose(Status status, Metadata trailers) {
                            Log.d(TAG," interceptCall : onClose status = " + status);
                            super.onClose(status, trailers);
                        }

                        @Override
                        public void onMessage(RespT message) {
                            Log.d(TAG," interceptCall : onMessage message = " + message);
                            super.onMessage(message);
                        }



                    }, headers);
                }catch (Exception e){
                    Log.d(TAG," interceptCall : err = " + e.getMessage());
                }

            }

            @Override
            public void sendMessage(ReqT message) {
                Log.d(TAG," interceptCall : sendMessage currentThreadName = "+Thread.currentThread().getName()+ "message = " + message );
                super.sendMessage(message);
            }

            @Override
            public void cancel(@Nullable String message, @Nullable Throwable cause) {
                Log.d(TAG," interceptCall : currentThreadName = "+Thread.currentThread().getName()+" cancel  message = " + message + " " + cause.getMessage());
                super.cancel(message, cause);
            }
        };

    }
public class MyClient2Interceptor implements ClientInterceptor {
    private final String TAG = "MyClient2Interceptor";
    private static final Metadata.Key<String> TOKEN = Metadata.Key.of("token", Metadata.ASCII_STRING_MARSHALLER);

    @Override
    public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method, CallOptions callOptions, Channel next) {

        return new ForwardingClientCall.SimpleForwardingClientCall<ReqT, RespT>(next.newCall(method, callOptions)) {

            @Override
            public void start(Listener<RespT> responseListener, Metadata headers) {
                // 客户端传递链路追中数据，将数据放到headers中
                Log.d(TAG," interceptCall : currentThreadName = "+Thread.currentThread().getName()+"start = " + headers );
                headers.put(TOKEN, "A2D05E5ED2414B1F8C6AEB19F40EF77C");
                try{
                    super.start(new ForwardingClientCallListener.SimpleForwardingClientCallListener<RespT>(responseListener) {
                        @Override
                        public void onHeaders(Metadata headers) {
                            // 服务端传递回来的header
                            Log.d(TAG," interceptCall : onHeaders = " + headers);
                            super.onHeaders(headers);
                        }

                        @Override
                        public void onClose(Status status, Metadata trailers) {
                            Log.d(TAG," interceptCall : onClose status = " + status);
                            super.onClose(status, trailers);
                        }

                        @Override
                        public void onMessage(RespT message) {
                            Log.d(TAG," interceptCall : onMessage message = " + message);
                            super.onMessage(message);
                        }



                    }, headers);
                }catch (Exception e){
                    Log.d(TAG," interceptCall : err = " + e.getMessage());
                }

            }

            @Override
            public void sendMessage(ReqT message) {
                Log.d(TAG," interceptCall : sendMessage currentThreadName = "+Thread.currentThread().getName()+ "message = " + message );
                super.sendMessage(message);
            }

            @Override
            public void cancel(@Nullable String message, @Nullable Throwable cause) {
                Log.d(TAG," interceptCall : currentThreadName = "+Thread.currentThread().getName()+" cancel  message = " + message + " " + cause.getMessage());
                super.cancel(message, cause);
            }
        };

    }
}

        给ManagedChannelBuilder添加拦截器，代码如下：

.intercept(new MyClientInterceptor(),new MyClient2Interceptor())

运行结果

        以一元RPC为例，运行结果如下：

2022-12-21 11:12:56.728 24644-24930/com.reactnative.grpcserverdemo D/MyClient2Interceptor:  interceptCall : currentThreadName = pool-3-thread-1start = Metadata()
2022-12-21 11:12:56.729 24644-24930/com.reactnative.grpcserverdemo D/MyClientInterceptor:  interceptCall : currentThreadName = pool-3-thread-1start = Metadata(token=A2D05E5ED2414B1F8C6AEB19F40EF77C)
2022-12-21 11:12:56.744 24644-24930/com.reactnative.grpcserverdemo D/MyClient2Interceptor:  interceptCall : sendMessage currentThreadName = pool-3-thread-1message = # com.google.protobuf.StringValue@7c65f
    value: "0"
2022-12-21 11:12:56.746 24644-24930/com.reactnative.grpcserverdemo D/MyClientInterceptor:  interceptCall : sendMessage currentThreadName = pool-3-thread-1message = # com.google.protobuf.StringValue@7c65f
    value: "0"
2022-12-21 11:12:57.251 24644-24935/com.reactnative.grpcserverdemo D/MyClientInterceptor:  interceptCall : onHeaders = Metadata(content-type=application/grpc,grpc-encoding=identity,grpc-accept-encoding=gzip)
2022-12-21 11:12:57.251 24644-24935/com.reactnative.grpcserverdemo D/MyClient2Interceptor:  interceptCall : onHeaders = Metadata(content-type=application/grpc,grpc-encoding=identity,grpc-accept-encoding=gzip)
2022-12-21 11:12:57.291 24644-24935/com.reactnative.grpcserverdemo D/MyClientInterceptor:  interceptCall : onMessage message = # order.OrderManagementOuterClass$Order@2e3553
    id: "0-1"
2022-12-21 11:12:57.293 24644-24935/com.reactnative.grpcserverdemo D/MyClient2Interceptor:  interceptCall : onMessage message = # order.OrderManagementOuterClass$Order@2e3553
    id: "0-1"
2022-12-21 11:12:57.296 24644-24935/com.reactnative.grpcserverdemo D/MyClientInterceptor:  interceptCall : onClose status = Status{code=OK, description=null, cause=null}
2022-12-21 11:12:57.297 24644-24935/com.reactnative.grpcserverdemo D/MyClient2Interceptor:  interceptCall : onClose status = Status{code=OK, description=null, cause=null}

服务端拦截器

        当客户端调用GRPC服务的远程方法时，通过使用服务器端的拦截器，可以在执行远程方法之前，执行一个通用的逻辑。当需要在调用远程方法之前应用认证等特性时，会非常有帮助。也可以添加多个拦截器，分别对不同的功能进行认证。其拦截流程如下：

代码实现

        添加两个拦截器的：MyServerInterceptor、MyServer2Interceptor，具体实现如下：

public class MyServerInterceptor implements ServerInterceptor {
    private final String TAG = "MyServerInterceptor";
    @Override
    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
        Log.d(TAG," interceptCall : headers = " + headers);
        ServerCall.Listener<ReqT> delegate = next.startCall(new ForwardingServerCall.SimpleForwardingServerCall<ReqT, RespT>(call) {
            @Override
            public void sendHeaders(Metadata headers) {
                Log.d(TAG, " interceptCall response : sendHeaders = " + headers);
                super.sendHeaders(headers);
            }

            @Override
            public void sendMessage(RespT message) {
                Log.d(TAG, " interceptCall response : sendMessage = " + headers);
                super.sendMessage(message);
            }

        }, headers);


        return new ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT>(delegate) {
            @Override
            public void onMessage(ReqT message) {
                super.onMessage(message);
                Log.d(TAG," interceptCall request : onMessage message = " + message);
            }

            @Override
            public void onReady() {
                super.onReady();
                Log.d(TAG," interceptCall request : onReady");
            }

            @Override
            public void onCancel() {
                super.onCancel();
                Log.d(TAG," interceptCall request : onCancel");
            }

            @Override
            public void onComplete() {
                super.onComplete();
                Log.d(TAG," interceptCall request : onComplete");
            }
        };

    }
public class MyServer2Interceptor implements ServerInterceptor {
    private final String TAG = "MyServer2Interceptor";
    @Override
    public <ReqT, RespT> ServerCall.Listener<ReqT> interceptCall(ServerCall<ReqT, RespT> call, Metadata headers, ServerCallHandler<ReqT, RespT> next) {
        Log.d(TAG," interceptCall : headers = " + headers);

        ServerCall.Listener<ReqT> delegate = next.startCall(new ForwardingServerCall.SimpleForwardingServerCall<ReqT, RespT>(call) {
            @Override
            public void sendHeaders(Metadata headers) {
                Log.d(TAG, " interceptCall response : sendHeaders = " + headers);
                super.sendHeaders(headers);
            }

            @Override
            public void sendMessage(RespT message) {
                Log.d(TAG, " interceptCall response : sendMessage = " + headers);
                super.sendMessage(message);
            }

        }, headers);


        return new ForwardingServerCallListener.SimpleForwardingServerCallListener<ReqT>(delegate) {
            @Override
            public void onMessage(ReqT message) {
                super.onMessage(message);
                Log.d(TAG," interceptCall request : onMessage message = " + message);
            }

            @Override
            public void onReady() {
                super.onReady();
                Log.d(TAG," interceptCall request : onReady");
            }

            @Override
            public void onCancel() {
                super.onCancel();
                Log.d(TAG," interceptCall request : onCancel");
            }

            @Override
            public void onComplete() {
                super.onComplete();
                Log.d(TAG," interceptCall request : onComplete");
            }
        };
    }
}

运行结果

        以一元RPC为例，运行结果如下：

2022-12-29 15:20:54.257 3345-3804/com.reactnative.grpcserverdemo D/MyServer2Interceptor:  interceptCall : headers = Metadata(user-agent=grpc-java-okhttp/1.42.0,content-type=application/grpc,token=A2D05E5ED2414B1F8C6AEB19F40EF77C,token=A2D05E5ED2414B1F8C6AEB19F40EF77C,grpc-accept-encoding=gzip)
2022-12-29 15:20:54.258 3345-3804/com.reactnative.grpcserverdemo D/MyServerInterceptor:  interceptCall : headers = Metadata(user-agent=grpc-java-okhttp/1.42.0,content-type=application/grpc,token=A2D05E5ED2414B1F8C6AEB19F40EF77C,token=A2D05E5ED2414B1F8C6AEB19F40EF77C,grpc-accept-encoding=gzip)
2022-12-29 15:20:54.262 3345-3804/com.reactnative.grpcserverdemo D/MyServerInterceptor:  interceptCall request : onReady
2022-12-29 15:20:54.262 3345-3804/com.reactnative.grpcserverdemo D/MyServer2Interceptor:  interceptCall request : onReady
2022-12-29 15:20:54.277 3345-3804/com.reactnative.grpcserverdemo D/MyServerInterceptor:  interceptCall request : onMessage message = # com.google.protobuf.StringValue@7c65f
    value: "0"
2022-12-29 15:20:54.278 3345-3804/com.reactnative.grpcserverdemo D/MyServer2Interceptor:  interceptCall request : onMessage message = # com.google.protobuf.StringValue@7c65f
    value: "0"
2022-12-29 15:20:54.280 3345-3804/com.reactnative.grpcserverdemo D/MyServerInterceptor:  interceptCall response : sendHeaders = Metadata()
2022-12-29 15:20:54.281 3345-3804/com.reactnative.grpcserverdemo D/MyServer2Interceptor:  interceptCall response : sendHeaders = Metadata()
2022-12-29 15:20:54.303 3345-3804/com.reactnative.grpcserverdemo D/MyServerInterceptor:  interceptCall response : sendMessage = Metadata(user-agent=grpc-java-okhttp/1.42.0,content-type=application/grpc,token=A2D05E5ED2414B1F8C6AEB19F40EF77C,token=A2D05E5ED2414B1F8C6AEB19F40EF77C,grpc-accept-encoding=gzip)
2022-12-29 15:20:54.304 3345-3804/com.reactnative.grpcserverdemo D/MyServer2Interceptor:  interceptCall response : sendMessage = Metadata(user-agent=grpc-java-okhttp/1.42.0,content-type=application/grpc,token=A2D05E5ED2414B1F8C6AEB19F40EF77C,token=A2D05E5ED2414B1F8C6AEB19F40EF77C,grpc-accept-encoding=gzip)
2022-12-29 15:20:54.332 3345-3804/com.reactnative.grpcserverdemo D/MyServerInterceptor:  interceptCall request : onComplete
2022-12-29 15:20:54.332 3345-3804/com.reactnative.grpcserverdemo D/MyServer2Interceptor:  interceptCall request : onComplete

最后附上demo下载地址

坚强的小水滴
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
22.gRPC框架设计思想
杨充
10-16 3327
03.视频播放器Api说明 目录介绍 01.最简单的播放 02.如何切换视频内核 03.切换视频模式 04.切换视频清晰度 05.视频播放监听 06.列表中播放处理 07.悬浮窗口播放 08.其他重要功能Api 09.播放多个视频 10.VideoPlayer相关Api 11.Controller相关Api 12.边播放边缓存api 13.类似抖音视频预加载 14.视频播放器埋点 00.视频播放器通用框架 基础封装视频播放器player，可以在ExoPlayer、MediaPlayer，声网RTC视频
抖音直播间数据采集，ProtoBuf + gRPC 分析请求头
dididi
08-31 3643
抖音直播间数据采集，ProtoBuf + gRPC 分析请求头 概念 Protobuf是Google protocol buffer的简称，是一种语言中立、平台无关、易于扩展的结构化数据序列化技术，可用于数据传输、存储等领域。 与Protoful类似的序列化技术还有XML、JSON、Thrift等，但Protoful更快、更小、更简单，且具备良好的兼容性。 目前经常运用在 安卓直播弹幕等业务场景中 了解更多短视频直播数据采集分析接口请点击查看接口文档 配置请求头 方法1 只设置客户端请求时附带的h
Android 设置拦截器拦截部分接口
最新发布
牛肉胡辣汤
06-07 1276
拦截器是 OkHttp 库中的一个重要概念，它允许我们在发送请求和接收响应的过程中对网络请求进行拦截和修改。拦截器可以用于添加、修改或者移除请求头、响应头，修改请求体或者响应体等操作。通过设置拦截器，我们可以在 Android 应用程序中方便地拦截部分接口的网络请求，并对其进行统一处理。这种方式能够提高代码的可维护性和扩展性，同时也能够降低重复代码的编写量，是 Android 开发中常用的技巧之一。
Android上使用grpc的方法教程
08-30
主要给大家介绍了在Android上使用grpc的方法教程，文中通过示例代码给大家详细介绍了在android上使用grpc的方法以及可能遇到的种种问题的解决方法，对大家具有一定的参考学习价值，需要的朋友们下面来一起看看吧。
android gRPC 简单使用
11-25 3294
gRPC 可以像调用方法一样进行网络请求 github地址：https://github.com/grpc/grpc-java 使用： 1.proto文件放置到 src/main/proto 2. module gradle配置 plugins { ... id 'com.google.protobuf' } android { ... } protobuf { protoc { artifact = 'com.google.protobuf:protoc:3.17.2' }
grpc android. 简书,gRPC & Android-Go语言中文社区
weixin_35126200的博客
06-05 139
什么是 RPCgRPC的官方Demohttp://www.grpc.io/docs/quickstart/android.html#update-a-grpc-servicegit clone -b v1.0.0 https://github.com/grpc/grpc-javacd grpc-java/examples./gradlew installDist./build/install/ex...
grpc android. 简书,（android端）GRPC的使用和MVC模式封装-Go语言中文社区
weixin_35997546的博客
06-05 564
GRPC是google开源的一个高性能、跨语言的RPC框架，基于HTTP2协议,基于protobuf来声明数据模型和RPC接口服务。想直接撸代码的直接通过传送门吧。(还有下面的都是图文混合，对于要配置项目，最快的方式，去github里面获取)先看看这张大图：图1现在来说说在Android这边的使用：配置Gradle相关：在moudle为app里面的Gradle 的android{}里面加上如下：p...
gRPC请求中对header进行处理
热门推荐
Kido is a boy...
08-07 1万+
gRPC请求设置header(Android、iOS、JavaServer)1.[Android (Java)]1.1只设置客户端请求时附带的header见类 io.grpc.stub.MetadataUtils，其中有个方法: /** * Attaches a set of request headers to a stub. * * @param stub to bind t
Android网络优化基础操作攻略（DNS解析，连接复用，Response Cache，数据压缩，弱网，网络安全，监控）
CallmeZhe的博客
01-14 677
做网络优化，首先我们要这个流程有一定的认识，
Android 配置好的 grpc
11-14
Android 配置好的 grpc 里面有gitee 链接 也可以直接下载
AndroidGRPC:gRPC android的简单示例
04-30
适用于Android的GRPC演示 越来越流行，并且比JSON更快地与服务器通信。 这是一个演示如何在Android应用程序中实现gRPC的项目。 此项目的后端应用程序。 关于教程和相关文章。
android gRPC 简单使用（csdn）————程序.pdf
12-01
android gRPC 简单使用（csdn）————程序
记录自己在厦门两年来的面试经历--完结篇
m0_67394230的博客
07-23 1714
芜湖首先简单说明一下，笔者是为19年6月份毕业，从事JAVA开发，18年11月份开始实习工作，本文主要描述一下这两年多的面试经历，帮助还未毕业或者准备找工作的兄弟萌了解一下厦门的一些公司情况（主要在软件园二期）。实习期：数据谷 — 没下文 软件园望海路那边，公司主要做医疗方向的软件开发,厦门研发这边规模不大，二三十个人，常年都有JAVA开发实习生岗位,整体薪资比较低，笔者只参加过面试，面试内容整体还是根据简历来，多线程问的比较多,还记得实习生岗位的时候问了一个问题:给你两亿的数据，要求从一台电脑移植到另外一
gRPC on Kotlin Android
xiaokangss的博客
03-30 1127
gRPC 是由 Google 开发的高性能、开源的远程过程调用（RPC）框架，它基于 HTTP/2 协议进行通信，并使用 Protocol Buffers 作为默认的序列化工具。gRPC 支持多种编程语言，包括 C、C++、Java、Python、Go、C# 等，使得开发者可以在不同的平台上轻松地构建分布式系统。
Android中使用GRPC简明教程
haohulala的博客
02-25 3543
这里最好根据你自己的配置文件，然后对比看看和上述文件有哪些缺失的信息，一般只需要添加缺失的信息即可，如果完全照搬上面的内容可能导致项目报错，因为里面记录了你本身的项目信息，可能和我的项目信息产生冲突。双向流模式是最后一种，也是最常用的一种，在这种模式中，客户端和服务端的通信没有什么限制，是比较理想的通信模式，应用场景也最为广泛，因为在这种模式中，你也可以只发送一个数据包。GRPC针对不同的业务场景，一共提供了四种通信模式，分别是简单一元模式，客户端流模式，服务端流模式和双向流模式，接下来这个进行介绍。
grpc android客户端,记一次技术调研(二): Android 应用实现 gRPC 调用
weixin_35964787的博客
05-30 450
问题在手机应用的开发中，通常会将复杂的业务逻辑层实现放在服务端，客户端仅负责表现层。但是对于某些手机应用而言，业务逻辑的实现位于服务端反而是不安全的或是不合理的，而是需要将其逻辑直接在手机端实现。目的面对不同系统的手机客户端，单独重复实现相同的业务逻辑，并非最佳实践。如何通过第三方语言 Go 语言将业务逻辑封装成库的形式，并以静态打包的方式提供给不同系统的手机客户端使用，是本次调研的目的。理想...
聊一聊 gRPC 中的拦截器
江南一点雨的专栏
02-15 1047
今天我们继续 gRPC 系列。今天我们来继续聊一聊 gRPC 中的拦截器。有请求的发送、处理，当然就会有拦截器的需求，例如在服务端通过拦截器统一进行请求认证等操作，这些就需要拦截器来完成，今天松哥先和小伙伴们来聊一聊 gRPC 中拦截器的基本用法，后面我再整一篇文章和小伙伴们做一个基于拦截器实现的 JWT 认证的 gRPC。我们分别来看。
android 使用grpc
10-10
在 Android 中使用 gRPC，您需要进行以下步骤： 1. 在您的 Android 项目中添加 gRPC 和 protobuf 的依赖项。您可以在项目的 build.gradle 文件中添加以下代码： ``` implementation 'io.grpc:grpc-okhttp:1.40.1' implementation 'io.grpc:grpc-protobuf-lite:1.40.1' implementation 'io.grpc:grpc-stub:1.40.1' implementation 'com.google.protobuf:protobuf-java:3.18.0' ``` 2. 定义您的 gRPC 服务和消息类型的.proto 文件。您可以使用 Protocol Buffers 语言来定义它们。例如，创建一个名为 "example.proto" 的文件，并在其中定义服务和消息类型。 示例 "example.proto" 文件内容： ```protobuf syntax = "proto3"; package com.example.grpc; service ExampleService { rpc ExampleMethod (ExampleRequest) returns (ExampleResponse) {} } message ExampleRequest { string message = 1; } message ExampleResponse { string reply = 1; } ``` 3. 在您的项目中运行 Protocol Buffers 编译器，以生成 Java 类。您可以使用 `protoc` 命令行工具或 Gradle 插件来完成此操作。例如，使用 Gradle 插件可以在项目的 build.gradle 文件中添加以下代码： ``` protobuf { protoc { artifact = 'com.google.protobuf:protoc:3.18.0' } plugins { grpc { artifact = 'io.grpc:protoc-gen-grpc-java:1.40.1' } } generateProtoTasks { all()*.plugins { grpc {} } } } ``` 然后，在命令行中运行 `./gradlew generateProto` 命令，以生成 Java 类。 4. 创建 gRPC 客户端代码。您可以使用生成的 Java 类来创建客户端代码，并与 gRPC 服务进行通信。在您的 Android 项目中，您可以创建一个 gRPC 客户端类，以处理与服务器的通信。 示例 gRPC 客户端类： ```java import com.example.grpc.ExampleRequest; import com.example.grpc.ExampleResponse; import com.example.grpc.ExampleServiceGrpc; import io.grpc.ManagedChannel; import io.grpc.ManagedChannelBuilder; import io.grpc.stub.StreamObserver; public class GrpcClient { private final ManagedChannel channel; private final ExampleServiceGrpc.ExampleServiceStub stub; public GrpcClient(String host, int port) { channel = ManagedChannelBuilder.forAddress(host, port) .usePlaintext() .build(); stub = ExampleServiceGrpc.newStub(channel); } public void callExampleMethod(String message, StreamObserver<ExampleResponse> responseObserver) { ExampleRequest request = ExampleRequest.newBuilder() .setMessage(message) .build(); stub.exampleMethod(request, responseObserver); } public void shutdown() throws InterruptedException { channel.shutdown().awaitTermination(5, TimeUnit.SECONDS); } } ``` 这是一个简单的示例，演示了如何创建 gRPC 客户端并调用服务的方法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值