Java→gRPC→Python业务功能调用实例

super1

写完这个Java→gRPC→Python业务功能调用实例，实验服务器的架构图就全部完成，加上最后一块砖封顶了。

本篇在gRPC自带的HellowWorld例子上增加一个功能调用，调用前面文章中建立的墨尔本房价分析模型，服务器部分用Python实现，客户端是Java的Tomcat Web App，用浏览器访问。

一、运行效果

1、浏览器输入。

选择回归算法及输入异常值阀值

2、服务器处理请求。

服务器打印收到的请求信息以便调试

3、客户端接收服务器返回结果。

客户端接收异常房价列表并查询原始数据

这里为了在一个页面上显示返回的异常数据及原始数据，将异常值阀值设为偏差60%，返回了6条记录。训练集有7212条数据，验证集有1803条数据，回归算法中准确率较好的已超过90%，非常高了。

二、Python部分

1、proto接口原型文件helloworld.proto。

增加了一个RPC调用GetOutliers()，以及它的调用参数message MelbourneRequest{}和返回结果message MelbourneReply{}，注意返回结果是不定长的列表，所以前面加stream定义返回结果为一个流，gRPC的一个优点是支持流操作，非常方便。
// Copyright 2015 The gRPC Authors//// Licensed under the Apache License, Version 2.0 (the "License");// you may not use this file except in compliance with the License.// You may obtain a copy of the License at////     http://www.apache.org/licenses/LICENSE-2.0//// Unless required by applicable law or agreed to in writing, software// distributed under the License is distributed on an "AS IS" BASIS,// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.// See the License for the specific language governing permissions and// limitations under the License.syntax = "proto3";option java_multiple_files = true;option java_package = "io.grpc.examples.helloworld";option java_outer_classname = "HelloWorldProto";option objc_class_prefix = "HLW";package helloworld;// The greeting service definition.service Greeter {  // Sends a greeting  rpc SayHello (HelloRequest) returns (HelloReply) {}    // Get outliers of Melbourne house pricing for a given algo and threshold.  rpc GetOutliers (MelbourneRequest) returns (stream MelbourneReply) {}}// The request message containing the user's name.message HelloRequest {  string name = 1;}// The response message containing the greetingsmessage HelloReply { string message = 1;}// Added for the Melbourne Example by Jean, 2022/12/13.// The request message containing the algo's name and threshhold for outliers.message MelbourneRequest {  string algo = 1;  double  threshold = 2;}// The response message containing the outliers.message MelbourneReply {  int64 row = 1;  double origin =2;  double predict =3;  double se =4;}
Protocol Buffers项目文档中有各种语言之间的数据类型转换对照表，要按对照表来定义参数的类型，Java中用double比float要方便一点。

Protocol Buffers数据类型对照表

定义好接口原型文件后要先编译它，以便在Python服务器程序中引用新增加的接口类。
[jean@VM-4-12-centos grpcTest]$ pwd/home/jean/grpcTest[jean@VM-4-12-centos grpcTest]$ python -m grpc_tools.protoc  -I.  --python_out=. --pyi_out=. --grpc_python_out=. helloworld.proto
2、Python服务器程序greeter_server_SSL_Auth.py。

增加了三个变量，各个回归算法在训练集的拟合结果train、验证集的拟合结果valid及算法性能perf，服务器启动时在主程序中直接执行与前面Shiny APP共享的Melbourne_Regress.py脚本加载预处理好的数据与各个算法最优参数的回归模型，然后初始化上述三个变量。具体脚本及参数优化请参阅前面的文章。

