精华内容
下载资源
问答
  • GRPCSpring Cloud的集成

    2021-08-22 18:27:38
    实现GRPCSPRING CLOUD的集成通讯, 采用NACOS接入, 支持负载
  • 3.gRPCSpring Cloud 中的应用.3.gRPCSpring Cloud 中的应用.
  • SpringCloud + GRPC练习项目 SpringCloud@Hoxton.SR8 功能简介 使用gateway作为网关 内部服务之间调用使用Grpc调用 注册中心使用阿里巴巴的nacos
  • gRPCSpring Cloud中的应用

    千次阅读 2019-03-16 22:18:47
    1、前言 在微服务开发中,服务间的...在微服务项目中,服务间的调用,是非常普遍频繁的,其性能也不是很理想。 为了解决上述问题,进行反复对比,最终服务间的调用方式采取了gRPC方式,其显著特点就是性能之高(...

    1、前言

        在微服务开发中,服务间的调用一般有两种方式:Feign、RestTemplate,但在实际使用过程中,尤其是Feign,存在各种限制及局限性,如:HTTP请求方式、返回类型等限制,有时会让你觉得那那都别扭。在微服务项目中,服务间的调用,是非常普遍频繁的,其性能也不是很理想。

       为了解决上述问题,进行反复对比,最终服务间的调用方式采取了gRPC方式,其显著特点就是性能之高(通信采用Netty),通过proto文件定义的接口也是非常清晰而又灵活。本文主要就gRPC在Spring Cloud项目中的使用进行说明实战。

      关于gRPC相关基础知识可以参考上一篇文章gRPC的使用

    2、gRPC在Spring Cloud中的使用

        看过上一篇文章gRPC的使用的话,你就清楚如果直接使用gRPC,显得有些吃力,因此借助一些开源的框架变得尤为必要。gRPC在Spring Cloud中使用开源项目grpc-spring-boot-starter,便于在Spring Cloud项目中开发应用。

    (grpc-spring-boot-starter虽然存在一些问题,但集成Sping Cloud项目已经相当高了,还是不错之选。如果你有时间,精力,还是又必要在源码基础上进行开发。)

    下面以实际demo来说明grpc-spring-boot-starter的应用。

    2.1 特点

    • 使用@ GrpcService自动创建并运行一个 gRPC 服务,内嵌在 spring-boot 应用中
    • 使用@ GrpcClient自动创建和管理你的客户端
    • 支持Spring Cloud(向Consul或Eureka注册服务并获取gRPC服务器信息)
    • 支持Spring Sleuth 进行链路跟踪
    • 支持对于server、client 分别设置全局拦截器或单个的拦截器
    • 支持Spring-Security
    • 支持metric (micrometer / actuator)

    (看了上面这些特点,就知道为啥选择这个开源项目了)

    2.2 使用DEMO

    2.2.1 定义gRPC接口

         基于protobuf来声明数据模型和RPC接口服务。

         创建一个公共字模块项目spring-boot-grpc-common,用于定义存放gRPC接口(proto),便于gRPC服务端和客户端使用。以helloworld.proto(src\main\proto\helloworld.proto)为例:

    syntax = "proto3";
    
    option java_multiple_files = true;
    option java_package = "com.xcbeyond.springboot.grpc.lib";
    option java_outer_classname = "HelloWorldProto";
    
    // The greeting service definition.
    service Simple {
        // Sends a greeting
        rpc SayHello (HelloRequest) returns (HelloReply) {
        }
    }
    
    // The request message containing the user's name.
    message HelloRequest {
        string name = 1;
    }
    
    // The response message containing the greetings
    message HelloReply {
        string message = 1;
    }
    

         根据proto的命令可以转换成对应的语言的代码,生成java代码,也可以借助maven插件,在编译时自动生成。这里通过mavent插件,可以在pom.xml中增加如下依赖:

    <build>
    		<extensions>
    			<extension>
    				<groupId>kr.motd.maven</groupId>
    				<artifactId>os-maven-plugin</artifactId>
    				<version>${os.plugin.version}</version>
    			</extension>
    		</extensions>
    		<plugins>
    			<plugin>
    				<groupId>org.xolstice.maven.plugins</groupId>
    				<artifactId>protobuf-maven-plugin</artifactId>
    				<version>${protobuf.plugin.version}</version>
    				<configuration>
    					<protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}</protocArtifact>
    					<pluginId>grpc-java</pluginId>
    					<pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
    				</configuration>
    				<executions>
    					<execution>
    						<goals>
    							<goal>compile</goal>
    							<goal>compile-custom</goal>
    						</goals>
    					</execution>
    				</executions>
    			</plugin>
    		</plugins>
    </build>

    在maven中进行package编译打包,将会在target中看见根据proto自动生成的Java类。(编译过程中可能会报错,此时可以忽略)

    2.2.2 gRPC服务端

    maven依赖:

    <dependency>
      <groupId>net.devh</groupId>
      <artifactId>grpc-server-spring-boot-starter</artifactId>
      <version>2.2.1.RELEASE</version>
    </dependency>

    实现 gRPC server 的业务逻辑,使用注解@GrpcService定义gRPC服务端,如下所示:

    package com.xcbeyond.springboot.grpc.server.service;
    
    import com.xcbeyond.springboot.grpc.lib.HelloReply;
    import com.xcbeyond.springboot.grpc.lib.HelloRequest;
    import com.xcbeyond.springboot.grpc.lib.SimpleGrpc;
    import io.grpc.stub.StreamObserver;
    import net.devh.boot.grpc.server.service.GrpcService;
    
    /**
     * @Auther: xcbeyond
     * @Date: 2019/3/6 18:15
     */
    @GrpcService
    public class GrpcServerService extends SimpleGrpc.SimpleImplBase {
        @Override
        public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
            System.out.println("GrpcServerService...");
            HelloReply reply = HelloReply.newBuilder().setMessage("Hello ==> " + request.getName()).build();
            responseObserver.onNext(reply);
            responseObserver.onCompleted();
        }
    }

    application.yml配置:

    gRPC 的 host 跟 port ,默认的监听的 host 是 0.0.0.0,默认的 port 是 9090,配置为0将会自动分配未使用的端口。

    grpc:
      server:
        port: 0

     

    2.2.3 gRPC客户端

    maven依赖:

    <dependency>
    	<groupId>net.devh</groupId>
    	<artifactId>grpc-client-spring-boot-starter</artifactId>
    	<version>2.2.1.RELEASE</version>
    </dependency>

    使用注解@GrpcClient来调用服务端接口,通过

    HelloReply response = simpleBlockingStub.sayHello(HelloRequest.newBuilder().setName(name).build());

    直接向服务端发起请求,和调用本地接口一样。

    package com.xcbeyond.springboot.grpc.client.service;
    
    import com.xcbeyond.springboot.grpc.lib.HelloReply;
    import com.xcbeyond.springboot.grpc.lib.HelloRequest;
    import com.xcbeyond.springboot.grpc.lib.SimpleGrpc.SimpleBlockingStub;
    import io.grpc.StatusRuntimeException;
    import net.devh.boot.grpc.client.inject.GrpcClient;
    import org.springframework.stereotype.Service;
    
    /**
     * @Auther: xcbeyond
     * @Date: 2019/3/7 09:10
     */
    @Service
    public class GrpcClientService {
    
        @GrpcClient("spring-boot-grpc-server")
        private SimpleBlockingStub simpleBlockingStub;
    
        public String sendMessage(String name) {
            try {
                HelloReply response = simpleBlockingStub.sayHello(HelloRequest.newBuilder().setName(name).build());
                return response.getMessage();
            } catch (final StatusRuntimeException e) {
                return "FAILED with " + e.getStatus().getCode();
            }
        }
    }
    

    application.yml配置:

       spring-boot-grpc-server,即:服务端应用名,结合spring cloud Eureka注册中心,通过服务名将会找到服务端的ip,进行通信,实际上是netty通信。
    grpc:
      client:
        spring-boot-grpc-server:
          enableKeepAlive: true
          keepAliveWithoutCalls: true
          negotiationType: plaintext

    本demo完整代码请参考https://github.com/xcbeyond/spring-boot-grpc.git

    展开全文
  • 集成GRPC 1、代码目录 2、api服务 2.1 helloworld.proto syntax = "proto3"; option java_multiple_files = true; option java_package = "com.yun.grpc.api"; option java_outer_classname = "HelloWorldProto";...

    0、前言

    • 集成GRPC

    1、代码目录

    在这里插入图片描述

    2、api服务

    2.1 helloworld.proto

    syntax = "proto3";
    
    option java_multiple_files = true;
    option java_package = "com.yun.grpc.api";
    option java_outer_classname = "HelloWorldProto";
    
    // The greeting service definition.
    service Simple {
      // Sends a greeting
      rpc SayHello (HelloRequest) returns (HelloReply) {
      }
    }
    
    // The request message containing the user's name.
    message HelloRequest {
      string name = 1;
    }
    
    // The response message containing the greetings
    message HelloReply {
      string message = 1;
    }
    

    2.2 pom.xml

       <artifactId>com.yun.grpc.api</artifactId>
    
        <properties>
            <grpc.2java.version>1.6.1</grpc.2java.version>
            <grpc.version>1.14.0</grpc.version>
            <os.plugin.version>1.6.0</os.plugin.version>
            <protobuf.plugin.version>0.5.1</protobuf.plugin.version>
            <protoc.version>3.3.0</protoc.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-netty</artifactId>
                <version>${grpc.version}</version>
            </dependency>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-protobuf</artifactId>
                <version>${grpc.version}</version>
            </dependency>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-stub</artifactId>
                <version>${grpc.version}</version>
            </dependency>
        </dependencies>
    
        <build>
            <extensions>
                <extension>
                    <groupId>kr.motd.maven</groupId>
                    <artifactId>os-maven-plugin</artifactId>
                    <version>${os.plugin.version}</version>
                </extension>
            </extensions>
            <plugins>
                <plugin>
                    <groupId>org.xolstice.maven.plugins</groupId>
                    <artifactId>protobuf-maven-plugin</artifactId>
                    <version>${protobuf.plugin.version}</version>
                    <configuration>
                        <protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}</protocArtifact>
                        <pluginId>grpc-java</pluginId>
                        <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.2java.version}:exe:${os.detected.classifier}</pluginArtifact>
                    </configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>compile</goal>
                                <goal>compile-custom</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </project>
    

    2.3 测试

    执行mvn package
    在这里插入图片描述

    3、provider

    3.1 pom.xml

    • 注: spring-boot-starter-web
    • 注: commons-collections
        <artifactId>com.yun.grpc.provider</artifactId>
        <properties>
            <grpc.server.version>2.0.1.RELEASE</grpc.server.version>
            <brave.instrumentation.grpc>5.1.2</brave.instrumentation.grpc>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>com.yun.grpc.api</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>com.yun.common</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <!--必需,没有的话无法注册到nacos-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>net.devh</groupId>
                <artifactId>grpc-server-spring-boot-starter</artifactId>
                <version>${grpc.server.version}</version>
            </dependency>
            <!--报错-->
            <dependency>
                <groupId>commons-collections</groupId>
                <artifactId>commons-collections</artifactId>
                <version>3.2.2</version>
            </dependency>
        </dependencies>
    

    3.2 bootstrap

    • 注: grpc.server.post必需
    grpc:
      server:
        port: 50051
    spring:
      application:
        name: service-grpc-provider
      cloud:
        nacos:
          config:
            server-addr:  192.168.126.133:8848
            file-extension: yaml
            enabled: true
    

    3.3 application

    • 注: metadata 必需
    server:
      port: 8011
    spring:
      cloud:
        nacos:
          discovery:
            server-addr: ${spring.cloud.nacos.config.server-addr}
            metadata:
              gRPC:
                port: ${grpc.server.port} # 不可少。UNAVAILABLE: NameResolver returned an empty list
    

    3.4 服务 GrpcServerService

    @GrpcService(SimpleGrpc.class)
    public class GrpcServerService extends SimpleGrpc.SimpleImplBase{
    
        @Override
        public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver){
            HelloReply reply = HelloReply.newBuilder()
                    .setMessage("Hello ========== " + req.getName())
                    .build();
            responseObserver.onNext(reply);
            responseObserver.onCompleted();
        }
    }
    

    3.5 启动类 GrpcProviderApplication

    @SpringBootApplication
    public class GrpcProviderApplication {
        public static void main(String[] args) {
            SpringApplication.run(GrpcProviderApplication.class,args);
    
        }
    }
    

    3.6 运行测试

    • 先运行nacos
    • GrpcProviderApplication

    4、consumer

    4.1、pom文件

        <modelVersion>4.0.0</modelVersion>
        <artifactId>com.yun.grpc.consumer</artifactId>
        <properties>
            <grpc.server.version>2.0.1.RELEASE</grpc.server.version>
            <brave.instrumentation.grpc>5.1.2</brave.instrumentation.grpc>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>com.yun.grpc.api</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <dependency>
                <groupId>com.example</groupId>
                <artifactId>com.yun.common</artifactId>
                <version>0.0.1-SNAPSHOT</version>
            </dependency>
            <!--必需,没有的话无法注册到nacos-->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>net.devh</groupId>
                <artifactId>grpc-client-spring-boot-starter</artifactId>
                <version>${grpc.server.version}</version>
            </dependency>
            <!--报错-->
            <dependency>
                <groupId>commons-collections</groupId>
                <artifactId>commons-collections</artifactId>
                <version>3.2.2</version>
            </dependency>
        </dependencies>
    

    4.2 bootstrap

    spring:
      application:
        name: service-grpc-consumer
      cloud:
        nacos:
          config:
            server-addr:  192.168.126.133:8848
            file-extension: yaml
            enabled: true
    

    4.3 application.xml

    server:
      port: 8012
    spring:
      cloud:
        nacos:
          discovery:
            server-addr: ${spring.cloud.nacos.config.server-addr}
    

    4.4 消费服务

    • service-grpc-provider
    @Service
    public class GrpcClientService {
        @GrpcClient("service-grpc-provider")
        private Channel serverChannel;
    
        public String sendMessage(String name) {
            SimpleGrpc.SimpleBlockingStub stub = SimpleGrpc.newBlockingStub(serverChannel);
            HelloReply response = stub.sayHello(HelloRequest.newBuilder().setName(name).build());
    
            return response.getMessage();
        }
    }
    

    4.5 测试controller

    @RestController
    public class GrpcClientController {
        @Autowired
        private GrpcClientService grpcClientService;
    
        @RequestMapping("/")
        public String printMessage(@RequestParam(defaultValue = "Spring Cloud") String name){
            return grpcClientService.sendMessage(name);
        }
    }
    

    4.6 CloudGrpcClientApplication

    @SpringBootApplication
    public class CloudGrpcClientApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(CloudGrpcClientApplication.class, args);
        }
    }
    

    5、测试

    展开全文
  • gRPC Spring Boot Starter README: English | 中文 Documentation: English | 中文 Features Automatically configures and runs the gRPC server with your @GrpcService implementations ...
  • 本项目基于Spring Boot 2.0.5+yidongnan/grpc-spring-boot-starter 2.0.1.RELEASE+SpringCloud Finchley.SR1,通过2个grpc-eureka-server模拟Eureka集群,多个可横向弹性扩容的grpc-spring-cloud-provider负责提供...

    本项目基于Spring Boot 2.0.5+yidongnan/grpc-spring-boot-starter 2.0.1.RELEASE+SpringCloud Finchley.SR1,通过2个grpc-eureka-server模拟Eureka集群,多个可横向弹性扩容的grpc-spring-cloud-provider负责提供gRPC服务,再用grpc-spring-cloud-consumer作为服务消费者来调用gRPC服务,服务提供者和消费者通过grpc-springboot-cloud-lib模块来完成接口约定。

    本项目已上传至GitHub:https://github.com/linshenkx/grpc-springboot-cloud

    一 项目结构

    1 项目结构

    根项目(com.linshen:grpc-springboot-cloud:1.0-SNAPSHOT)下有4个子模块:

    • grpc-eureka-server:Eureka服务器
    • grpc-springboot-cloud-lib:gRPC接口,包含原始proto文件,并负责将其转换为java代码
    • grpc-spring-cloud-provider:Eureka客户端,同时也是gRPC服务提供者
    • grpc-spring-cloud-consumer:Eureka客户端,同时也是gRPC服务消费者

    2 模块功能

    • 相互关系
      根项目负责依赖版本管理,通过grpc-eureka-server实现Eureka集群,通过grpc-spring-cloud-provider负责提供gRPC服务,再用grpc-spring-cloud-consumer作为服务消费者来调用gRPC服务,服务提供者和消费者都作为Eureka客户端注册在Eureka集群中,消费者通过服务名发现提供者并通过grpc-springboot-cloud-lib模块来完成接口约定实现RPC。
    • 对应MVC关系
      • grpc-springboot-cloud-lib就是service(接口,为提供实现)
      • grpc-spring-cloud-provider就相当于serviceImpl(service的实现类)
      • grpc-spring-cloud-consumer就相当于controller
    • 框架依赖
      • grpc-eureka-server:除了必要的eureka-server依赖外再依赖actuator方便监控
      • grpc-springboot-cloud-lib需要将proto文件转换成java类,故需依赖于protobuf-maven-plugin插件,另外还需要io.grpc下的grpc-all,否则生成的java类会提示缺少依赖
      • grpc-spring-cloud-provider 要注册到eureka服务中心,需要web依赖,否则会报错
      • grpc-spring-cloud-consumer 基本和provider一样

    二 项目搭建

    0 编写根项目pom文件

    <?xml version="1.0" encoding="UTF-8"?>
    <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>
    
        <groupId>com.linshen</groupId>
        <artifactId>grpc-springboot-cloud</artifactId>
        <packaging>pom</packaging>
        <version>1.0-SNAPSHOT</version>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.5.RELEASE</version>
        </parent>
    
        <modules>
            <module>grpc-springboot-cloud-lib</module>
            <module>grpc-eureka-server</module>
            <module>grpc-spring-cloud-provider</module>
            <module>grpc-spring-cloud-consumer</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>
            <spring-boot.version>${parent.version}</spring-boot.version>
            <net-devh-grpc.version>2.0.1.RELEASE</net-devh-grpc.version>
            <spring-cloud.version>Finchley.SR1</spring-cloud.version>
        </properties>
    
        <dependencyManagement>
            <dependencies>
                <dependency>
                    <groupId>org.springframework.cloud</groupId>
                    <artifactId>spring-cloud-dependencies</artifactId>
                    <version>${spring-cloud.version}</version>
                    <type>pom</type>
                    <scope>import</scope>
                </dependency>
                <!--公共grpc模块-->
                <dependency>
                    <groupId>com.linshen</groupId>
                    <artifactId>grpc-springboot-cloud-lib</artifactId>
                    <version>${project.version}</version>
                </dependency>
                <!--核心grpc-spring-boot依赖-->
                <dependency>
                    <groupId>net.devh</groupId>
                    <artifactId>grpc-client-spring-boot-starter</artifactId>
                    <version>${net-devh-grpc.version}</version>
                </dependency>
                <dependency>
                    <groupId>net.devh</groupId>
                    <artifactId>grpc-server-spring-boot-starter</artifactId>
                    <version>${net-devh-grpc.version}</version>
                </dependency>
            </dependencies>
        </dependencyManagement>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.apache.maven.plugins</groupId>
                    <artifactId>maven-deploy-plugin</artifactId>
                    <configuration>
                        <skip>true</skip>
                    </configuration>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    1 创建grpc-springboot-cloud-lib模块

    <?xml version="1.0" encoding="UTF-8"?>
    <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">
        <parent>
            <artifactId>grpc-springboot-cloud</artifactId>
            <groupId>com.linshen</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
        <modelVersion>4.0.0</modelVersion>
    
        <artifactId>grpc-springboot-cloud-lib</artifactId>
        <packaging>jar</packaging>
    
        <properties>
            <os.plugin.version>1.6.0</os.plugin.version>
            <grpc.version>1.15.1</grpc.version>
            <protoc.version>3.6.1</protoc.version>
            <protobuf.plugin.version>0.6.1</protobuf.plugin.version>
        </properties>
    
        <dependencies>
            <dependency>
                <groupId>io.grpc</groupId>
                <artifactId>grpc-all</artifactId>
                <version>${grpc.version}</version>
            </dependency>
        </dependencies>
    
        <build>
            <extensions>
                <extension>
                    <groupId>kr.motd.maven</groupId>
                    <artifactId>os-maven-plugin</artifactId>
                    <version>${os.plugin.version}</version>
                </extension>
            </extensions>
            <plugins>
                <plugin>
                    <groupId>org.xolstice.maven.plugins</groupId>
                    <artifactId>protobuf-maven-plugin</artifactId>
                    <version>${protobuf.plugin.version}</version>
                    <extensions>true</extensions>
                    <configuration>
                        <protocArtifact>com.google.protobuf:protoc:${protoc.version}:exe:${os.detected.classifier}</protocArtifact>
                        <pluginId>grpc-java</pluginId>
                        <pluginArtifact>io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}</pluginArtifact>
                        <!--默认值-->
                        <protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
                        <!--默认值-->
                        <!--<outputDirectory>${project.build.directory}/generated-sources/protobuf/java</outputDirectory>-->
                        <outputDirectory>${project.basedir}/src/main/java</outputDirectory>
                        <!--设置是否在生成java文件之前清空outputDirectory的文件,默认值为true,设置为false时也会覆盖同名文件-->
                        <clearOutputDirectory>false</clearOutputDirectory>
                        <!--更多配置信息可以查看https://www.xolstice.org/protobuf-maven-plugin/compile-mojo.html-->
                    </configuration>
                    <executions>
                        <execution>
                            <!--在执行mvn compile的时候会执行以下操作-->
                            <phase>compile</phase>
                            <goals>
                                <!--生成OuterClass类-->
                                <goal>compile</goal>
                                <!--生成Grpc类-->
                                <goal>compile-custom</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    2 创建grpc-eureka-server模块

    <?xml version="1.0" encoding="UTF-8"?>
    <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>
    
        <artifactId>grpc-eureka-server</artifactId>
        <packaging>jar</packaging>
    
        <name>grpc-eureka-server</name>
    
        <parent>
            <artifactId>grpc-springboot-cloud</artifactId>
            <groupId>com.linshen</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
    
        <dependencies>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    3 创建grpc-spring-cloud-provider模块

    <?xml version="1.0" encoding="UTF-8"?>
    <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>
    
        <artifactId>grpc-spring-cloud-provider</artifactId>
        <packaging>jar</packaging>
    
        <name>grpc-spring-cloud-provider</name>
    
        <parent>
            <artifactId>grpc-springboot-cloud</artifactId>
            <groupId>com.linshen</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
    
        <dependencies>
            <dependency>
                <groupId>com.linshen</groupId>
                <artifactId>grpc-springboot-cloud-lib</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>net.devh</groupId>
                <artifactId>grpc-server-spring-boot-starter</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    3 创建grpc-spring-cloud-consumer模块

    <?xml version="1.0" encoding="UTF-8"?>
    <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>
    
        <artifactId>grpc-spring-cloud-consumer</artifactId>
        <packaging>jar</packaging>
    
        <name>grpc-spring-cloud-consumer</name>
    
        <parent>
            <artifactId>grpc-springboot-cloud</artifactId>
            <groupId>com.linshen</groupId>
            <version>1.0-SNAPSHOT</version>
        </parent>
    
        <dependencies>
            <dependency>
                <groupId>com.linshen</groupId>
                <artifactId>grpc-springboot-cloud-lib</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.cloud</groupId>
                <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-actuator</artifactId>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>net.devh</groupId>
                <artifactId>grpc-client-spring-boot-starter</artifactId>
            </dependency>
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    </project>
    

    三 功能实现

    1 在grpc-springboot-cloud-lib模块利用proto文件生成java代码

    (1) 编写proto文件

    还是在src/main/proto目录编写下一个greeter.proto文件,如下

    syntax = "proto3";
    
    option java_package = "com.linshen.grpc.cloud.lib";
    
    service Greeter {
        rpc SayHello ( HelloRequest) returns (  HelloReply) {}
    
    }
    message HelloRequest {
        string name = 1;
    }
    message HelloReply {
        string message = 1;
    }
    

    (2) 生成java代码

    行protobuf插件的compile和compile-custom功能,生成java代码到src/main/java目录下
    lib

    2 编写grpc-eureka-server

    这里要实现两个Eureka-Server集群实现服务中心的高可用(两个确实很少,谈不上高可用,这里只是演示一下),需要通过不同的profile来启动不同的Eureka-Server,故需要application.yml、application-slave1.yml和application-slave2.yml三个文件。application.yml定义了公共属性和actuator配置,并且配置了默认active-profile是slave1。其中slave1运行在端口8781上,slave2运行在端口8782上,两者的域名(也可以设置成ip)通过环境变量传入,不传的话默认是在本地(localhost)运行。
    最终的工程目录应该如下
    eureka-server

    (0)添加@EnableEurekaServer支持

    (1)编写application.yml文件

    spring:
      application:
        name: grpc-eureka-server
      profiles:
        active: ${grpc-eureka-profile:slave1}
    # actuator management
    management:
      endpoint:
        health:
          show-details: always
      endpoints:
        web:
          exposure:
            include: '*'
    
    # actuator info
    info:
      app:
        encoding:UTF-8
        java.source:1.8
        java.traget:1.8
    

    (2)编写application-slave1.yml文件

    server:
      port: 8781
    eureka:
      client:
        service-url:
          defaultZone: http://${cloudServerSlave2:localhost}:8782/eureka/
      instance:
        hostname: ${cloudServerSlave1:localhost}
      server:
        enable-self-preservation: false
    

    (2)编写application-slave2.yml文件

    server:
      port: 8782
    eureka:
      client:
        service-url:
          defaultZone: http://${cloudServerSlave1:localhost}:8781/eureka/
      instance:
        hostname: ${cloudServerSlave2:localhost}
      server:
        enable-self-preservation: false
    

    3 在grpc-spring-cloud-provider模块实现接口

    最终的工程目录应该如下
    provider

    (0)添加@EnableDiscoveryClient支持

    (1) 编写application文件

    如下,server.port和grpc.server.port都为0,这样启动的时候服务端口和grpc端口都会随机分配,就不会重复占用了,eureka.instance.instance-id也是通过应用名+uuid的方式来避免重复

    server:
      port: 0
    grpc:
      server:
        port: 0
    spring:
      application:
        name: grpc-spring-cloud-provider
    eureka:
      client:
        service-url:
          defaultZone: http://${cloudServerSlave1:localhost}:8781/eureka/,http://${cloudServerSlave2:localhost}:8782/eureka/
      instance:
        instance-id: ${spring.application.name}:${random.uuid}
    logging:
      level:
        org.springframework.web.servlet.DispatcherServlet: DEBUG
    # actuator management
    management:
      endpoint:
        health:
          show-details: always
      endpoints:
        web:
          exposure:
            include: '*'
    # actuator info
    info:
      app:
        encoding:UTF-8
        java.source:1.8
        java.traget:1.8
        name:grpc-spring-cloud-provider
    

    (2) 编写GreeterService类

    package com.linshen.grpcspringcloudprovider;
    
    import com.linshen.grpc.cloud.lib.GreeterGrpc;
    import com.linshen.grpc.cloud.lib.GreeterOuterClass;
    import io.grpc.stub.StreamObserver;
    import lombok.extern.slf4j.Slf4j;
    import net.devh.springboot.autoconfigure.grpc.server.GrpcService;
    
    @Slf4j
    @GrpcService(GreeterOuterClass.class)
    public class GreeterService extends GreeterGrpc.GreeterImplBase {
        @Override
        public void sayHello(GreeterOuterClass.HelloRequest request, StreamObserver<GreeterOuterClass.HelloReply> responseObserver) {
            String message = "Hello " + request.getName();
            final GreeterOuterClass.HelloReply.Builder replyBuilder = GreeterOuterClass.HelloReply.newBuilder().setMessage(message);
            responseObserver.onNext(replyBuilder.build());
            responseObserver.onCompleted();
            log.info("Returning " +message);
        }
    }
    

    4 在grpc-spring-cloud-consumer模块调用服务

    最终的工程目录应该如下
    在这里插入图片描述

    (0)添加@EnableDiscoveryClient支持

    (1) 编写application文件

    不需要配置grpc.server.port,其他的和provider大致相同

    (2)编写GrpcClientService服务类

    注意这里的@GrpcClient的value是provider的spring.application.name

    package com.linshen.grpcspringcloudconsumer;
    
    import com.linshen.grpc.cloud.lib.GreeterGrpc;
    import com.linshen.grpc.cloud.lib.GreeterOuterClass;
    import io.grpc.Channel;
    import net.devh.springboot.autoconfigure.grpc.client.GrpcClient;
    import org.springframework.stereotype.Service;
    
    @Service
    public class GrpcClientService {
    
        @GrpcClient("grpc-spring-cloud-provider")
        private Channel serverChannel;
    
        public String sendMessage(String name) {
            GreeterGrpc.GreeterBlockingStub stub= GreeterGrpc.newBlockingStub(serverChannel);
            GreeterOuterClass.HelloReply response = stub.sayHello(GreeterOuterClass.HelloRequest.newBuilder().setName(name).build());
            return response.getMessage();
        }
    }
    

    (3)编写GrpcClientController类

    package com.linshen.grpcspringcloudconsumer;
    
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RequestParam;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class GrpcClientController {
    
        @Autowired
        private GrpcClientService grpcClientService;
    
        @RequestMapping("/")
        public String printMessage(@RequestParam(defaultValue = "LinShen") String name) {
            return grpcClientService.sendMessage(name);
        }
    }
    

    四 项目启动

    0 install工程

    在根工程下运行mvn install -Dmaven.test.skip=true,这一步将项目install到本地仓库,目的是使插件能正常工作,避免出现Failed to collect dependencies问题,如果只是在本地运行的话没遇到依赖问题,这一步也可以省略。

    1 多profiles启动grpc-eureka-server

    分别指定active-profiles为slave1和slave2启动grpc-eureka-server

    2 任意实例数量启动grpc-spring-cloud-provider

    重复启动grpc-spring-cloud-provider,这里我启动了两次,获得两个实例

    3 启动grpc-spring-cloud-consumer

    简单启动一个消费者即可

    最终运行情况应该如下
    Run Dashboard

    五 测试

    打开eureka-server1,即http://localhost:8781/,如下图,可以看到所有的服务实例到注册到服务中心了
    server1
    打开eureka-server2,即http://localhost:8782/,如下图,可以看到服务实例信息还没有eureka-server1完整
    server2
    这个时候再打开consumer,即http://localhost:49236/,如下图,运行正常
    consumer
    把Grpc-Eureka-Server-Slave1杀掉,再查看eureka-server2,可以发现注册信息已经同步到slave2了,这个时候consumer仍可正常使用

    六 其他

    1 相关文章

    gRPC-Java指导:https://grpc.io/docs/tutorials/basic/java.html
    gRPC 官方文档中文版1.0:https://doc.oschina.net/grpc
    Maven Protocol Buffers Plugin 插件指南:https://www.xolstice.org/protobuf-maven-plugin/index.html

    Spring Boot 2+gRPC 学习系列1:搭建Spring Boot 2+gRPC本地项目:https://blog.csdn.net/alinyua/article/details/83030149
    Spring Boot 2+gRPC 学习系列2:搭建Spring Cloud +gRPC集群项目:https://blog.csdn.net/alinyua/article/details/83043823

    Spring Boot 2+Dubbo 学习系列1:使用Docker部署zookeeper:https://blog.csdn.net/alinyua/article/details/81016734
    Spring Boot 2+Dubbo 学习系列2:搭建Spring Boot 2+Dubbo+Zookeeper集群:https://blog.csdn.net/alinyua/article/details/81019925
    Spring Boot 2+Dubbo 学习系列3:dubbo-ops 之 Dubbo Admin:https://blog.csdn.net/alinyua/article/details/81034023

    2 GitHub项目

    linshenkx/grpc-springboot-cloud(Spring Cloud +gRPC集群项目):https://github.com/linshenkx/grpc-springboot-cloud
    linshenkx/grpc-springboot-lin(Spring Boot 2+gRPC本地项目):https://github.com/linshenkx/grpc-springboot-lin
    linshenkx/spring-cloud-lin(Spring Boot 2整合Spring Cloud):https://github.com/linshenkx/spring-cloud-lin
    gRPC-Java的GitHub地址:https://github.com/grpc/grpc-java
    yidongnan/grpc-spring-boot-starter的GitHub地址:https://github.com/yidongnan/grpc-spring-boot-starter

    展开全文
  • Spring CloudgRPC

    千次阅读 2019-02-14 16:19:09
    文章目录Spring Cloud为什么需要gRPCgRPC简介gRPC的核心概念服务定义 Spring Cloud为什么需要gRPC 微服务架构的风格,是每个微服务运行在自己的进程中,并使用轻量级的通信机制,通常是HTTP RESTFUL API。这些服务是...

    Spring Cloud为什么需要gRPC

    微服务架构的风格,是每个微服务运行在自己的进程中,并使用轻量级的通信机制,通常是HTTP RESTFUL API。这些服务是围绕业务能力来划分的、构建的,并通过完全自动化的机制来部署。这些服务可以用不同的语言来编写,以及不同的数据存储技术,以保证最低限度的集中式管理。

    但是在通常情况下,HTTP不会开启KeepAlive功能,即为短连接,每次请求都需要建立TCP连接,这使得其在耗时非常低效。

    对外提供RESTAPI是可以理解的,但内部服务之间进行调用若还是采用HTTP就会显得性能低下,Spring Cloud默认使用Feign进行内部服务调用,而Feign底层使用HTTP协议进行服务之间的调用。

    Spring Cloud官方没有提供RESTAPI之外的服务调用方案,现有的更高效的内部服务调用方案是GRPC。

    GRPC相比HTTP/JSON客户端有如下优势:

    • GRPC采用了Proto Buffer作为序列化工具,这比采用JSON方式进行序列化性能提高了不少。
    • GRPC采用了HTTP2协议,进行了头部信息压缩,对连接进行了复用,减少了TCP的连接次数。
    • GRPC采用Netty做为IO处理框架,提高了性能。

    gRPC简介

    是谷歌开源的一个高性能的、通用的RPC框架。和其他RPC一样,客户端应用程序可以直接调用远程服务的方法,就好像调用本地方法一样。它隐藏了底层的实现细节,包括序列化(XML、JSON、二进制)、数据传输(TCP、HTTP、UDP)、反序列化等,开发人员只需要关自业务本身,而不需要关注RPC的技术细节。

    与其他RPC框架一样,gRPC也遵循定义服务(类似于定义接口的思想)。gRPC客户端通过定义方法名、方法参数和返回类型来声明一个可以被远程调用的接口方法。由服务端实现客户端定义的接口方法,并运行一个gRPC服务来处理gPRC
    客户端调用。注意,gRPC客户端和服务端共用一个接口方法。

    gRPC客户端和服务端具有运行环境和开发语言无关性。

    gRPC的核心概念

    服务定义

    和其他RPC框架一样,gRPC遵循服务定义(Service definition)的思想。gRPC默认情况下使用protocol buffers作为接口定义语言(IDL),这种接口语言描述了服务接口和负载消息的结构。

    使用Protocol Buffers的Maven插件

    使用Protocol Buffers需要掌握额外的接口定义语言(IDL),还需要Protocol Buffers编译组件的支持。

    使用最广泛、最方便的Maven插件方式来使用Protocol Buffers。

    依赖

    <dependency>
       <groupId>com.google.protobuf</groupId>
        <artifactId>protobuf-java</artifactId>
        <version>3.5.1</version>
    </dependency>
    

    安装Protocol Buffers的Maven插件,具体可参考https://www.xolstice.org/protobuf-maven-plugin中的介绍。

    <build>
    
       <!--<extensions>-->
       <!--<extension>-->
       <!--<groupId>kr.motd.maven</groupId>-->
       <!--<artifactId>os-maven-plugin</artifactId>-->
       <!--<version>1.5.0.Final</version>-->
       <!--</extension>-->
       <!--</extensions>-->
    
       <!--<plugins>-->
       <!--<plugin>-->
       <!--<groupId>org.xolstice.maven.plugins</groupId>-->
       <!--<artifactId>protobuf-maven-plugin</artifactId>-->
       <!--<version>0.5.1</version>-->
       <!--<extensions>true</extensions>-->
    
       <!--<executions>-->
       <!--<execution>-->
       <!--<goals>-->
       <!--<goal>compile</goal>-->
       <!--<goal>test-compile</goal>-->
       <!--</goals>-->
       <!--<configuration>-->
       <!--<protocArtifact>com.google.protobuf:protoc:3.4.0:exe:${os.detected.classifier}</protocArtifact>-->
       <!--</configuration>-->
       <!--</execution>-->
       <!--</executions>-->
       <!--</plugin>-->
    
       <!--</plugins>-->
    
       <!--<extensions>-->
       <!--<extension>-->
       <!--<groupId>kr.motd.maven</groupId>-->
       <!--<artifactId>os-maven-plugin</artifactId>-->
       <!--<version>1.4.1.Final</version>-->
       <!--</extension>-->
       <!--</extensions>-->
       <!--<plugins>-->
       <!--<plugin>-->
       <!--<groupId>org.xolstice.maven.plugins</groupId>-->
       <!--<artifactId>protobuf-maven-plugin</artifactId>-->
       <!--<version>0.5.0</version>-->
       <!--<configuration>-->
       <!--<protocArtifact>-->
       <!--com.google.protobuf:protoc:3.1.0:exe:${os.detected.classifier}-->
       <!--</protocArtifact>-->
       <!--<pluginId>grpc-java</pluginId>-->
       <!--<pluginArtifact>-->
       <!--io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}-->
       <!--</pluginArtifact>-->
       <!--</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.5.0.Final</version>
           </extension>
       </extensions>
       <plugins>
           <plugin>
               <groupId>org.xolstice.maven.plugins</groupId>
               <artifactId>protobuf-maven-plugin</artifactId>
               <version>0.5.1</version>
               <configuration>
                   <!--源IDL文件,如下为默认值-->
                   <protoSourceRoot>${project.basedir}/src/main/proto</protoSourceRoot>
                   <!--默认值-->
                   <!--<outputDirectory>${project.build.directory}/generated-sources/protobuf/java</outputDirectory>-->
                   <!--配置编译后输出的文件地址-->
                   <outputDirectory>${project.build.directory}/generated-sources/protobuf/java</outputDirectory>
                   <!--设置是否在生成java文件之前清空outputDirectory的文件,默认值为true,设置为false时也会覆盖同名文件-->
                   <clearOutputDirectory>true</clearOutputDirectory>
                   <protocArtifact>
                       com.google.protobuf:protoc:3.5.1:exe:${os.detected.classifier}
                   </protocArtifact>
                   <pluginId>grpc-java</pluginId>
                   <!--编译器地址,用artifact、groupId、version来确定唯一性f-->
                   <pluginArtifact>
                       io.grpc:protoc-gen-grpc-java:${grpc.version}:exe:${os.detected.classifier}
                   </pluginArtifact>
               </configuration>
               <executions>
                   <execution>
                       <goals>
                           <goal>compile</goal>
                           <goal>compile-custom</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
    </build>
    
    

    实例代码如下:

    		PersonModel.person forezp = PersonModel.person.newBuilder()
                    .setId(1)
                    .setName("bzb")
                    .setEmail("15851485932@163.com")
                    .build();
    
            for (byte b : forezp.toByteArray()){
                System.out.print(b);
            }
    
            System.out.println("\n bytes长度" + forezp.toByteString().size());
    
            System.out.println("forezp byte结束==============");
    
            System.out.println("forezp 反序列化对象开始================");
            PersonModel.person forezpCopy = null;
    
            try {
                forezpCopy = PersonModel.person.parseFrom(forezp.toByteArray());
            } catch (InvalidProtocolBufferException e) {
                e.printStackTrace();
            }
    
            System.out.println(forezpCopy.toString());
            System.out.println("forezp 反序列化对象结束================");
    
    

    采用Protobuf序列化的数据可读性很差,但体积很小,所有能大大提高传输效率。

    Proto Buffer语法介绍

    1. 定义一个Java的List集合类的变量,需要在变量前使用repeated关键字,如下所示:
    message ComplexObject {
    	repeated string sons = 4; // List列表
    	repeated Person persons = 6; // 复杂对象列表
    }
    2. 定义一个Map类型,使用map关键字,如下:
    

    message ComplexObject {
    map<string, Person> map = 8;
    }

    3. 定义枚举类,使用enum关键字,如下:
    

    enum Gender {
    MAN = 0;
    WOMAN = 1;
    }

    
    可以参考https://developers.google.com/protocol-buffers/docs/proto3
    # gRPC基于HTTP2
    HTTP2即超文本传输协议版本2,HTTP2通过对头部字段进行压缩,在客户端和服务端建立连接之后允许双向传输数据来提供传输效率、减少延迟。HTTP2还允许在客户端和服务端未建立连接的情况下由服务端发送消息到客户端。
    
    HTTP2的一些概念和特性:
    1. 二进制流
    HTTP2是一个二进制协议,对帧(Frame)的使用更为简单。帧是数据传输的最小单位。每个帧都属于一个特定的流(stream)。一个请求或响应可能由多个帧组成。HTTP2的请求和响应以帧为单位进行了划分,所有的帧都在流上传输,帧可以不按照顺序发送,然后在服务端重新按照头部字段Stream Identifier进行排序。帧具有如下的公共字段:Type, Length, Flags, Stream Identifier, Frame Payload。
    2. 多路复用
    客户端和服务端的连接可以包含多个并发的流,流被客户端和服务端共享,可以让客户端和服务端同时发生消息,也可以单方发生消息,也可以被任意一方关闭。流的多路复用,提高了连接的利用率。
    3. 头压缩
    HTTP是一种无状态的协议,客户端只有发生cookies才能让服务器记住客户端 的一些状态,cookies可能包含的消息比较复杂,并且每次请求都需要携带cookies,这会严重拖累HTTP请求的速度,所以头压缩是非常有必要的。
    4. 服务器推送
    也称为缓存推送。它可以让服务器在客户端不发生请求的情况下,主动将资源推送给客户端,并让客户端缓存起来,从而但需要该资源时,直接从缓存中取。服务器推送需要客户端主动开启,开启之后,客户端可以随时终止该推送服务(发送一个RST_STREAM帧来终止)。
    
    gRPC基于HTTP2,继承了HTTP2的优点,带来诸如双向、流控、头部压缩、单TCP连接上的多路复用请求等特性。
    
    # gRPC基于Netty进行IO处理
    Netty是由JBOSS开源的一个异步事件驱动的Java网络应用框架,用于快速开发可维护的、高性能的协议客户端和服务端。
    
    gRPC的Java版本用Netty做为NIO框架。gRPC的客户端和服务端均使用Netty Channel作为数据传输通道,使用Proto Buffer作为数据序列化和反序列化的工具。每个请求被封装成符合HTTP2规范的数据流。客户端连接上服务端的Channel之后,保持长连接,这样就做到了连接复用,从而极大提高了数据交互的效率。
    
    展开全文
  • Spring Cloud和gRPC的整合实战.pdf
  • grpc-spring-boot-starter:用于gRPC框架的Spring Boot启动器模块
  • SpringCloud微服务 gRPC(一)

    千次阅读 2019-07-22 17:40:19
    SpringCloud集成gRPC
  • SpringCloud 集成gRPC 实例
  • springcloud集成grpc(一)

    千次阅读 热门讨论 2019-02-25 10:16:12
    springcloud集成grpc(一) GRPC简介 是谷歌开源的一个高性能的、通用的RPC框架。其他RPC一样,客户端应用程序可以直接调用远程服务的方法,就好像调用本地方法一样。它隐藏了底层的实现细节,包括序列化(XML、...
  • Spring Cloud和gRPC的整合实战

    千次阅读 2019-12-07 15:34:35
    https://github.com/cakin24/spring-cloud-code/tree/master/ch20-1 二zipkin下载以及运行 1地址地址 https://dl.bintray.com/openzipkin/maven/io/zipkin/java/zipkin-server/ 2运行 D:\Program\zipkin>...
  • springcloud高并发坑之ribbon饥饿加载 在本章我们说说grpc的饥饿加载,grpc连接也是一样的问题,发布后,如果超时时间设置的比较短,第一次请求一般会报超时,当高并发情况下发布系统时,会出现一段时间的超时。 ...
  • springcloud集成grpc(二)

    千次阅读 2019-05-27 18:36:35
    上一章内容介绍了springboot2集成net.devh.grpc 本章介绍springboot2集成 Github 地址以及相关 DEMO 代码 ...facade:独立的 Maven 模块,依赖 spring-boot-starter-grpc,需要远程调用的方法,都定...
  • 随着微服务的流行,服务服务之间的稳定性变得越来越重要。 Sentinel 以流量为切入点,从流量控制、熔断降级、系统负载保护等多个维度保护服务的稳定性。 Sentinel 具有以下特征: 丰富的应用场景: Sentinel 承接...
  • 【RPC】springcloudgrpc、dubbo 什么区别?

    千次阅读 多人点赞 2020-07-30 07:40:58
    首先,对 dubbo 不是很了解,所以只说一下我对于 SpringCloud grpc 的了解,如果有什么地方说得不对,请指正。 在 SpringCloud 中,服务间的调用是通过 http 通信的,其实就相当于在调用 RESTFul 接口。而 grpc ...
  • 狂神说SpringCloud学习笔记

    万次阅读 多人点赞 2020-05-21 13:28:29
    注:本文根据哔哩哔哩Up主狂神老师:狂神说Java所讲的spring cloud课程所作的笔记,狂神老师spring cloud 哔哩哔哩视频连接:https://www.bilibili.com/video/BV1jJ411S7xr?p=18spring ,课程代码可用在狂神老师的...
  • 经过一年的发展, Dubbo-go 在技术社区运营方面都已经有了不错的成绩。Dubbo-go 是 Dubbo 的完整 Go 语言实现,在功能实现技术路径上与 Dubbo 有不同程度的对标,项目团队预计很快便可以追平 Java 版的功能。...
  • Dubbo-go 近期还实现了 REST 协议以及 gRPC 的支持,打通了 Spring Cloud gRPC 生态,再加上与 Java Dubbo 的互通,应用场景广泛。因此,它被其开发者叫做“all-in-one”的 RPC 框架。 目前 Dubbo 官方已经投入...
  • springcloud+eureka+grpc

    2020-03-18 09:57:14
    https://blog.csdn.net/weixin_39648546/article/details/90416742

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,634
精华内容 2,253
关键字:

grpc和springcloud

spring 订阅