【仓颉三方库】 网络组件——rpc4cj

别说我什么都不会2025-04-16 10:18

架构图

  • rpc4cj使客户端和服务端应用程序可以透明地进行通信,并简 化了连接系统的构建。

源码目录

arduino 复制代码 
.
├── README.md
├── doc
│   ├── assets
│   ├── cjcov
│   ├── feature_api.md
│   └── design.md
├── src
│   └── attributes
│   └── buffer
│   └── exceptions
│   └── grpc
│   └── internal
│   └── net
│   └── resolver
│   │   └── dns
│   │   └── manual
│   │   └── passthrough
│   └── transport
│   └── util     
└── test
    ├── HLT
    ├── LLT
    └── UT
  • doc存放库的设计文档、提案、库的使用文档、LLT 用例覆盖报告
  • src是库源码目录
  • test存放测试用例，包括HLT用例、LLT 用例和UT用例

接口说明

主要是核心类和成员函数说明，详情见 API

使用说明

编译

编译描述和具体 shell 命令

linux x86 编译：

需要依赖 protobuf4cj, 可在 gitcode.com/Cangjie-TPC... 处编译获取 将构建完成的的 protobuf 文件夹复制到 rpc4cj 项目根目录下面

复制代码 
cjpm build

windows x86 编译：

前提：使用 openssl version 查看环境下有无 openssl, 版本为 OpenSSL 3.x.x,若无，可参考 github.com/openssl/ope... 官网的 Build and Install。

需要依赖 protobuf4cj, 可在 gitcode.com/Cangjie-TPC... 处编译获取 将构建完成的的 protobuf 文件夹复制到 rpc4cj 项目根目录下面

复制代码 
cjpm build

功能示例

需要安装 protobuf 软件及 protobuf4cj 插件: ubuntu 系统可使用以下命令安装 protobuf

bash 复制代码 
apt install -y protobuf-compiler
protoc --version # 正确显示版本号即成功

编译安装 protobuf-gen-cj 插件，可在 gitcode.com/Cangjie-TPC... 处编译获取

使用 protobuf4cj 用该 proto 文件生成 helloworld_pb.cj 文件, 放入test/LLT中，可以使用以下命令，参考 README.md · Cangjie-TPC/protobuf4c - 码云 - 开源中国 (gitcode.com)

scss 复制代码 
protoc --cj_out=.  --proto_path=. $(proto_files) #--cj_out= 指定输出地址，--proto_path=指定proto文件路径

一元调用功能示例

首先运行任意一版本语言的 helloworld server example，或本仓附带 go 版本 server 端 其他语言版本 server 端可于 Supported languages | gRPC内获取

示例 proto 文件如下：

ini 复制代码 
syntax = "proto3";

option go_package = "google.golang.org/grpc/examples/helloworld/helloworld";
option java_multiple_files = true;
option java_package = "io.grpc.examples.helloworld";
option java_outer_classname = "HelloWorldProto";

package helloworld;

service Greeter {
  rpc SayHello (HelloRequest) returns (HelloReply) {}
}

message HelloRequest {
  string name = 1;
}

message HelloReply {
  string message = 1;
}

示例代码如下：

使用测试框架运行，将 "xxxx" 处替换为本地代码仓库地址，并将源代码文件放入test/LLT中。

javascript 复制代码 
// DEPENDENCE: ./helloworld.pb.cj
// EXEC: cjc %import-path %L %l %f ./helloworld.pb.cj  %project-path %project-L/protobuf  -l protobuf-cj
// EXEC: ./main

from std import socket.*
from rpc4cj import grpc.*
from rpc4cj import transport.*
from rpc4cj import exceptions.*
from rpc4cj import util.*
from std import collection.*
from protobuf import protobuf.*
from protobuf import grpc.*
from std import time.*

var port: UInt16 = 50051
main (){
    var req = HelloRequest()
    var resp = HelloReply()
    req.name = "World"
    var con = dial("127.0.0.1:${port}")
    con.invoke("/helloworld.Greeter/SayHello", req, resp)
    println("result: ${resp}")
}

启动仓内提供测试用 go 版本服务器

bash 复制代码 
./test/LLT/test_grpc_post/go_server