在服务类Greeter()中增加了提供服务的方法GetOutliers()，根据请求中的算法与阀值从验证集拟合结果valid中选出异常值，每个异常值一行，生成一个接口原型中定义的MelbourneReply对象outlier，用yield outlier以stream的形式返回给客户端。gRPC 官方文档中文版中有Python stream用法的说明。
# Copyright 2015 gRPC authors.## Licensed under the Apache License, Version 2.0 (the "License");# you may not use this file except in compliance with the License.# You may obtain a copy of the License at##     http://www.apache.org/licenses/LICENSE-2.0## Unless required by applicable law or agreed to in writing, software# distributed under the License is distributed on an "AS IS" BASIS,# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.# See the License for the specific language governing permissions and# limitations under the License."""The Python implementation of the GRPC helloworld.Greeter server."""from concurrent import futuresimport loggingimport grpcimport helloworld_pb2import helloworld_pb2_grpcimport timeimport pandas as pdimport numpy as nptrain = Nonevalid = Noneperf  = None# The Class to serve the client with a Function defined by tha proto file.class Greeter(helloworld_pb2_grpc.GreeterServicer):    def SayHello(self, request, context):        print(request.name)        return helloworld_pb2.HelloReply(message='Hello, %s!' % request.name)    def GetOutliers(self, request, context):        print(request.algo)        print(request.threshold)                test = valid[["origin",request.algo]]        test.index.name = 'row'        test.reset_index(inplace=True)        test.rename(columns={request.algo:"predict"},inplace=True)        test["origin2"] = np.exp(test["origin"])        test["predict2"] = np.exp(test["predict"])        test["se"] = np.round((test["predict2"]- test["origin2"])/test["origin2"]*100,1)        outliers =test.loc[np.abs(test["se"])>= request.threshold]        outliers = outliers[["row","origin2","predict2","se"]]        outliers.rename(columns={"origin2":"origin","predict2":"predict"},inplace=True)        outliers.sort_values(["se"],ascending = True, inplace=True)        for index, onerow in outliers.iterrows():          outlier = helloworld_pb2.MelbourneReply(\            row = int(onerow["row"]),\            origin = onerow["origin"],\            predict = onerow["predict"],\            se = onerow["se"]            )          # print(outlier)          yield outlier        # For authenticating with a password.class AuthInterceptor(grpc.ServerInterceptor):    def __init__(self, key):        # 'rpc-auth-header' is the header data containing the password.        self._valid_metadata = ('rpc-auth-header', key)        def deny(_, context):            context.abort(grpc.StatusCode.UNAUTHENTICATED, 'Invalid key')        self._deny = grpc.unary_unary_rpc_method_handler(deny)    def intercept_service(self, continuation, handler_call_details):        meta = handler_call_details.invocation_metadata        print(meta)        # https://grpc.io/docs/guides/auth/#extending-grpc-to-support-other-authentication-mechanisms        # There's a bug in the document, meta[0] should be meta[1] for newer versions.        if meta and meta[1] == self._valid_metadata:            return continuation(handler_call_details)        else:            return self._deny# The server procedure.def serve():    port = '50051'    # Now requires authentication with a password by attaching an interceptor.    # 'access_key' is the password.    server = grpc.server(                futures.ThreadPoolExecutor(max_workers=10),                interceptors=(AuthInterceptor('access_key'),)             )    helloworld_pb2_grpc.add_GreeterServicer_to_server(Greeter(), server)    # Load the server's certificate chain & private key.    # So the server should be run as root.    with open('/root/cert/server.key', 'rb') as f:        private_key = f.read()    with open('/root/cert/server.crt', 'rb') as f:        certificate_chain = f.read()    with open('/root/cert/ca.crt', 'rb') as f:        root_certificates = f.read()    # False means client cert is not required.    server_credentials = grpc.ssl_server_credentials(((private_key, certificate_chain),), root_certificates,False)    # '[::]:' means may be accessed from any IP.    server.add_secure_port('[::]:' + port, server_credentials)        server.start()    print("Server started, listening on " + port)    # May be interrupted by Ctrl+C.    server.wait_for_termination()if __name__ == '__main__':      print("Loading Melbourne models......")    t_started = time.time()    exec(open("/home/jean/scripts/Melbourne_Regress.py").read())    train = PredictTrain()    valid = PredictValid()    perf = performance()    t_finished = time.time()    print("Melbourne models loaded, "+str(round(t_finished-t_started,1))+" seconds.")      logging.basicConfig()    serve()
3、Python客户端程序greeter_client_SSL_Auth.py。

Python客户端程序是测试用途，以验证服务器程序工作正常。先构造一个接口原型中定义的MelbourneRequest对象，然后调用GetOutliers()函数，返回的stream在Python客户端中是一个Iterator，用for语句遍历，具体可参阅gRPC 官方文档中文版。
    print("Outlier client received: \n")    for outlier in stub.GetOutliers(helloworld_pb2.MelbourneRequest(algo='cat', threshold=65)):        print(outlier)
