springboot 集成 grpc 和 protobuf（二） | 在实际项目中使用 grpc 和 protobuf

springboot 集成 grpc 和 protobuf（二） | 在实际项目中使用 grpc 和 protobuf 不熟悉grpc和protobuf的请参考第一篇： springboot 集成 grpc 和 protobuf（一） | grpc和protobuf 的简介及本地使用. 注意：下面的测试代码写在同一个项目中！ 一、项目结构：如下图

二、项目搭建 2.1 引入pom依赖：代码比较长，请耐心

        UTF-8
        UTF-8
        1.8
    

    
        
            org.springframework.boot
            spring-boot-starter
        
        
            org.springframework.boot
            spring-boot-starter-test
            test
        
        
            com.alibaba
            fastjson
            1.2.45
        
        
            com.alibaba
            druid-spring-boot-starter
            1.1.9
        
        
            org.springframework.boot
            spring-boot-starter-web
        
        
            org.springframework.boot
            spring-boot-starter-aop
        
        
            org.springframework
            spring-context-support
        
        
            org.mybatis.spring.boot
            mybatis-spring-boot-starter
            1.3.0
        
        
        
            mysql
            mysql-connector-java
            5.1.38
        
        
            junit
            junit
            test
        

        
        
        
            com.google.protobuf
            protobuf-java
            3.5.1
        
        
        
            io.grpc
            grpc-all
            1.11.0
        
        
            io.netty
            netty-all
            4.1.25.Final
        
        
            io.netty
            netty-tcnative-boringssl-static
            2.0.8.Final
        

        
        
            net.devh
            grpc-client-spring-boot-starter
            1.3.0-RELEASE
        
        
        
            net.devh
            grpc-server-spring-boot-starter
            1.3.0-RELEASE
        
    

    
        
            
                kr.motd.maven
                os-maven-plugin
                1.6.0
            
        
        
            
                org.springframework.boot
                spring-boot-maven-plugin
                
                    
                        
                            repackage
                        
                    
                
            

            
            
                org.apache.maven.plugins
                maven-surefire-plugin
                
                    true
                
            


            
                org.xolstice.maven.plugins
                protobuf-maven-plugin
                0.5.0
                
                    com.google.protobuf:protoc:3.5.1:exe:${os.detected.classifier}
                    grpc-java
                    io.grpc:protoc-gen-grpc-java:1.11.0:exe:${os.detected.classifier}
                    
                    ${project.basedir}/src/main/proto
                    
                    
                    ${project.basedir}/src/main/java
                    
                    false
                
                
                    
                        
                        compile
                        
                            
                            compile
                            
                            compile-custom
                        
                    
                
            
        
    

2.2 proto 文件介绍，第一篇也有介绍 文件名：data.proto

syntax = "proto3";

package example; //编译出来的文件存放目录

service FormatData {	
  rpc DoFormat(Data) returns (Data){}  //这里后面会用到，注意！！！
  // DoForma 客户端调用服务端使用的方法
  // Data 消息体，跟实体类类似，传参和返回都是一个实体接收
}

message Data {
  string text = 1;  // 1：代表第一个参数
  string flag = 2;  // 2：代表第二个参数
}

2.3 项目搭建好后，使用 maven 编译一下

2.4 然后会在java目录下生成：以Grpc结尾的文件才是连接的主要 2.4.1 DataOuterClass 文件是生成上面 data.proto 里面的message下面的 text 和 flag 参数的set和get方法，相当于实体Bean 2.4.2 FormatDataGrpc 文件是 grpc 的连接服务，下面会用这个调用

2.5 编写客户端：

三、代码编写：下面是先写的客户端代码，再写的服务端代码 客户端 3.1 application.yml文件配置（注意，yml文件中最下面url和端口根据启动项目打印的来，服务端有启动时有介绍）

server:
  port: 8078
  servlet:
    context-path: /huangtu-timer

# mysql
spring:
  # 环境 dev|test|prod
  profiles:
    active: test

logging:
  level: debug
  level.com.huangtu: debug
  path: logs/
  file: timer.log

# Grpc配置
grpc:
  client:
    local-grpc-server:
      #测试，大写转小写
      host: 0.0.0.0 		  #grpc服务端的 url
      port: 9090		      #grpc服务端的端口
      enableKeepAlive: true
      keepAliveWithoutCalls: true