另开一终端执行命令

bash 复制代码 
python3 ci_test/main.py test

执行结果如下：

css 复制代码 
result: {message: "Hello World"}

流式调用功能示例

cangjie 双向流式调用的示例如下:

示例代码如下：

scss 复制代码 
from std import socket.*
from rpc4cj import grpc.*
from rpc4cj import transport.*
from rpc4cj import exceptions.*
from rpc4cj import util.*
from std import collection.*
from std import time.*
from std import sync.*
from protobuf import protobuf.*

let strServer: String = "20221226abc"

var port: UInt16 = 0
let num: Int64 = 5
main() {
    let ss: SocketServer = SocketServer(TCP, "127.0.0.1", port)
    port = ss.port

    spawn{ =>
        println("ss=${ss.address}")//127.0.0.1:50051/hello
        let lis: GRPCServerSocket = GRPCServerSocket(GrpcSocketS(ss))

        let server: Server = Server()
        registerGreeterServer(server, ServerTest())
        server.serve(lis)
    }

    sleep(Duration.second)

    var req = HelloRequest()
    var resp = HelloReply()
    req.name = "World"
    var con = dial("127.0.0.1:${port}")//linux

    var stream = con.newStreamClient()

    stream.doStreamRequest("/helloworld.Greeter/SayHello")
    for (i in 0..num) {
        req.name = "World-" + i.toString()
        stream.sendStreamMsg(req)
    }
    var readstream = stream.closeAndRecv()
    while (readstream.recv(resp)) {
        println(resp)
    }
  return 0
}

//protobuf 依赖
class ServerTest <: GreeterServer {
    public func SayHello(hr: HelloRequest): (HelloReply, GrpcError) {
        let hy: HelloReply = HelloReply()
        hy.message = "ceshi-20221227"
        println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~0")
        println("received: hr.name = ${hr.name}")
        println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~1")
        return (hy, GrpcError())
    }
    public func mustEmbedUnimplementedGreeterServer() {}
}

public class HelloRequest <: Message & TypedMessage<HelloRequest> {
    private var p_name = Pb3String()

    public init() {
        m_innerInit()
    }

    public mut prop name: String { get() { p_name.get() } set(i_vtmp) { p_name.set(i_vtmp); markDirty() } }

    protected func m_size(): Int64 {
        var i_tmp = 0
        if (!p_name.isEmpty()) { i_tmp += 1 + binSize(p_name.data) }
        return i_tmp
    }

    protected func m_isEmpty(): Bool {
        p_name.isEmpty()
    }

    protected func m_clear(): Unit {
        p_name.clear()
    }

    public func copyFrom(src: HelloRequest): HelloRequest {
        p_name = src.p_name
        m_innerCopyFrom(src)
        return this
    }

    public func clone(): HelloRequest {
        return HelloRequest().copyFrom(this)
    }

    public func unpack<T>(src: T): Unit where T <: BytesReader {
        while (!src.isEmpty()) {
            let i_tmp = src.parseTag()
            match (i_tmp[0]) {
                case 1 => p_name.unpack(src)
                case _ => m_unknown(src, i_tmp)
            }
        }
        markDirty()
    }

    public func pack<T>(out: T): Unit where T <: BytesWriter {
        if (!p_name.isEmpty()) { out.append(10); out.packBin(p_name.data) }
        m_unknown(out)
    }

    public func toString(): String {
        var i_tmp = StructPrinter()
        if (!p_name.isEmpty()) { i_tmp.append("name", p_name.get()) }
        return i_tmp.done().toString()
    }

    public func packi(out: BytesWriter) { match (out) { case i_tmp: SimpleWriter => pack(i_tmp) case _ => pack(out) } }
    public func unpacki(src: BytesReader) { match (src) { case i_stmp: SimpleReader => unpack(i_stmp) case _ => unpack(src) } }

    public static func empty() { HelloRequest() }
    public static func fromBytes(src: Collection<Byte>) { let i_tmp = HelloRequest(); i_tmp.unpack(src); i_tmp }
    public static func fromBytes(src: BytesReader) { let i_tmp = HelloRequest(); i_tmp.unpack(src); i_tmp }
}