完整的程序。
# Copyright 2015 gRPC authors.## Licensed under the Apache License, Version 2.0 (the "License");# you may not use this file except in compliance with the License.# You may obtain a copy of the License at##     http://www.apache.org/licenses/LICENSE-2.0## Unless required by applicable law or agreed to in writing, software# distributed under the License is distributed on an "AS IS" BASIS,# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.# See the License for the specific language governing permissions and# limitations under the License."""The Python implementation of the GRPC helloworld.Greeter client."""from __future__ import print_functionimport loggingimport grpcimport helloworld_pb2import helloworld_pb2_grpc# Class to add authentication header to the meta data of every gRPC call.class GrpcAuth(rpc.AuthMetadataPlugin):    def __init__(self, key):        self._key = key    # 'rpc-auth-header' is the authentication header defined by the server.    def __call__(self, context, callback):        callback((('rpc-auth-header', self._key),), None)def run():    # NOTE(gRPC Python Team): .close() is possible on a channel and should be    # used in circumstances in which the with statement does not fit the needs    # of the code.    print("Will try to greet world ...")    # Will fail for enpty credentials.    # creds = grpc.ssl_channel_credentials()    # Need to include root certificate in credentials.    # https://stackoverflow.com/questions/72230151/how-to-open-a-secure-channel-in-python-grpc-client-without-a-client-ssl-certific    # Copy the selfsigned CA's root cert to the client directory, so that the client doesn't need to be run as root.    with open('ca.crt', 'rb') as f:        creds = grpc.ssl_channel_credentials(f.read())        # A composite channel credentials with SSL and password.    # Host name need to be the same as the server certificate.     channel = grpc.secure_channel(        'jeanye.cn:50051',        grpc.composite_channel_credentials(            creds,            grpc.metadata_call_credentials(                GrpcAuth('access_key')                # A worng key will fail then.                # GrpcAuth('wrong_access_key')            )        )    )            stub = helloworld_pb2_grpc.GreeterStub(channel)    response = stub.SayHello(helloworld_pb2.HelloRequest(name='Jean'))    print("Greeter client received: " + response.message)        print("Outlier client received: \n")    for outlier in stub.GetOutliers(helloworld_pb2.MelbourneRequest(algo='cat', threshold=65)):        print(outlier)    if __name__ == '__main__':    logging.basicConfig()    run()
运行Python客户端程序。

服务器端打印请求的算法与阀值以便调试

Python客户端正确运行

三、Java客户端

演示性质，暂时还是在Java客户端项目中生成存根stub类，然后拷贝到Tomcat Web项目中，用Java客户端项目先测试也要方便一点。

1、proto接口原型文件helloworld.proto。

客户端项目同上篇文章配置，拷贝上面的接口原型文件到Java客户端项目中更新原来的文件。项目名grpcclient 上右键-> Run As -> Maven Build，重新生成Java的stub类。

2、HelloWorldClientSSLAuthMelbourne.java。