3.2 客户端代码如下：一边参考 data.proto 文件一边理解更好

使用自动注入只需要配置yml中的即可，手动配置url和端口的话就注释上面的代码，放开下面代码的注释，然后直接用构造方法调用即可

import example.DataOuterClass;
import example.FormatDataGrpc;
import io.grpc.Channel;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import net.devh.springboot.autoconfigure.grpc.client.GrpcClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.stereotype.Component;
import types.Common;
import types.Unlock;
import types.WalletServiceGrpc;

import java.util.concurrent.TimeUnit;

/**
 * CreateBy: huangtu
 */
@Component
public class GrpcClientService {
    private Logger logger = LoggerFactory.getLogger(GrpcClientService.class);

    /** yml文件配置自动注入grpc的url和端口 */
//    @GrpcClient("local-grpc-server")
//    private Channel serverChannel;


    /**
     * 测试方法
     * @param letter        字母大小写转换
     */
//    public void sendMessage(String letter) {
        //将yml文件中的url和端口封装进连接服务 -- 
        //这里大部分都是一样的，proto文件里面的server是什么方法，这里就会自带 xxxxxBlockingStub
//        FormatDataGrpc.FormatDataBlockingStub stub = FormatDataGrpc.newBlockingStub(serverChannel);
        //调用连接方法，封装参数，进行传输和接收
        //自己自定义的 proto 文件直接参考替换类和方法就行
 //       DataOuterClass.Data data = stub.doFormat(DataOuterClass.Data.newBuilder().setText(letter).build());
 //       logger.info(data.getText()+"=======");
 //   }


    /** 手动配置grpc的url和端口 */
    private final ManagedChannel channel;
    private final FormatDataGrpc.FormatDataBlockingStub blockingStub;
    public GrpcClientService(String host, int port) {
        ManagedChannelBuilder channelBuilder = ManagedChannelBuilder.forAddress(host, port).usePlaintext(true);
        channel = channelBuilder.build();
        blockingStub = FormatDataGrpc.newBlockingStub(channel);
    }

	/**
     * 停止连接---遇到异常可关闭连接----一般不用，因为连接是一直在的，报错看日志即可，关闭则需要重启服务端
     */
    public void shutdown() throws InterruptedException {
        channel.shutdown().awaitTermination(5, TimeUnit.SECONDS);
    }
    
    /**
     * 测试方法
     * @param letter        字母：大小写转换
     */
    public void sendMessage(String letter) {
        //将yml文件中的url和端口封装进连接服务 -- 
        //这里大部分都是一样的，proto文件里面的server是什么方法，这里就会自带 xxxxxBlockingStub
        FormatDataGrpc.FormatDataBlockingStub stub = FormatDataGrpc.newBlockingStub(serverChannel);
        //调用连接方法，封装参数，进行传输和接收
        //自己自定义的 proto 文件直接参考替换类和方法就行
        DataOuterClass.Data data = stub.doFormat(DataOuterClass.Data.newBuilder().setText(letter).build());
        logger.info(data.getText()+"=======");
    }

}

服务端---- 3.3 java服务端代码：

3.3.1 加入pom依赖：这里的服务端依赖已经在上面加了，所以可以不用重复加

    net.devh
    grpc-server-spring-boot-starter
    1.3.0-RELEASE

3.3.2 服务端代码

import example.DataOuterClass;
import example.FormatDataGrpc;
import io.grpc.stub.StreamObserver;
import net.devh.springboot.autoconfigure.grpc.server.GrpcService;

/**
 * CreateBy: huangtu
 */
@GrpcService(DataOuterClass.class)
public class GrpcServerService extends FormatDataGrpc.FormatDataImplBase {

    //注意，这里的 doFormat 方法，要跟dat.proto文件的server代码块里面的方法一样，注意大小写
    //因为我这里message 代码块 是Data。我自己既用它做传参也用它做返回
    //request是客户端传过来的参数，responseObserver是返回给客户端响应的参数
    public void doFormat(DataOuterClass.Data request, StreamObserver responseObserver) {
        String text = request.getText();
        StringBuffer stringBuffer = new StringBuffer();
        //大小写转换
        for(int i=0;i