public class HelloReply <: Message & TypedMessage<HelloReply> {
    private var p_message = Pb3String()

    public init() {
        m_innerInit()
    }

    public mut prop message: String { get() { p_message.get() } set(i_vtmp) { p_message.set(i_vtmp); markDirty() } }

    protected func m_size(): Int64 {
        var i_tmp = 0
        if (!p_message.isEmpty()) { i_tmp += 1 + binSize(p_message.data) }
        return i_tmp
    }

    protected func m_isEmpty(): Bool {
        p_message.isEmpty()
    }

    protected func m_clear(): Unit {
        p_message.clear()
    }

    public func copyFrom(src: HelloReply): HelloReply {
        p_message = src.p_message
        m_innerCopyFrom(src)
        return this
    }

    public func clone(): HelloReply {
        return HelloReply().copyFrom(this)
    }

    public func unpack<T>(src: T): Unit where T <: BytesReader {
        while (!src.isEmpty()) {
            let i_tmp = src.parseTag()
            match (i_tmp[0]) {
                case 1 => p_message.unpack(src)
                case _ => m_unknown(src, i_tmp)
            }
        }
        markDirty()
    }

    public func pack<T>(out: T): Unit where T <: BytesWriter {
        if (!p_message.isEmpty()) { out.append(10); out.packBin(p_message.data) }
        m_unknown(out)
    }

    public func toString(): String {
        var i_tmp = StructPrinter()
        if (!p_message.isEmpty()) { i_tmp.append("message", p_message.get()) }
        return i_tmp.done().toString()
    }

    public func packi(out: BytesWriter) { match (out) { case i_tmp: SimpleWriter => pack(i_tmp) case _ => pack(out) } }
    public func unpacki(src: BytesReader) { match (src) { case i_stmp: SimpleReader => unpack(i_stmp) case _ => unpack(src) } }

    public static func empty() { HelloReply() }
    public static func fromBytes(src: Collection<Byte>) { let i_tmp = HelloReply(); i_tmp.unpack(src); i_tmp }
    public static func fromBytes(src: BytesReader) { let i_tmp = HelloReply(); i_tmp.unpack(src); i_tmp }
}

//server 端
public abstract class GreeterServer <: Message {
    public func SayHello(hr: HelloRequest): (HelloReply, GrpcError)
    public func mustEmbedUnimplementedGreeterServer(): Unit

    protected func m_size(): Int64 { return 0 }
    protected func m_isEmpty(): Bool { return false }
    protected func m_clear(): Unit {}
    public func unpacki(_: BytesReader): Unit {}
    public func packi(_: BytesWriter): Unit {}
    public func toString(): String { return "" }
}

class UnimplementedGreeterServer <: GreeterServer {
    public func SayHello(_: HelloRequest): (HelloReply, GrpcError) {
        return (HelloReply(), GrpcError(Unimplemented, "method SayHello not implemented"))
    }
    public func mustEmbedUnimplementedGreeterServer() {}
}

interface UnsafeGreeterServer {
    func mustEmbedUnimplementedGreeterServer(): Unit
}

public func defaultAnyAndServerStreamToGrpcError(any: Any, ss: ServerStream): GrpcError {
    println("++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------0")
    println("++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------0")
    if (any is HelloRequest) {
        let hy: HelloRequest = (any as HelloRequest).getOrThrow()
        println("hy.name = ${hy.name}")
    } else if (any is HelloReply) {
        (any as HelloReply).getOrThrow()
        println("hy.message = hy.message")
    }

    let hr: HelloRequest = HelloRequest()
    for (i in 0..num) {
        hr.name = "ceshi-20221227-stream-" + i.toString()
        ss.sendMsg(hr)
    }

    var resp = HelloReply()
    for (_ in 0..num) {
        ss.recvMsg(resp)
        println("resp = ${resp}")
    }

    println("++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------1")
    println("++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------1")
    return NULL_ERR
}

var Greeter_ServiceDesc = ServiceDesc(
    serviceName: "helloworld.Greeter",
    handlerType: -1,
    streams: [StreamDesc(streamName: "SayHello", handler:  StreamHandler(defaultAnyAndServerStreamToGrpcError) )],
    metadata: "./helloworld.proto"
)

