Spring boot 整合grpc 运用

已于 2023-11-13 17:45:07 修改
阅读量757 收藏 1
点赞数 1
文章标签： spring boot qt 后端
于 2023-11-10 11:05:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hesqlplus730/article/details/134326883
版权

文章目录

GRPC基础概念：

  • GRPC是google开源的一个高性能、跨语言的RPC框架，基于HTTP2协议，基于protobuf 3.x，基于Netty 4.x.

Protocol Buffers：

  • 一个跨语言、跨平台的具有可扩展机制的序列化数据工具。也就是说，我在ubuntu下用python语言序列化一个对象，并使用http协议传输到使用java语言的android客户端，java使用对用的代码工具进行反序列化，也可以得到对应的对象
    1

proto 基础语法：

//指定proto3语法
syntax = "proto3";
//指定作用域
package xxx;
//java_multiple_files = true; 表示在生成Java代码时，每个`.proto`文件都会生成一个独立的Java文件
//声明 rpc 服务接口
//关键字: service 声明需要生成的服务接口"类"
service Greeter {
    // 关键字: rpc 声明服务方法,包括方法名、请求消息(请求体)、相应消息(响应体)
    rpc SayHello(HelloRequest) returns (HelloResponse);
}
//声明请求、响应消息
//关键字: message 声明请求体和响应体
message HelloRequest {
		//标识号 1
    //编号的范围为1 ~ 536,870,911(2^29-1)，其中19000~19999不可用。因为Protobuf协议的实现过程中对预留了这些编号
    string name = 1;
		//表示一个人有多个号码
	  repeated string phone = 3;
}
 
message HelloResponse {
    string message = 1;
}
调用类型：

  • Unary RPC 一元RPC调用，也叫简单RPC调用

    rpc SayHello(HelloRequest) returns (HelloResponse);

  • 【服务端 Server Stream RPC】流式RPC. 客户端向服务端发送单个请求，服务端以流的方式返回一系列消息。客户端从流中读取消息，直到没有更多的消息。当然，返回的消息当然不是乱序的，gRPC保证单个请求中的消息顺序

    rpc LotsOfReplies(HelloRequest) returns (stream HelloResponse);

  • 【客户端 Client Stream RPC】流式RPC调用。客户端向服务端请求一系列的消息，一旦客户端完成消息写入，就会等待服务端读取所有消息并处理它们。gRPC同样会保证单个请求中消息的顺序性

    rpc LotsOfGreetings(stream HelloRequest) returns (HelloResponse);

  • 【双向流式调用 Bidirectional Streaming RPC】就是客户端和服务端均以流的方式进行读写消息。这两个流式完全独立的，因此，服务端和客户端可以按照他们喜欢的方式写入和读取流。比如：服务端可以在等待所有的客户端消息发送到后，再处理；也可以交替读取请求、写入响应信息等。当然，每个流中的消息顺序是可以保证的。

    rpc BidiHello(stream HelloRequest) returns (stream HelloResponse);

    Channels通道

    gRPC通道提供了一条链接到指定主机和端口号的服务端的链接。他在创建客户端stub的时候使用。客户端可以指定通道参数来修改gRPC的默认行为，例如：打开或者关闭消息压缩。一个通道是有连接和空闲两个状态的

mvn 插件整合，proto编译，生成代码

<build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>

            <!-- 生成插件 -->
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:3.5.1:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.11.0:exe:${os.detected.classifier}</pluginArtifact>
                    <protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
                    <!--设置grpc生成代码到指定路径-->
                    <outputDirectory>${project.basedir}/src/main/java</outputDirectory>
                    <!--生成代码前是否清空目录-->
                    <clearOutputDirectory>false</clearOutputDirectory>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>

        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.2</version>
            </extension>
        </extensions>

    </build>

在这里插入图片描述

Spring boot 整合 grpc

大致流程：
1

项目结构：

在这里插入图片描述

整合代码：