Java客户端操作gRPC stream的例子可以参阅grpc-java自带的RouteGuide例子及其proto文件。gRPC stream在Java客户端也是一个java.util.Iterator类，可以通过for()循环去迭代，用hasNext()判断是否结束，用next()去获取下一个返回的MelbourneReply对象，存储为一个java.util.List以便后续处理。注意blockingStub.getOutliers()，与接口原型定义中相比，java方法的首字母按Java函数的惯例都改成了小写。
package io.grpc.examples.helloworld;import io.grpc.Channel;import io.grpc.ClientInterceptor;import io.grpc.ClientInterceptors;import io.grpc.ManagedChannel;import io.grpc.StatusRuntimeException;import io.grpc.examples.header.HeaderClientInterceptor;import io.grpc.netty.shaded.io.grpc.netty.GrpcSslContexts;import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.io.File;import java.util.concurrent.TimeUnit;import java.util.logging.Level;import java.util.logging.Logger;/** * A simple client that requests a greeting from the {@link HelloWorldServer}. */public class HelloWorldClientSSLAuthMelbourne {  private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());  private final GreeterGrpc.GreeterBlockingStub blockingStub;  /** Construct client for accessing HelloWorld server using the existing channel. */  public HelloWorldClientSSLAuthMelbourne(Channel channel) {    // 'channel' here is a Channel, not a ManagedChannel, so it is not this code's responsibility to    // shut it down.    // Passing Channels to code makes code easier to test and makes it easier to reuse Channels.    blockingStub = GreeterGrpc.newBlockingStub(channel);  }    /** Get outliers of Melbourne house price. */  public List<MelbourneReply> getOutliers(String algo, double threshold) {    logger.info("Will try to get outliers for algo " + algo +" with threshold "+ threshold + " ...");    MelbourneRequest request = MelbourneRequest.newBuilder().setAlgo(algo).setThreshold(threshold).build();    Iterator<MelbourneReply>  response;       List<MelbourneReply> result = new ArrayList<>();    try {        response = blockingStub.getOutliers(request);        for (int i = 1; response.hasNext(); i++) {            MelbourneReply outlier = response.next();            result.add(outlier);            System.out.println("Result #" + i + ": "+outlier.getRow()+" | "+ Math.round(outlier.getOrigin()*100.0)/100.0+" | "+Math.round(outlier.getPredict()*100.0)/100.0+" | "+outlier.getSe());        }      } catch (StatusRuntimeException e) {          logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());        return null;      }    logger.info("Get outliers of Melbourne house price.");    return result;  }      /**   * Greet server. If provided, the first element of {@code args} is the name to use in the   * greeting. The second argument is the target server.   */  public static void main(String[] args) throws Exception {    /*      * Use NettyChannelBuilder to build SSL connection to server.     * https://stackoverflow.com/questions/42700411/ssl-connection-for-grpc-java-client     * Need to include selfsigned CA certificate to build a sslContext to verify the server.     * And the server name must be same as the name in the server certificate.     */        ManagedChannel originChannel = NettyChannelBuilder.forAddress("jeanye.cn", 50051)            .sslContext(GrpcSslContexts.forClient().trustManager(new File("d:/temp/ca.crt")).build())            .build();         ClientInterceptor interceptor = new HeaderClientInterceptor();    Channel channel = ClientInterceptors.intercept(originChannel, interceptor);    try {        HelloWorldClientSSLAuthMelbourne client = new HelloWorldClientSSLAuthMelbourne(channel);        List<MelbourneReply> res = client.getOutliers("cat",60.0);    } finally {      // ManagedChannels use resources like threads and TCP connections. To prevent leaking these      // resources the channel should be shut down when it will no longer be used. If it may be used      // again leave it running.        originChannel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);    }  }}
运行结果：

Java客户端运行正确

四、Tomcat Web App

1、拷贝上面Java客户端项目生成的stub类更新。
GreeterGrpc.java                        HelloReply.java                         HelloReplyOrBuilder.java                HelloRequest.java                       HelloRequestOrBuilder.java              HelloWorldProto.java                    MelbourneReply.java                     MelbourneReplyOrBuilder.javaMelbourneRequest.java                   MelbourneRequestOrBuilder.java
2、HelloWorldClientSSLAuthMelbourne.java。

参考上面的Java客户端编写，实现gRPC调用的帮助类。
package io.grpc.examples.helloworld;import io.grpc.Channel;import io.grpc.ClientInterceptor;import io.grpc.ClientInterceptors;import io.grpc.ManagedChannel;import io.grpc.StatusRuntimeException;import io.grpc.netty.shaded.io.grpc.netty.GrpcSslContexts;import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;import java.io.File;import java.util.ArrayList;import java.util.Iterator;import java.util.List;import java.util.concurrent.TimeUnit;import java.util.logging.Level;import java.util.logging.Logger;/** * A simple client that requests a greeting from the {@link HelloWorldServer}. */public class HelloWorldClientSSLAuthMelbourne {    private static final Logger logger = Logger.getLogger(HelloWorldClient.class.getName());    private final GreeterGrpc.GreeterBlockingStub blockingStub;    private ManagedChannel originChannel = null;    private Channel channel = null;    /** Construct client for accessing HelloWorld server by creating a channel. */    public HelloWorldClientSSLAuthMelbourne(String caFile, String server, Integer port) throws Exception {        /*         * Use NettyChannelBuilder to build SSL connection to server.         * https://stackoverflow.com/questions/42700411/ssl-connection-for-grpc-java-         * client Need to include selfsigned CA certificate to build a sslContext to         * verify the server. And the server name must be same as the name in the server         * certificate.         */        originChannel = NettyChannelBuilder.forAddress(server, port)                .sslContext(GrpcSslContexts.forClient().trustManager(new File(caFile)).build()).build();        // "access_key" is the password to call gRPC.        ClientInterceptor interceptor = new HeaderClientInterceptor("access_key");        // Channel with an interceptor to add an auth header for each gRPC call.        channel = ClientInterceptors.intercept(originChannel, interceptor);        // 'channel' here is a Channel, not a ManagedChannel, so it is not this code's        // responsibility to shut it down.        // Passing Channels to code makes code easier to test and makes it easier to        // reuse Channels.        blockingStub = GreeterGrpc.newBlockingStub(channel);    }    /** Say hello to server. */    public String greet(String name) {        logger.info("Will try to greet " + name + " ...");        HelloRequest request = HelloRequest.newBuilder().setName(name).build();        HelloReply response;        try {            response = blockingStub.sayHello(request);        } catch (StatusRuntimeException e) {            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());            return (e.toString());        }        logger.info("Greeting: " + response.getMessage());        return (response.getMessage());    }    /** Get ooutliers of Melbourne house price. */    public List<MelbourneReply> getOutliers(String algo, double threshold) {        logger.info("Will try to get outliers for algo " + algo + " with threshold " + threshold + " ...");        MelbourneRequest request = MelbourneRequest.newBuilder().setAlgo(algo).setThreshold(threshold).build();        Iterator<MelbourneReply> response;        List<MelbourneReply> result = new ArrayList<>();        try {            response = blockingStub.getOutliers(request);            for (int i = 1; response.hasNext(); i++) {                MelbourneReply outlier = response.next();                result.add(outlier);                System.out.println("Result #" + i + ": " + outlier.getRow() + " | " + outlier.getOrigin() + " | "                        + outlier.getPredict() + " | " + outlier.getSe());            }        } catch (StatusRuntimeException e) {            logger.log(Level.WARNING, "RPC failed: {0}", e.getStatus());            return null;        }        logger.info("Get outliers of Melbourne house price.");        return result;    }    /** Close the channel. */    public void close() throws Exception {        try {            // ManagedChannels use resources like threads and TCP connections. To prevent            // leaking these            // resources the channel should be shut down when it will no longer be used. If            // it may be used again leave it running.            originChannel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);        } catch (Exception e) {            e.printStackTrace();        }    }}
3、algo.jsp。

输入页面，选择算法及输入异常值阀值。
<%@ page language="java" contentType="text/html; charset=GBK"    pageEncoding="GBK"%><!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd"><html><head><meta http-equiv="Content-Type" content="text/html; charset=GBK"><title>Java EE gRPC调用测试</title></head><body><center> <form action="melbourne.jsp" method="post"> 墨尔本房价gRPC调用示例 <br/>  算法:<select name="algo" id="algo">      <option value="svm">SVM</option>      <option value="rf">RandomForest</option>      <option value="gbr">GBR</option>      <option value="xgb">XGB</option>      <option value="lgbm">LigthGBM</option>      <option value="cat" selected>CatBoost</option>      <option value="blend">Blend</option>            </select>       <br/>  异常值阀值:<input type="number" name="threshold" value=60><br/> <input type="submit" value="查看异常值"> </form> </center></body></html>
4、melbourne.jsp。

显示gRPC调用结果及匹配的原始数据，所以项目中打包了原始数据文件（预处理）Melbourne_housing_pre.csv。
<%@ page language="java" contentType="text/html; charset=GBK"    pageEncoding="GBK"%><%@ page import="io.grpc.examples.helloworld.*,java.util.*,java.io.BufferedReader,java.io.FileReader"%>        <%List<MelbourneReply> resp =null;Set<Long> set = new HashSet<Long>();try{        String algo = request.getParameter("algo");    Double threshold = new Double(request.getParameter("threshold"));    if (algo==null) algo = "cat";    //String server = "localhost";    String server = "jeanye.cn";    Integer port = 50051;        // Plain text without SSL & password.    // HelloWorldClient client = new HelloWorldClient(server, port);    String caFile =  application.getRealPath("/WEB-INF/ca.crt");    // SSL without password.    // HelloWorldClientSSL client = new HelloWorldClientSSL(caFile,server,port);     // SSL with password.    //HelloWorldClientSSLAuth client = new HelloWorldClientSSLAuth(caFile,server,port);      HelloWorldClientSSLAuthMelbourne client = new HelloWorldClientSSLAuthMelbourne(caFile,server,port);           resp = client.getOutliers(algo, threshold);    client.close();    }catch(Exception e){    e.printStackTrace();}%>    <!DOCTYPE html><html><head><meta charset="GBK"><title>Java EE 调用gRPC 测试</title></head><body><h3>Java gRPC调用服务器端Python程序结果  <a href="algo.jsp">返回</a></h3><%if (resp !=null){%><table boder="1" cellspacing="0" bordercolor="#D3D3D3"><tr><td>行号</td><td>真实值</td><td>预测值</td><td>偏差%</td></tr><%    for(Iterator it=resp.iterator();it.hasNext();){        MelbourneReply outlier = (MelbourneReply)it.next();        set.add(outlier.getRow());%><tr><td><%= outlier.getRow()%></td><td><%=  Math.round(outlier.getOrigin()*100.0)/100.0%></td><td><%= Math.round(outlier.getPredict()*100.0)/100.0%></td><td><%= outlier.getSe()%></td></tr><%    }%></table><%}%><br><h3>匹配的原始数据</h3><table border="1" cellspacing="0" bordercolor="#D3D3D3"><tr><% String path = request.getRealPath("/WEB-INF");System.out.println(path);BufferedReader reader = new BufferedReader(new FileReader(path+"/Melbourne_housing_pre.csv"));// skip headerString header[] =reader.readLine().split(",");header[0] = "Row";for (int i=0; i<header.length;i++){%><td><%=header%></td><%}%></tr><%String line = null;long index=0; //读取每行，直到为空while((line=reader.readLine())!=null){     if (set.contains(index)){        String items[] = line.split(",");%><tr><%        for (int i=0; i< items.length; i++){%><td><%=items %></td><%        }%></tr><%    }    index++;}%></table><br><a href="algo.jsp">返回</a></body></html>
5、本机测试。

Tomcat本地测试选择算法与阀值

服务器发返回结果正确

6、部署到服务器上运行，见本篇开头的运行效果。

五、用Maven管理Tomcat项目

参考资料。用Maven管理Tomcat项目的好处，一是可以在项目中根据proto接口原型定义生成Java stub类，不用从Java客户端项目中拷贝；二是开发时不用逐个导入依赖的包，Maven会自动解决依赖关系，下载导入相应的包；三是打包成war发布到服务器时，Maven会自动把依赖包放进去。这样就方便多了。程序与上面的Tomcat Web App是一样的，只是项目的组织结构有所不同。

1、建立Maven管理的Web APP项目。

Eclipse->File->New Maven Project，后面要选择archetype，不要选simple project。

建立一个Maven项目

Catalog选All Catalogs，Filter中输入maven-archetype-webapp，项目类型选Group Id: org.apache.maven.archetypes，Artifact Id: maven-archetype-webapp，注意它的版本是1.4。如果Catalog选了Internal，也可以列出来，但它会是内置的1.0版，二者生成的pom.xml是不一样的。All Catalog要联网到各个catalog去下载archetype列表（可以按configure按钮配置），取决于网络的状况，有时候可能会出不来，有时候可能要等几十秒。

选择正确的Group Id和 Artifact Id

Internal自带的1.0版生成不同的pom.xml，本篇用1.4版

为自己的项目定义Group Id与Artifact Id，因为已经建好了grpc项目，用grpcTest演示，所以前后截图的项目名可能会有所不同。

为自己的项目定义Group Id与Artifact Id

项目名上右键->Properties->Java Build Path->Add Library，Server Runtime把Tomcat Server Runtime加入，否则JSP编译报错。JRE System Library把适当的JDK加入，由于我的笔记本上JDK11的版本比服务器上JDK11的版本新，导致服务器上部署时报java.lang.unsupportedclassversionerror，我在笔记本上降为JDK8。此时Maven Dependencies只有基本的junit等，后面再加。

设置Java Build Path

此时可以在项目名上右键->Run As->Run on Server，选择前面实验中配好的Tomcat服务器，把新建的项目发布到Tomcat上，在Eclipse中浏览首页，验证项目正确创建，它会自动生成web.xml。

启动Maven管理的Tomcat项目

2、更新pom.xml。

1)、将java版本设为与build path一样的1.8。

2)、把前面gRPC Java客户端项目中pom.xml的dependency拷贝过来。

3)、因为不了解<pluginManagement>的用法，新建了一个<plugins>，把Java客户端项目中pom.xml的generate-sources一节的plugin拷贝过来，用来生成gRPC的Java stub类源码。参阅资料。

4)、<build>里的<defaultGoal>也可以拷贝过来，generate-sources要排在clean后，其它任务的前面。
然后在项目名上右键->Maven->Update Project，更新Maven项目的Java Build Path引用。如果是本地第一次引用这些包，Maven联网下载可能需要一点时间。