func registerGreeterServer(s: Server, srv: Message) {
    s.registerService(Greeter_ServiceDesc, srv)
}

执行结果如下：

ini 复制代码 
ss=127.0.0.1:46327
++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------0
++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------0
resp = {message: "World-0"}
resp = {message: "World-1"}
resp = {message: "World-2"}
resp = {message: "World-3"}
resp = {message: "World-4"}
++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------1
++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------1

DD一下： 欢迎大家关注公众号<程序猿百晓生>，可以了解到以下知识点。

erlang 复制代码 
`欢迎大家关注公众号<程序猿百晓生>，可以了解到以下知识点。`
1.OpenHarmony开发基础
2.OpenHarmony北向开发环境搭建
3.鸿蒙南向开发环境的搭建
4.鸿蒙生态应用开发白皮书V2.0 & V3.0
5.鸿蒙开发面试真题（含参考答案） 
6.TypeScript入门学习手册
7.OpenHarmony 经典面试题(含参考答案)
8.OpenHarmony设备开发入门【最新版】
9.沉浸式剖析OpenHarmony源代码
10.系统定制指南
11.【OpenHarmony】Uboot 驱动加载流程
12.OpenHarmony构建系统--GN与子系统、部件、模块详解
13.ohos开机init启动流程
14.鸿蒙版性能优化指南
.......

压缩功能示例

可以启用默认 gzip 算法压缩请求数据，该示例需要和 test/LLT/grpc/compressor/helloworld.pb.cj 一起编译

示例代码如下：

typescript 复制代码 
from std import socket.*
from rpc4cj import grpc.*
from rpc4cj import transport.*
from rpc4cj import exceptions.*
from rpc4cj import util.*
from std import sync.*
from std import time.*
from std import collection.*
from protobuf import protobuf.*

let strServer: String = "test pass"
class ServerTest <: GreeterServer {
    public func SayHello(hr: HelloRequest): (HelloReply, GrpcError) {
        let hy: HelloReply = HelloReply()
        hy.message = strServer
        return (hy, GrpcError())
    }
    public func mustEmbedUnimplementedGreeterServer() {}
}

var port: UInt16 = 50051
main() {

    let ss: SocketServer = SocketServer(TCP, "127.0.0.1", port)
    port = ss.port

    spawn{ =>
        let lis: GRPCServerSocket = GRPCServerSocket(GrpcSocketS(ss))
        let server: Server = Server()
        registerGreeterServer(server, ServerTest())
        server.serve(lis)
    }

    sleep(Duration.second)

    var req = HelloRequest()
    var resp = HelloReply()
    req.name = "World"

    var con = dial("127.0.0.1:${port}")//linux
    con.useCompressor()
    con.invoke("/helloworld.Greeter/SayHello",req,resp)
    println(resp)
    return 0
}

执行结果如下：

lua 复制代码 
--------------------------111
inhr.name = World
--------------------------111
{message: "test pass"}

拦截器功能示例

拦截器提供对请求的参数和获取到的请求的拦截以实现对数据的检查和控制，一元请求拦截器示例如下，该示例需要和 test/LLT/grpc/interceptor/helloworld.pb.cj 一起编译

示例代码如下：

swift 复制代码 
from std import socket.*
from rpc4cj import grpc.*
from rpc4cj import transport.*
from rpc4cj import exceptions.*
from rpc4cj import util.*
from std import collection.*
from std import sync.*
from std import time.*
from protobuf import protobuf.*

let strServer: String = "World0123456789"
class ServerTest <: GreeterServer {
    public func SayHello(_: HelloRequest): (HelloReply, GrpcError) {
        let hy: HelloReply = HelloReply()
        hy.message = strServer
        return (hy, GrpcError())
    }
    public func mustEmbedUnimplementedGreeterServer() {}
}