父 pom
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.7.17</version>
    <relativePath/> <!-- lookup parent from repository -->
  </parent>

  <groupId>com.xiaoshu</groupId>
  <artifactId>grpc-demo</artifactId>
  <version>1.0-SNAPSHOT</version>
  <packaging>pom</packaging>

  <name>grpc-demo</name>
  <modules>
    <module>grpc-server</module>
    <module>grpc-client</module>
    <module>grpc-proto</module>
  </modules>

  <properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
    <java.version>1.8</java.version>
    <grpc.version>2.15.0.RELEASE</grpc.version>
  </properties>

  <!-- 通用依赖 -->
  <dependencies>

    <dependency>
      <groupId>org.projectlombok</groupId>
      <artifactId>lombok</artifactId>
      <version>1.18.10</version>
      <scope>provided</scope>
    </dependency>

    <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

  </dependencies>

  <dependencyManagement>
    <dependencies>

      <dependency>
        <groupId>net.devh</groupId>
        <artifactId>grpc-spring-boot-starter</artifactId>
        <version>${grpc.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>

      <dependency>
        <groupId>net.devh</groupId>
        <artifactId>grpc-server-spring-boot-starter</artifactId>
        <version>${grpc.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>

      <dependency>
        <groupId>net.devh</groupId>
        <artifactId>grpc-client-spring-boot-starter</artifactId>
        <version>${grpc.version}</version>
        <type>pom</type>
        <scope>import</scope>
      </dependency>

    </dependencies>

  </dependencyManagement>


  <build>

    <plugins>
      <plugin>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
    </plugins>

  </build>

</project>
proto 模块
syntax = "proto3";

package com.ht.meta;
// 生成类的包名
option java_multiple_files = true;
// 生成代码位置
option java_package = "com.meta";
// 定义的所有消息、枚举和服务生成对应的多个类文件，而不是以内部类的形式出现
option java_outer_classname = "HtMetaInfoSyncProto";

service HtMetaInfoSyncService {
  rpc syncMeta (HtMetaSyncRequest) returns (HtMetaSyncResponse) {}
}

//同步类型
enum SyncType {
  ADD  = 0; // 新增
  DEL  = 1; // 删除
  EDIT = 2; // 修改
}

//同步Request
message HtMetaSyncRequest {
  //json内容
  string syncJson = 1;
  //同步类型
  SyncType syncType = 2;
}

//响应Response
message HtMetaSyncResponse {
  //响应码
  string code = 1;
  //提示
  string msg = 2;
}

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.xiaoshu</groupId>
        <artifactId>grpc-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>grpc-proto</artifactId>
    <packaging>jar</packaging>

    <name>grpc-proto</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>
        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-spring-boot-starter</artifactId>
            <version>${grpc.version}</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <configuration>
                    <excludes>
                        <exclude>
                            <groupId>org.projectlombok</groupId>
                            <artifactId>lombok</artifactId>
                        </exclude>
                    </excludes>
                </configuration>
            </plugin>

            <!-- 生成插件 -->
            <plugin>
                <groupId>org.xolstice.maven.plugins</groupId>
                <artifactId>protobuf-maven-plugin</artifactId>
                <version>0.6.1</version>
                <configuration>
                    <protocArtifact>com.google.protobuf:protoc:3.5.1:exe:${os.detected.classifier}</protocArtifact>
                    <pluginId>grpc-java</pluginId>
                    <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.11.0:exe:${os.detected.classifier}</pluginArtifact>
                    <protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
                    <!--设置grpc生成代码到指定路径-->
                    <outputDirectory>${project.basedir}/src/main/java</outputDirectory>
                    <!--生成代码前是否清空目录-->
                    <clearOutputDirectory>false</clearOutputDirectory>
                </configuration>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>compile-custom</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>

        </plugins>

        <extensions>
            <extension>
                <groupId>kr.motd.maven</groupId>
                <artifactId>os-maven-plugin</artifactId>
                <version>1.6.2</version>
            </extension>
        </extensions>

    </build>


</project>
服务端：
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.xiaoshu</groupId>
        <artifactId>grpc-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>grpc-server</artifactId>
    <packaging>jar</packaging>

    <name>grpc-server</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

        <dependency>
            <groupId>com.xiaoshu</groupId>
            <artifactId>grpc-proto</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-server-spring-boot-starter</artifactId>
            <version>${grpc.version}</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>

        <!-- fastjson -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>

    </dependencies>

</project>


server:
  port: 8080

spring:
  application:
    name: spring-boot-grpc-server

# gRPC有关的配置，这里只需要配置服务端口号
grpc:
  server:
    port: 9898

服务端代码：

import com.meta.HtMetaInfoSyncServiceGrpc;
import com.meta.HtMetaSyncRequest;
import com.meta.HtMetaSyncResponse;
import com.meta.SyncType;
import com.util.JsonUtil;
import com.vo.HtMetaClusterInfoVo;
import io.grpc.stub.StreamObserver;
import lombok.extern.slf4j.Slf4j;
import net.devh.boot.grpc.server.service.GrpcService;
import java.util.List;

/**
 * @author 何永豪
 * @className HtMetaSyncService
 * @description TODO
 * @date 2023/11/6 15:25
 */
@Slf4j
@GrpcService
public class HtMetaSyncService extends HtMetaInfoSyncServiceGrpc.HtMetaInfoSyncServiceImplBase {

    @Override
    public void syncMeta(HtMetaSyncRequest request, StreamObserver<HtMetaSyncResponse> responseObserver) {
        String syncJson = request.getSyncJson();
        log.info("接收到json：{}",syncJson);
        List<HtMetaClusterInfoVo> list = JsonUtil.toList(syncJson, HtMetaClusterInfoVo.class);
        SyncType syncType = request.getSyncType();
        int number = syncType.getNumber();
        log.info("同步类型：{}",number);
        HtMetaSyncResponse syncResponse = HtMetaSyncResponse.newBuilder()
                .setCode("1000")
                .setMsg("同步成功").build();
        responseObserver.onNext(syncResponse);
        responseObserver.onCompleted();
    }

}
客户端：
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>com.xiaoshu</groupId>
        <artifactId>grpc-demo</artifactId>
        <version>1.0-SNAPSHOT</version>
    </parent>

    <artifactId>grpc-client</artifactId>
    <packaging>jar</packaging>

    <name>grpc-client</name>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    </properties>

    <dependencies>

        <dependency>
            <groupId>com.xiaoshu</groupId>
            <artifactId>grpc-proto</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>net.devh</groupId>
            <artifactId>grpc-client-spring-boot-starter</artifactId>
            <version>${grpc.version}</version>
        </dependency>

    </dependencies>

</project>

yml

server:
  port: 8088

spring:
  application:
    name: local-client

grpc:
  client:
    # gRPC配置的名字，GrpcClient注解会用到
    local-grpc-server:
      # gRPC服务端地址
      address: 'static://127.0.0.1:9898'
      enableKeepAlive: true
      keepAliveWithoutCalls: true
      #认证类型，无加密
      negotiationType: plaintext

客户端stub

import com.meta.HtMetaInfoSyncServiceGrpc;
import com.meta.HtMetaSyncRequest;
import com.meta.HtMetaSyncResponse;
import com.meta.SyncType;
import io.grpc.StatusRuntimeException;
import net.devh.boot.grpc.client.inject.GrpcClient;
import org.springframework.stereotype.Service;

/**
 * @author xiaoshu
 */
@Service
public class HtMetaInfoSyncClient {

    @GrpcClient("local-grpc-server")
    private HtMetaInfoSyncServiceGrpc.HtMetaInfoSyncServiceBlockingStub stub;


    public String syncMeta(final String json,final SyncType syncType) {
        try {
            HtMetaSyncResponse htMetaSyncResponse = stub.syncMeta((
                    HtMetaSyncRequest.newBuilder()
                            .setSyncJson(json)
                            .setSyncType(syncType)
                            .build()));
            String code = htMetaSyncResponse.getCode();
            String msg = htMetaSyncResponse.getMsg();
            return code+":"+msg;
        } catch (final StatusRuntimeException e) {
            return "FAILED with " + e.getStatus().getCode().name();
        }
    }

}
实际调用：
@Autowired
private HtMetaInfoSyncClient htMetaInfoSyncClient;

@RequestMapping("/htMetaSync")
public String htMetaSync() {
    String json="";
    return htMetaInfoSyncClient.syncMeta(json, SyncType.ADD);
}

原生集成

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.14</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <groupId>com.xiaoshuzxc</groupId>
    <artifactId>grpc-native-api</artifactId>
    <packaging>jar</packaging>

    <name>grpc-native-api</name>
    <description>grpc原生api整合方式</description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <grpc.version>1.29.0</grpc.version>
        <proto.version>3.12.0</proto.version>
        <netty.tcnative.version>2.0.30.Final</netty.tcnative.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-bom</artifactId>
                <version>${grpc.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <dependencies>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-configuration-processor</artifactId>
            <optional>true</optional>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>com.xiaoshu</groupId>
            <artifactId>grpc-proto</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-protobuf</artifactId>
        </dependency>

        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-stub</artifactId>
        </dependency>

        <dependency>
            <groupId>io.grpc</groupId>
            <artifactId>grpc-netty</artifactId>
        </dependency>

        <dependency>
            <groupId>io.netty</groupId>
            <artifactId>netty-tcnative-boringssl-static</artifactId>
            <version>${netty.tcnative.version}</version>
            <scope>runtime</scope>
        </dependency>

    </dependencies>
</project>


import org.springframework.stereotype.Service;
import java.lang.annotation.*;

@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Service
public @interface GrpcService {

}

启动grpc服务监听：

import com.annotation.GrpcService;
import io.grpc.BindableService;
import io.grpc.Server;
import io.grpc.netty.GrpcSslContexts;
import io.grpc.netty.NettyServerBuilder;
import io.netty.handler.ssl.ClientAuth;
import io.netty.handler.ssl.SslContextBuilder;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.config.BeanDefinition;
import org.springframework.boot.CommandLineRunner;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.core.type.AnnotatedTypeMetadata;
import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.util.Map;
import java.util.stream.Stream;

/**
 * @author 何永豪
 * @className GrpcServer
 * @description TODO
 * @date 2023/11/7 15:56
 */
@Slf4j
public class GrpcServer implements CommandLineRunner, DisposableBean {

    private Server server;

    @Resource
    private AbstractApplicationContext applicationContext;

    @Resource
    private GrpcProperties grpcProperties;

    @Override
    public void destroy() {
        stop();
    }

    @Override
    public void run(String... args) throws Exception {
        start();
    }

    private SslContextBuilder getSslContextBuilder(){
        SslContextBuilder sslContextBuilder = SslContextBuilder.forServer(new File(grpcProperties.getServerCertPath()), new File(grpcProperties.getServerPrivateKeyPath()));
        sslContextBuilder.trustManager(new File(grpcProperties.getServerTrustCertPath()));
        sslContextBuilder.clientAuth(ClientAuth.REQUIRE);
        return GrpcSslContexts.configure(sslContextBuilder);
    }


    private void start() throws IOException {
        NettyServerBuilder nettyServerBuilder = NettyServerBuilder
                .forPort(grpcProperties.getPort());
//                .sslContext(getSslContextBuilder().build()
//                        );
        scanBeanWithAnnotation(GrpcService.class, BindableService.class)
                .forEach(e->{
                    BindableService bindableService = applicationContext.getBeanFactory().getBean(e, BindableService.class);
                    nettyServerBuilder.addService(bindableService.bindService());
                });
        server = nettyServerBuilder.build().start();
        log.info("grpc start listen {}",grpcProperties.getPort());
        Thread thread = new Thread(() -> {
            try {
                GrpcServer.this.blockUntilShutdown();
            } catch (InterruptedException e) {
                log.error("grpc server stopped");
                throw new RuntimeException(e);
            }
        });
        thread.setDaemon(false);
        thread.start();
    }

    private void stop(){
        if (server !=null){
            server.shutdown();
        }
    }

    private void blockUntilShutdown() throws InterruptedException {
        if (server !=null ){
            server.awaitTermination();
        }
    }

    private <T> Stream<String> scanBeanWithAnnotation(Class<? extends Annotation> annotionType,Class<T> beanType){
        String[] beanNamesForType = applicationContext.getBeanNamesForType(beanType);
        return Stream.of(beanNamesForType).filter(e->{
            BeanDefinition beanDefinition = applicationContext.getBeanFactory().getBeanDefinition(e);
            Map<String, Object> beansWithAnnotation = applicationContext.getBeansWithAnnotation(annotionType);
            if (beansWithAnnotation.containsKey(e)){
                return true;
            }else if (beanDefinition.getSource() instanceof AnnotatedTypeMetadata){
                return AnnotatedTypeMetadata.class.cast(beanDefinition.getSource()).isAnnotated(annotionType.getName());
            }
            return false;
        });
    }

}

服务端：

@Slf4j
@GrpcService
public class HtMetaSyncService extends HtMetaInfoSyncServiceGrpc.HtMetaInfoSyncServiceImplBase {

    @Override
    public void syncMeta(HtMetaSyncRequest request, StreamObserver<HtMetaSyncResponse> responseObserver) {
        String syncJson = request.getSyncJson();
        log.info("接收到json：{}",syncJson);
        SyncType syncType = request.getSyncType();
        int number = syncType.getNumber();
        log.info("同步类型：{}",number);
        HtMetaSyncResponse syncResponse = HtMetaSyncResponse.newBuilder()
                .setCode("1000")
                .setMsg("同步成功").build();
        responseObserver.onNext(syncResponse);
        responseObserver.onCompleted();
    }

}

客户端

import com.config.GrpcProperties;
import com.meta.HtMetaInfoSyncServiceGrpc;
import com.meta.HtMetaSyncRequest;
import com.meta.HtMetaSyncResponse;
import com.meta.SyncType;
import io.grpc.ManagedChannel;
import io.grpc.StatusRuntimeException;
import io.grpc.netty.NettyChannelBuilder;
import lombok.SneakyThrows;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
import java.util.Objects;

/**
 * @author xiaoshu
 */
@Component
public class HtMetaInfoSyncClient {

    @Resource
    private GrpcProperties grpcProperties;

    @SneakyThrows
    public String syncMeta(final String json,final SyncType syncType) {
        ManagedChannel channel = null;
        try {
            channel=NettyChannelBuilder.
                    forAddress(grpcProperties.getServerIp(),grpcProperties.getPort())
                    //非加密连接
                    .usePlaintext()
                    //加密
                    //.sslContext(grpcProperties.buildClentSslContext())
                    .build();
            HtMetaInfoSyncServiceGrpc.HtMetaInfoSyncServiceBlockingStub stub = HtMetaInfoSyncServiceGrpc.newBlockingStub(channel);
            HtMetaSyncResponse htMetaSyncResponse = stub.syncMeta((
                    HtMetaSyncRequest.newBuilder()
                            .setSyncJson(json)
                            .setSyncType(syncType)
                            .build()));
            String code = htMetaSyncResponse.getCode();
            String msg = htMetaSyncResponse.getMsg();
            return code+":"+msg;
        } catch (final StatusRuntimeException e) {
            return "FAILED with " + e.getStatus().getCode().name();
        }finally {
            if (Objects.nonNull(channel)){
                channel.shutdown();
            }
        }
    }
}

import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author 何永豪
 * @className GrpcConfig
 * @description TODO
 * @date 2023/11/7 16:58
 */
@Configuration
public class GrpcConfig {

    @Bean
    @ConditionalOnProperty(value = "grpc.enable",havingValue = "true",matchIfMissing = true)
    public GrpcServer grpcServer(){
        return new GrpcServer();
    }

}

@Component
@ConfigurationProperties(prefix = "grpc")
@Data
public class GrpcProperties {

    private Integer port;

    private String  serverIp;

    private String serverCertPath;

    private String serverPrivateKeyPath;

    private String serverTrustCertPath;

    private String clientCertPath;

    private String clientCertChainPath;

    private String clientPrivateKeyPath;

    /*public SslContext buildClentSslContext() throws SSLException {
        SslContextBuilder sslContextBuilder = GrpcSslContexts.forClient();
        sslContextBuilder.trustManager(new File(clientCertPath));
        sslContextBuilder.keyManager(new File(clientCertChainPath),new File(clientPrivateKeyPath));
        return sslContextBuilder.build();
    }*/

}

server:
  port: 8077

spring:
  application:
    name: grpc-api

grpc:
  #监听端口
  port: 6100
  #目标IP
  server-ip: 127.0.0.1
  #ssl配置
  server-cert-path: /ca/server/server.crt
  server-private-key-path: /ca/server/server.pem
  server-trust-cert-path: /ca/server/ca.crt

双向流式调用

客户端 -> -> -> 服务端
服务端 -> -> 客户端

service HtMetaInfoSyncService {
  rpc syncMeta (stream HtMetaSyncRequest) returns (stream HtMetaSyncResponse) {}
}

客户端：

import com.meta.HtMetaInfoSyncServiceGrpc;
import com.meta.HtMetaSyncRequest;
import com.meta.HtMetaSyncResponse;
import com.meta.SyncType;
import io.grpc.Status;
import io.grpc.StatusRuntimeException;
import io.grpc.stub.StreamObserver;
import lombok.extern.slf4j.Slf4j;
import net.devh.boot.grpc.client.inject.GrpcClient;
import org.springframework.stereotype.Service;

/**
 * @author xiaoshu
 */
@Slf4j
@Service
public class HtMetaInfoSyncClient {

    @GrpcClient("local-grpc-server")
    private HtMetaInfoSyncServiceGrpc.HtMetaInfoSyncServiceStub stub;


    public void syncMeta(final String json,final SyncType syncType) {
        try {
            StreamObserver<HtMetaSyncResponse> responseObserver = new StreamObserver<HtMetaSyncResponse>() {
                @Override
                public void onNext(HtMetaSyncResponse response) {
                    // 处理响应
                    log.info("处理响应");
                    String msg = response.getMsg();
                    String code = response.getCode();
                    log.info("msg: {}",msg);
                    log.info("code: {}",code);
                }

                @Override
                public void onError(Throwable t) {
                    // 处理错误
                    log.info("处理错误");
                }

                @Override
                public void onCompleted() {
                    // 处理完成
                    log.info("处理完成");
                }
            };
            stub.syncMeta(responseObserver);

            StreamObserver<HtMetaSyncRequest> streamRequest = stub.syncMeta(responseObserver);
            // 发送请求
            streamRequest.onNext(
                    HtMetaSyncRequest.newBuilder()
                            .setSyncType(syncType)
                            .setSyncJson(json)
                    .build());
            // 发送请求
            streamRequest.onNext(
                    HtMetaSyncRequest.newBuilder()
                            .setSyncType(syncType)
                            .setSyncJson(json+"请求2")
                            .build());
            // 完成请求
            responseObserver.onCompleted();
        } catch (final StatusRuntimeException e) {
            Status status = e.getStatus();
        }
    }

}

服务端：

import com.meta.HtMetaInfoSyncServiceGrpc;
import com.meta.HtMetaSyncRequest;
import com.meta.HtMetaSyncResponse;
import com.meta.SyncType;
import io.grpc.stub.StreamObserver;
import lombok.extern.slf4j.Slf4j;
import net.devh.boot.grpc.server.service.GrpcService;

/**
 * @author 何永豪
 * @className HtMetaSyncService
 * @description TODO
 * @date 2023/11/6 15:25
 */
@Slf4j
@GrpcService
public class HtMetaSyncService extends HtMetaInfoSyncServiceGrpc.HtMetaInfoSyncServiceImplBase {

    @Override
    public StreamObserver<HtMetaSyncRequest> syncMeta(StreamObserver<HtMetaSyncResponse> responseObserver) {
        return new StreamObserver<HtMetaSyncRequest>() {
            @Override
            public void onNext(HtMetaSyncRequest request) {
                String syncJson = request.getSyncJson();
                log.info("syncJson: {}",syncJson);
                SyncType syncType = request.getSyncType();
                log.info("syncType: {}",syncType);
                // 处理请求并生成响应
                HtMetaSyncResponse response = HtMetaSyncResponse.newBuilder()
                        .setCode("1000")
                        .setMsg("ok")
                        .build();
                responseObserver.onNext(response);
            }

            @Override
            public void onError(Throwable t) {
                // 处理错误
                log.info("");
            }

            @Override
            public void onCompleted() {
                // 处理完成
                responseObserver.onCompleted();
            }
        };

    }
}
何xiao树
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
SpringBoot整合grpc
weixin_44504392的博客
12-30 4157
springboot-grpc整合文档
Spring boot使用gRPC 的详细教程
u013643074的博客
07-13 3863
本篇文章，我们介绍gRPC并通过例子详细演示使用gRPC的过程。
springboot 使用 GRPC
热门推荐
正怒月神的博客
01-19 1万+
说明： GRPC是什么？ 首先我们知道 RPC是远程过程调用。 而GRPC是RPC的一种实现。 那么为什么要用GRPC呢？ 因为它支持跨语言的开发，换句话说，大家都用过FeignRPC，尤其在spring cloud中。 然而它只支持java语言，而作为微服务，可能有很多其他的服务不是java开发的。因此需要满足这个需求，就需要一个跨语言的RPC，所以就会考虑使用GRPC 好了，下面进入正题 直接上代码。 我们做一个Service和一个Client 进行交互。 一，Service
gRPC - gRPC 整合 SpringBoot2.x、3.x（全代码、统一异常处理）
CYK_byte的博客
01-06 3794
b）这是因为我们在 client 模块中引入的依赖 "grpc-client-spring-boot-starter" 已经包含了 api 模块中引入的官方最新依赖，但是 client 中包含的依赖是 1.51.0 版本，而 api 模块中引入的是 1.60.0 版本。a）创建一个类，添加 @GrpcService 注解（注入容器中，表示它是一个 proto 文件中描述的 service 的实现类），让他继承对应的 Base 接口，重写 proto 文件中提供 service 下的方法即可.
grpc框架分析之sprinboot整合grpc
qq_38697245的博客
04-30 3440
gRPC简介： gRPC 一开始由 google 开发，是一款语言中立、平台中立、开源的远程过程调用(RPC)系统。面向移动和 HTTP/2 设计。目前提供 C、Java 和 Go 语言版本,分别是：grpc, grpc-java, grpc-go. 其中 C 版本支持 C, C++, Node.js, Python, Ruby, Objective-C, PHP 和 C# 支持。 ...
spring-boot-grpc-example:spring-boot-grpc-example
05-14
9. **监控与日志**：Spring Boot与gRPC的整合还允许我们集成常见的监控工具（如Prometheus、Grafana）和日志系统（如Logback、Log4j），对gRPC服务性能进行实时监控和问题排查。 10. **微服务架构**：在微服务环境...
springboot 整合grpc
09-04
SpringBoot 整合gRPC是一项将Google开发的高性能、开源的RPC框架gRPC与流行的Java微服务框架SpringBoot结合的技术实践。gRPC基于HTTP/2协议，使用Protocol Buffers（protobuf）作为数据交换格式，提供了强类型、高效...
Spring Boot+spring Cloud纯净版
11-03
2. **通信方式**: 微服务间通信通常采用RESTful API或gRPC，可结合Spring Cloud OpenFeign实现声明式调用。 3. **数据库隔离**: 每个微服务应有独立的数据存储，避免数据耦合。 4. **持续集成/持续部署（CI/CD）**...
SpringBoot、SpringCloud的各种集成例子大全
最新发布
03-28
SpringBoot集成gRPC框架-实现RPC服务; SpringBoot集成Thrift框架-实现RPC服务; SpringBoot集成Nacos框架-实现配置中心; SpringBoot集成Jedis框架-实现Redis调用; SpringBoot集成Lettuce框架-实现Redis调用; ...
40.Spring-Boot-Dubbo-Zookeeper.rar
09-20
下面我们将详细探讨Spring Boot整合Dubbo和Zookeeper的相关知识点。 首先，让我们理解Spring Boot与Dubbo的整合。Spring Boot简化了Spring的应用初始化和配置，使得开发者能够更专注于业务逻辑。在整合Dubbo时，...
Java(SpringBoot接入)实现gPRC看这一篇就够了
weixin_37697242的博客
06-27 1282
java实现gRPC SpringBoot接入gRPC gRPC异常
Springboot之接入gRPC
宣晨光
02-18 1201
依次执行protobuf:compile、compile-custom。在src/java同级添加proto文件夹，内部添加proto文件。修改java_package，生成包路径。核心文件 MediaBrokerGrpc。随后生成对应代码文件。
grpc 介绍与整合springboot
Jelly
12-09 465
grpc是谷歌的一种高性能、开源的通用型RPC框架；支持多达十几种常用语言，它的原理是通过 IDL（Interface Definition Language）文件定义服务接口的参数和返回值类型，然后通过代码生成程序生成服务端和客户端的具体实现代码，这样在 gRPC 里，客户端应用可以像调用本地对象一样调用另一台服务器上对应的方法。
gRpc入门和springboot整合
qq_33472553的博客
09-16 926
grpc 入门 和 springboot整合
SpringBoot使用GRPC框架(服务端)
at_that_time的博客
05-31 2451
SprigBoot使用GRPC框架
【SpringBoot框架篇】37.使用gRPC实现远程服务调用
皓亮君的博客
03-21 1614
RPC（Remote Procedure Call）是一种用于实现分布式系统中不同节点之间通信的协议。它允许一个节点（称为客户端）调用另一个节点（称为服务器）上的远程方法，就像调用本地方法一样。RPC的目标是隐藏底层通信细节，使得远程调用过程对开发者透明。在RPC中，客户端通过发送请求消息给服务器来调用远程方法，服务器接收到请求后执行相应的方法，并将结果返回给客户端。RPC可以跨越不同的网络和操作系统，使得分布式系统中的不同节点能够进行高效的通信和协作。
使用注解@GrpcService在Spring Boot 中开始使用gRPC
Kenard的博客
01-15 1675
在现代微服务架构中，不同服务之间高效、健壮和可扩展的通信至关重要。gRPC是由Google开发的高性能开源框架，使客户端和服务器应用能够无缝、高效地进行通信。本文将指导您通过使用@GrpcService注解将gRPC集成到Spring Boot应用程序中的步骤。在微服务和分布式系统的世界中，高效和可扩展的通信机制的需求比以往任何时候都更为关键。作为开发人员和架构师寻找强大而有效的方式来促进服务间通信的时候，他们经常在REST和gRPC之间进行权衡。
spring boot grpc
08-23
Spring Boot gRPC是一个基于Google开源的高性能、跨语言的RPC框架GRPC的Spring Boot Starter。它是基于HTTP2协议和Protobuf 3.x的，使用Netty 4.x作为底层通信框架。你可以在GitHub上找到Grpc Spring Boot Starter的地址，它是一个开源项目，可以让你更方便地在Spring Boot应用中集成gRPC功能。对于版本号，一般情况下，我们可以在项目的pom.xml文件中使用属性来指定版本号，例如<grpc.stater.version>1.3.0-RELEASE</grpc.stater.version><span class="em">1</span><span class="em">2</span><span class="em">3</span> #### 引用[.reference_title] - *1* *2* *3* [springboot整合gprc 传输对象](https://blog.csdn.net/qq_28423433/article/details/79108976)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值