完整的源码如下：
<?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>jean.test</groupId>    <artifactId>grpc</artifactId>    <versin>0.0.1-SNAPSHOT</version>    <packaging>war</packaging>    <name>grpc Maven Webapp</name>    <!-- FIXME change it to the project's website -->    <url>http://www.example.com</url>    <properties>        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>        <maven.compiler.source>1.8</maven.compiler.source>        <maven.compiler.target>1.8</maven.compiler.target>    </properties>    <dependencies>        <dependency>            <groupId>junit</groupId>            <artifactId>junit</artifactId>            <version>4.11</version>            <scope>test</scope>        </dependency>        <dependency>            <groupId>com.google.protobuf</groupId>            <artifactId>protobuf-java</artifactId>            <version>3.21.7</version>        </dependency>        <dependency>            <groupId>io.grpc</groupId>            <artifactId>grpc-netty-shaded</artifactId>            <version>1.51.0</version>        </dependency>        <dependency>            <groupId>io.grpc</groupId>            <artifactId>grpc-protobuf</artifactId>            <version>1.51.0</version>        </dependency>        <dependency>            <groupId>io.grpc</groupId>            <artifactId>grpc-stub</artifactId>            <version>1.51.0</version>        </dependency>        <!-- Removed from JDK11 and above, need to be added here -->        <!-- https://blog.csdn.net/ml863606/article/details/109202246?utm_medium=distribute.pc_relevant.none-task-blog-2~default~baidujs_baidulandingword~default-0-109202246-blog-120904477.pc_relevant_3mothn_strategy_recovery&spm=1001.2101.3001.4242.1&utm_relevant_index=3 -->        <dependency>            <groupId>javax.annotation</groupId>            <artifactId>javax.annotation-api</artifactId>            <version>1.3.2</version>        </dependency>    </dependencies>    <build>        <defaultGoal>clean generate-sources compile install</defaultGoal>        <finalName>grpc</finalName>        <pluginManagement><!-- lock down plugins versions to avoid using Maven                 defaults (may be moved to parent pom) -->            <plugins>                <plugin>                    <artifactId>maven-clean-plugin</artifactId>                    <version>3.1.0</version>                </plugin>                <!-- see http://maven.apache.org/ref/current/maven-core/default-bindings.html#Plugin_bindings_for_war_packaging -->                <plugin>                    <artifactId>maven-resources-plugin</artifactId>                    <version>3.0.2</version>                </plugin>                <plugin>                    <artifactId>maven-compiler-plugin</artifactId>                    <version>3.8.0</version>                </plugin>                <plugin>                    <artifactId>maven-surefire-plugin</artifactId>                    <version>2.22.1</version>                </plugin>                <plugin>                    <artifactId>maven-war-plugin</artifactId>                    <version>3.2.2</version>                </plugin>                <plugin>                    <artifactId>maven-install-plugin</artifactId>                    <version>2.5.2</version>                </plugin>                <plugin>                    <artifactId>maven-deploy-plugin</artifactId>                    <version>2.8.2</version>                </plugin>            </plugins>        </pluginManagement>                <plugins>                <!-- compile proto file into java files -->                <plugin>                    <groupId>com.github.os72</groupId>                    <artifactId>protoc-jar-maven-plugin</artifactId>                    <version>3.11.1</version>                    <executions>                        <execution>                            <phase>generate-sources</phase>                            <goals>                                <goal>run</goal>                            </goals>                            <configuration>                                <includeMavenTypes>direct</includeMavenTypes>                                <inputDirectories>                                    <include>src/main/resources</include>                                </inputDirectories>                                <outputTargets>                                    <outputTarget>                                        <type>java</type>                                        <outputDirectory>src/main/java</outputDirectory>                                    </outputTarget>                                    <outputTarget>                                        <type>grpc-java</type>                                        <pluginArtifact>io.grpc:protoc-gen-grpc-java:1.51.0</pluginArtifact>                                        <outputDirectory>src/main/java</outputDirectory>                                    </outputTarget>                                </outputTargets>                            </configuration>                        </execution>                    </executions>                </plugin>               </plugins>            </build></project>