var port: UInt16 = 50052
main() {

    let ss: SocketServer = SocketServer(TCP, "127.0.0.1", port)
    port = ss.port

    spawn{ =>
        let lis: GRPCServerSocket = GRPCServerSocket(GrpcSocketS(ss))

        let usi: UnaryServerInterceptor = getUnaryServerInterceptor()
        let so1: ServerOption = unaryInterceptor(usi)

        var opts: Array<ServerOption> = Array<ServerOption>([so1])

        let server: Server = Server.newServer(opts)
        registerGreeterServer(server, ServerTest())

        server.serve(lis)
    }

    sleep(Duration.second)

    var req = HelloRequest()
    var resp = HelloReply()
    req.name = "World"

    var opts = ArrayList<DialOption>()
    opts.append(WithUnaryInterceptor(unary()))

    var con = dial("127.0.0.1:${port}",opts )//linux
    con.invoke("/helloworld.Greeter/SayHello",req,resp)
    return 0
}

func funcIns_1(_:Any,_:UnaryServerInfo, _:UnaryHandler): (Message, GrpcError) {
    println("测试服务端一元拦截器调用！")
    return (GrpcErrorMessage(), GrpcError())
}

public func getUnaryServerInterceptor(): UnaryServerInterceptor{
    let cal_Ins_UnaryServerInterceptor :UnaryServerInterceptor = UnaryServerInterceptor(funcIns_1)
    return cal_Ins_UnaryServerInterceptor
}

class unary <: UnaryInvoker {
    public func orderUnaryClientInterceptor(method: String, req: Message, _: Message): Unit {
        if (method == "/helloworld.Greeter/SayHello") {
            println(method)
            println("method ok")
        } else {
            throw Exception("error method")
        }
        var r = (req as HelloRequest).getOrThrow()
        if (r.name == "World") {
            println(r.name)
            println("request ok")  
        } else {
            throw Exception("error method")
        }
    }
}

执行结果如下：

sql 复制代码 
--------------------------000
inhr.name = World
--------------------------000
测试服务端一元拦截器调用！
/helloworld.Greeter/SayHello
method ok
World
request ok

DD一下： 欢迎大家关注公众号<程序猿百晓生>，可以了解到以下知识点。

erlang 复制代码 
`欢迎大家关注公众号<程序猿百晓生>，可以了解到以下知识点。`
1.OpenHarmony开发基础
2.OpenHarmony北向开发环境搭建
3.鸿蒙南向开发环境的搭建
4.鸿蒙生态应用开发白皮书V2.0 & V3.0
5.鸿蒙开发面试真题（含参考答案） 
6.TypeScript入门学习手册
7.OpenHarmony 经典面试题(含参考答案)
8.OpenHarmony设备开发入门【最新版】
9.沉浸式剖析OpenHarmony源代码
10.系统定制指南
11.【OpenHarmony】Uboot 驱动加载流程
12.OpenHarmony构建系统--GN与子系统、部件、模块详解
13.ohos开机init启动流程
14.鸿蒙版性能优化指南
.......

域名解析功能示例

客户端可以启用内置域名解析功能，提供对服务器域名的解析并连接，示例如下:

示例代码如下：

javascript 复制代码 
from std import socket.*
from rpc4cj import grpc.*
from rpc4cj import transport.*
from rpc4cj import exceptions.*
from rpc4cj import util.*
from std import collection.*
from std import time.*
from std import sync.*
from rpc4cj import resolver.*
from rpc4cj import resolver.dns.*

var port: UInt16 = 0
main() {
    let ss: SocketServer = SocketServer(TCP, "127.0.0.1", port)
    port = ss.port
    spawn{ =>
        let lis: GRPCServerSocket = GRPCServerSocket(GrpcSocketS(ss))
        let server: Server = Server()
        server.serve(lis)
    }
    sleep(Duration.second)
    try{
        dial("passthrough:///127.0.0.1:${port}")//reslove localhost with
    } catch (e: Exception) {
          println("reslove failed")
          return 1
    }
    println("reslove pass")
    return 0
}

执行结果如下：

python 复制代码 
reslove pass

TLS 安全连接功能示例

TLS 是一种网络传输层安全协议，可以为 rpc4cj 客户端应用程序和服务器端应用程序之间提供安全连接，示例如下: 注： 示例中使用到的密钥仅供参考，用户需要自行准备。

示例代码如下：

scss 复制代码 
// DEPENDENCE: ./example-cert.pem
// DEPENDENCE: ./example-key.pem
// EXEC: cjc %import-path %L %l %f %project-path %project-L/protobuf  -l protobuf-cj
// EXEC: ./main

from std import socket.*
from std import io.*
from std import sync.*
from std import time.*
from std import collection.*
from net import tls.*

from rpc4cj import grpc.*
from rpc4cj import transport.*
from rpc4cj import exceptions.*
from rpc4cj import util.*

from protobuf import protobuf.*

class ServerTest <: GreeterServer {
	// SayHello implements helloworld.GreeterServer
	public func SayHello(hr: HelloRequest): (HelloReply, GrpcError) {
		let hy: HelloReply = HelloReply()
		hy.message = "测试server端-20230224......哈哈哈哈，测试通了！"
		println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~0")
		println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~1")
		println("测试server端-20220919")
		println("received: hr.name = ${hr.name}")
		println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~2")
		println("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~3")
		return (hy, GrpcError())
	}
	public func mustEmbedUnimplementedGreeterServer() {}
}

var port: UInt16 = 50051

main(): Int64 {

    var cfgs = TlsServerConfig("./example-cert.pem","./example-key.pem")
    cfgs.alpnList = ["h2", "http/1.1"]
    let ss: TlsSocketServer = TlsSocketServer(TCP, "127.0.0.1", port, cfgs)
    port = ss.port

    spawn{ =>
        println("ss=${ss.address}")//127.0.0.1:50051/hello
        let lis: GRPCServerSocket = GRPCServerSocket(GrpcTlsS(ss))

        let server: Server = Server()
        registerGreeterServer(server, ServerTest())
        server.serve(lis)
    }

    sleep(Duration.second)

    var req = HelloRequest()
    var resp = HelloReply()
    req.name = "World"

    var cfg = TlsClientConfig("./example-cert.pem")
    cfg.alpnList = ["h2", "http/1.1"]
    cfg.verifyMode = VerifyNone

    try {
        var con = dial("127.0.0.1:${port}", cfg: cfg)//linux
        con.invoke("/helloworld.Greeter/SayHello", req, resp)
    } catch(e: Exception) {
        e.printStackTrace()
        return -1
    }

    println("result: ${resp}")
    println("result: {\"message\": \"Hello World\"}")

    return 0
}

public class HelloRequest <: Message & TypedMessage<HelloRequest> {
    private var p_name = Pb3String()

    public init() {
        m_innerInit()
    }

    public mut prop name: String { get() { p_name.get() } set(i_vtmp) { p_name.set(i_vtmp); markDirty() } }

    protected func m_size(): Int64 {
        var i_tmp = 0
        if (!p_name.isEmpty()) { i_tmp += 1 + binSize(p_name.data) }
        return i_tmp
    }

    protected func m_isEmpty(): Bool {
        p_name.isEmpty()
    }

    protected func m_clear(): Unit {
        p_name.clear()
    }

    public func copyFrom(src: HelloRequest): HelloRequest {
        p_name = src.p_name
        m_innerCopyFrom(src)
        return this
    }

    public func clone(): HelloRequest {
        return HelloRequest().copyFrom(this)
    }

    public func unpack<T>(src: T): Unit where T <: BytesReader {
        while (!src.isEmpty()) {
            let i_tmp = src.parseTag()
            match (i_tmp[0]) {
                case 1 => p_name.unpack(src)
                case _ => m_unknown(src, i_tmp)
            }
        }
        markDirty()
    }

    public func pack<T>(out: T): Unit where T <: BytesWriter {
        if (!p_name.isEmpty()) { out.append(10); out.packBin(p_name.data) }
        m_unknown(out)
    }

    public func toString(): String {
        var i_tmp = StructPrinter()
        if (!p_name.isEmpty()) { i_tmp.append("name", p_name.get()) }
        return i_tmp.done().toString()
    }

    public func packi(out: BytesWriter) { match (out) { case i_tmp: SimpleWriter => pack(i_tmp) case _ => pack(out) } }
    public func unpacki(src: BytesReader) { match (src) { case i_stmp: SimpleReader => unpack(i_stmp) case _ => unpack(src) } }