更新好的包依赖关系

3、生成gRPC的Java stub类。

把前面Java客户端项目中的接口原型定义文件helloworld.proto拷贝过来，在项目名字上右键->Run As->Maven generate-sources，则会执行pom.xml中定义的generate-sources任务生成gRPC stub类。注意如果手工删除了生成的stub类，又没有更新proto原型文件，这个操作会直接跳过，什么都不做。更新一下proto原型文件，让它有个新的时间戳，重新运行即可。Maven有这个右键菜单是因为在pom.xml中定义了它。

生成gRPC的Java stub类

Eclipse中有两个可以编辑proto文件的插件，提供了语法高亮显示等功能，我安装了protobuf-dt，具体安装方法请参阅其项目主页上的说明，它有一个小问题，就是不认识proto文件中的option语句，原因是其打包的descriptor.proto文件比较旧，参考该帖子，通过WinRAR用一个比较新的替换（D:/eclipse/plugins/com.google.eclipse.protobuf_2.3.2.201609161849.jar内的）即可，我用了Anaconda3安装好的一个。

编辑proto文件的插件protobuf-dt

替换descriptor.proto

找到版本比较新的descriptor.proto

另外，Eclipse->Window->Preferences->Protocol Buffer->Compiler中，默认不勾选"Compile .proto files on save"选项，不要改它，因为我们用Run As->Maven gererate-sources来生成，勾选了每次更改保存都调Compiler，然后会报错，应该是还没有配好：
Errors occurred during the build.Errors running builder 'Xtext Project Builder' on project 'grpc'.'void com.google.common.io.Closeables.closeQuietly(java.io.Closeable)'

保存proto文件时不要编译

4、把前面Tomcat Web App项目中的程序文件拷贝到Maven Tomcat Web App项目中。包括前面图中的HelloWorldClient*.java，HeaderClient*.java，*.jsp，以及WEB-INF下的资源文件ca.crt、Melbourne_housing_pre.csv，详见前面图中的项目结构。

然后在algo.jsp上右键->Run As->Run on Server，发布到前面配好的Tomcat服务器，运行测试，这与平常是一样的。

测试Maven-Tomcat项目

测试Maven-Tomcat项目

5、打包发布到Linux服务器上。

项目名字上右键->Run As->Maven Build，因为pom.xml中定义了<defaultGoal>，直接按Run按钮就可以。

运行Maven Build打包

生成的war文件在项目的target目录下，可以在Eclipse的Console窗口看build过程的输出。

生成war文件发布到Linux服务器

在Linux服务器上测试

六、配置Python服务端开机自启动
# cd /etc/rc.d# vi rc.local# Startup Python gRPC server, added by Jean 2022/12/16.cd /home/jean/grpcTest/usr/lib64/anaconda3/bin/python  greeter_server_SSL_Auth.py# reboot now
Done.