    public static func empty() { HelloRequest() }
    public static func fromBytes(src: Collection<Byte>) { let i_tmp = HelloRequest(); i_tmp.unpack(src); i_tmp }
    public static func fromBytes(src: BytesReader) { let i_tmp = HelloRequest(); i_tmp.unpack(src); i_tmp }
}

public class HelloReply <: Message & TypedMessage<HelloReply> {
    private var p_message = Pb3String()

    public init() {
        m_innerInit()
    }

    public mut prop message: String { get() { p_message.get() } set(i_vtmp) { p_message.set(i_vtmp); markDirty() } }

    protected func m_size(): Int64 {
        var i_tmp = 0
        if (!p_message.isEmpty()) { i_tmp += 1 + binSize(p_message.data) }
        return i_tmp
    }

    protected func m_isEmpty(): Bool {
        p_message.isEmpty()
    }

    protected func m_clear(): Unit {
        p_message.clear()
    }

    public func copyFrom(src: HelloReply): HelloReply {
        p_message = src.p_message
        m_innerCopyFrom(src)
        return this
    }

    public func clone(): HelloReply {
        return HelloReply().copyFrom(this)
    }

    public func unpack<T>(src: T): Unit where T <: BytesReader {
        while (!src.isEmpty()) {
            let i_tmp = src.parseTag()
            match (i_tmp[0]) {
                case 1 => p_message.unpack(src)
                case _ => m_unknown(src, i_tmp)
            }
        }
        markDirty()
    }

    public func pack<T>(out: T): Unit where T <: BytesWriter {
        if (!p_message.isEmpty()) { out.append(10); out.packBin(p_message.data) }
        m_unknown(out)
    }

    public func toString(): String {
        var i_tmp = StructPrinter()
        if (!p_message.isEmpty()) { i_tmp.append("message", p_message.get()) }
        return i_tmp.done().toString()
    }

    public func packi(out: BytesWriter) { match (out) { case i_tmp: SimpleWriter => pack(i_tmp) case _ => pack(out) } }
    public func unpacki(src: BytesReader) { match (src) { case i_stmp: SimpleReader => unpack(i_stmp) case _ => unpack(src) } }

    public static func empty() { HelloReply() }
    public static func fromBytes(src: Collection<Byte>) { let i_tmp = HelloReply(); i_tmp.unpack(src); i_tmp }
    public static func fromBytes(src: BytesReader) { let i_tmp = HelloReply(); i_tmp.unpack(src); i_tmp }
}

//server端
public abstract class GreeterServer <: Message {
	public func SayHello(hr: HelloRequest): (HelloReply, GrpcError)
	public func mustEmbedUnimplementedGreeterServer(): Unit

    protected func m_size(): Int64 { return 0 }
    protected func m_isEmpty(): Bool { return false }
    protected func m_clear(): Unit {}
    public func unpacki(_: BytesReader): Unit {}
    public func packi(_: BytesWriter): Unit {}
    public func toString(): String { return "" }

}

class UnimplementedGreeterServer <: GreeterServer {
	public func SayHello(_: HelloRequest): (HelloReply, GrpcError) {
		return (HelloReply(), GrpcError(Unimplemented, "method SayHello not implemented"))
	}
	//public func clone() { this }
	public func mustEmbedUnimplementedGreeterServer() {}
}

interface UnsafeGreeterServer {
	 func mustEmbedUnimplementedGreeterServer(): Unit
}

/*
public class DEFAULT_MESSAGELITE2 <: Message {
    public func clone() { this }
}
*/

func Greeter_SayHello_Handler(srv: Message, dec: (Message) -> GrpcError, interceptor: ?UnaryServerInterceptor): (Message, GrpcError) {
	let inhr: HelloRequest = HelloRequest()

	var err: GrpcError = dec(inhr)
	if (!err.isNull()) {
		return (inhr, err)
	}
	match(interceptor){
		case Some(v) =>
				let info: UnaryServerInfo = UnaryServerInfo(
					server:     srv,
					fullMethod: "/helloworld.Greeter/SayHello"
				)
				println("--------------------------000")
				println("inhr.name = ${inhr.name}")
				println("--------------------------000")
				inhr.name = "dec(inhr)解析到的HelloRequest是空的？？？-----000"
				func handlercs(req: Any): (Any, GrpcError) {
					return (srv as (GreeterServer)).getOrThrow().SayHello((req as HelloRequest).getOrThrow())
					//return srv.SayHello((req as HelloRequest).getOrThrow())
				}
				return v.f(inhr, info, UnaryHandler(handlercs))
		case None =>
				println("--------------------------111")
				println("inhr.name = ${inhr.name}")
				println("--------------------------111")
				//inhr.name = "dec(inhr)解析到的HelloRequest是空的？？？-----111"
				return (srv as (GreeterServer)).getOrThrow().SayHello(inhr)
				//return srv.SayHello(inhr)
	}
}

public func defaultAnyAndServerStreamToGrpcError(any: Any, ss: ServerStream): GrpcError {
    println("++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------0")
	println("++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------0")
    if (any is HelloRequest) {
        let hy: HelloRequest = (any as HelloRequest).getOrThrow()
        println("hy.name = ${hy.name}")
    } else if (any is HelloReply) {
		let hy: HelloReply = (any as HelloReply).getOrThrow()
		println("hy.message = ${hy.message}")
	}

	let hr: HelloRequest = HelloRequest()
	hr.name = "测试processStreamingRPC--20221008！仓颉666"
	ss.sendMsg(hr)

	println("++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------1")
	println("++++++++++++++++++++++++++start-------------------defaultAnyAndServerStreamToGrpcError-------1")
	return NULL_ERR
}

var Greeter_ServiceDesc = ServiceDesc(
	serviceName: "helloworld.Greeter",
	handlerType: -1,
	methods: [MethodDesc(methodName: "SayHello", handler:  Greeter_SayHello_Handler)],
	//streams: [StreamDesc(streamName: "SayHello", handler:  StreamHandler(defaultAnyAndServerStreamToGrpcError) )],
	metadata: "./helloworld.proto"
)

func registerGreeterServer(s: Server, srv: Message) {
	s.registerService(Greeter_ServiceDesc, srv)
}

执行结果如下：

sql 复制代码 
ss=127.0.0.1:50051
--------------------------111
inhr.name = World
--------------------------111
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~0
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~1
测试server端-20220919
received: hr.name = World
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~2
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~3
result: {message: "测试server端-20230224......哈哈哈哈，测试通了！"}
result: {"message": "Hello World"}
相关推荐
别说我什么都不会3 小时前
【仓颉三方库】 网络组件——upload4cj
harmonyos
simple_lau5 小时前
鸿蒙应用如何配置多环境
harmonyos
simple_lau5 小时前
如何从零到一开始搭建鸿蒙项目
harmonyos
HZW89706 小时前
鸿蒙应用开发—数据持久化之SQLite
android·前端·harmonyos
白羊@7 小时前
鸿蒙案例---生肖抽卡
前端·javascript·华为·harmonyos
幽蓝计划8 小时前
HarmonyOS NEXT开发教程：全局悬浮窗
华为·harmonyos
我爱学习_zwj8 小时前
Node.js入门
harmonyos
H.ZWei8 小时前
鸿蒙应用开发—鸿蒙app一键安装脚本
python·华为·harmonyos·安装·hdc
马剑威（威哥爱编程）9 小时前
鸿蒙动画与交互设计：ArkUI 3D变换与手势事件详解
华为·交互·harmonyos·arkts
热门推荐
01我决定放弃搞 Java 了02RAG 实践- Ollama+RagFlow 部署本地知识库03DeepSeek各版本说明与优缺点分析04Scipy||第三章 线性代数 (scipy.linalg)05DeepSeek RAGFlow构建本地知识库系统06如何在WPS和Word/Excel中直接使用DeepSeek功能07C#/.NET/.NET Core技术前沿周刊 | 第 34 期（2025年4.7-4.13）08汽车上的各种质量：整备质量、总质量、装载质量、簧上质量、簧下质量09本地化部署AI知识库：基于Ollama+DeepSeek+AnythingLLM保姆级教程10ZNS SSD垃圾回收优化方案解读-1