GRPC的基础使用方法
grpc 是 google 开源的高性能、通用的 rpc 框架，它采用了基于 http/2 协议的二进制传输协议，支持多种语言，包括 rust。rust 语言 grpc 模块是一个用于 rust 语言的 grpc 客户端和服务器实现，它提供了一个简单易用的 api，可以方便地创建和使用 grpc 服务。
基础用法创建 grpc 服务器在 rust 语言 grpc 模块中，可以使用serverbuilder结构体来创建 grpc 服务器。下面是一个简单的示例：
use grpc::{server, serverbuilder};fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::greeter_server::greeterserver::new_service_def(greeterimpl {})); let server = server.build().unwrap(); server.start(); server.wait();}struct greeterimpl {}impl proto::greeter_server::greeter for greeterimpl { fn say_hello(&self, _m: grpc::requestoptions, req: proto::hellorequest) - > grpc::singleresponse { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); grpc::singleresponse::completed(r) }}这个示例中，我们创建了一个serverbuilder对象，并通过http字段设置了服务器的端口号。然后我们使用add_service方法将我们实现的greeter服务添加到服务器中。最后，我们通过build方法构建了服务器，并通过start方法启动了服务器。服务器启动后，我们通过wait方法等待客户端连接。
创建 grpc 客户端在 rust 语言 grpc 模块中，可以使用client结构体来创建 grpc 客户端。下面是一个简单的示例：
use grpc::{channelbuilder, client};fn main() { let ch = channelbuilder::new_plain(); let client = client::new(ch); let mut req = proto::hellorequest::new(); req.set_name(world.to_string()); let resp = client.say_hello(grpc::requestoptions::new(), req); println!({}, resp.wait().unwrap().get_message());}这个示例中，我们创建了一个channelbuilder对象，并使用client结构体创建了一个 grpc 客户端。然后我们创建了一个hellorequest对象，并设置了它的name字段。最后，我们使用say_hello方法向服务器发送请求，并通过wait方法等待响应。响应对象是一个singleresponse对象，我们通过unwrap方法获取了它的值，并打印了它的message字段。
使用流式 rpc在 rust 语言 grpc 模块中，可以使用流式 rpc 来传输流数据。下面是一个简单的示例：
use grpc::{client, clientstreamingsink, server, serverbuilder, serverstreamingsink, writeflags};fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::streaming::create_greeter_server(greeterimpl {})); let server = server.build().unwrap(); server.start(); let ch = channelbuilder::new_plain(); let client = client::new(ch); let reqs = vec![ proto::hellorequest::new(), proto::hellorequest::new(), proto::hellorequest::new(), ]; let (mut tx, rx) = client.say_hello_stream(grpc::requestoptions::new()).unwrap(); for req in reqs { tx = tx.send((req, writeflags::default())).unwrap(); } tx.close().unwrap(); for resp in rx.wait() { println!({}, resp.unwrap().get_message()); }}struct greeterimpl {}impl proto::streaming::greeter for greeterimpl { fn say_hello_stream(&self, _m: grpc::requestoptions, _stream: grpc::streamingrequest) - > grpc::streamingresponse { let (tx, rx) = grpc::channel::mpsc::channel(0); std::thread::spawn(move || { for req in _stream.into_iter() { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); tx.send((r, writeflags::default())).unwrap(); } tx.close().unwrap(); }); grpc::streamingresponse::new(rx) }}这个示例中，我们创建了一个greeter服务，并实现了一个say_hello_stream方法，该方法接收一个streamingrequest对象，并返回一个streamingresponse对象。在该方法中，我们使用mpsc::channel方法创建了一个通道，用于传输流数据。然后我们使用std::thread::spawn方法创建了一个线程，该线程会将接收到的请求转换成响应，并通过通道发送给客户端。最后，我们使用streamingresponse::new方法将通道包装成一个streamingresponse对象，并将其返回给客户端。
在客户端中，我们创建了一个say_hello_stream方法，并使用send方法向服务器发送请求。然后我们通过wait方法等待响应，并打印了响应的message字段。
使用双向流式 rpc在 rust 语言 grpc 模块中，可以使用双向流式 rpc 来传输双向流数据。下面是一个简单的示例：
use grpc::{client, clientstreamingsink, server, serverbuilder, serverstreamingsink, streamingsink, writeflags};fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::streaming::create_greeter_server(greeterimpl {})); let server = server.build().unwrap(); server.start(); let ch = channelbuilder::new_plain(); let client = client::new(ch); let (mut tx, rx) = client.say_hello_bidi(grpc::requestoptions::new()).unwrap(); let reqs = vec![ proto::hellorequest::new(), proto::hellorequest::new(), proto::hellorequest::new(), ]; std::thread::spawn(move || { for req in reqs { tx = tx.send((req, writeflags::default())).unwrap(); let resp = rx.into_future().wait().unwrap().0; println!({}, resp.unwrap().get_message()); } tx.close().unwrap(); });}struct greeterimpl {}impl proto::streaming::greeter for greeterimpl { fn say_hello_bidi(&self, _m: grpc::requestoptions, stream: grpc::streamingrequest) - > grpc::streamingresponse { let (tx, rx) = grpc::channel::mpsc::channel(0); std::thread::spawn(move || { for req in stream.into_iter() { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); tx.send((r, writeflags::default())).unwrap(); } tx.close().unwrap(); }); grpc::streamingresponse::new(rx) }}这个示例中，我们创建了一个greeter服务，并实现了一个say_hello_bidi方法，该方法接收一个streamingrequest对象，并返回一个streamingresponse对象。在该方法中，我们使用mpsc::channel方法创建了一个通道，用于传输流数据。然后我们使用std::thread::spawn方法创建了一个线程，该线程会将接收到的请求转换成响应，并通过通道发送给客户端。最后，我们使用streamingresponse::new方法将通道包装成一个streamingresponse对象，并将其返回给客户端。
在客户端中，我们使用say_hello_bidi方法向服务器发送请求，并通过into_future方法获取响应。然后我们通过println方法打印了响应的message字段。
进阶用法使用 tokio在 rust 语言 grpc 模块中，可以使用 tokio 来实现异步 rpc。下面是一个简单的示例：
use grpc::{client, clientstreamingsink, server, serverbuilder, serverstreamingsink, streamingsink, writeflags};#[tokio::main]async fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::greeter_server::greeterserver::new_service_def(greeterimpl {})); let server = server.build().unwrap(); server.start(); let ch = channelbuilder::new_plain(); let client = client::new(ch); let mut req = proto::hellorequest::new(); req.set_name(world.to_string()); let resp = client.say_hello_async(grpc::requestoptions::new(), req).await.unwrap(); println!({}, resp.get_message());}struct greeterimpl {}impl proto::greeter_server::greeter for greeterimpl { fn say_hello(&self, _m: grpc::requestoptions, req: proto::hellorequest) - > grpc::singleresponse { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); grpc::singleresponse::completed(r) }}这个示例中，我们使用tokio::main宏来创建异步运行时。在服务器和客户端中，我们使用async关键字来定义异步函数。在客户端中，我们使用await关键字来等待异步响应。
tokio 使用流式 rpc下面是一个使用 tokio 和流式 rpc 的示例：
use grpc::{client, clientstreamingsink, server, serverbuilder, serverstreamingsink, streamingsink, writeflags};use tokio::sync::mpsc;#[tokio::main]async fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::streaming::create_greeter_server(greeterimpl {})); let server = server.build().unwrap(); server.start(); let ch = channelbuilder::new_plain(); let client = client::new(ch); let (mut tx, rx) = mpsc::channel(10); let mut stream = client.say_hello_streaming(grpc::requestoptions::new()).unwrap(); tokio::spawn(async move { while let some(req) = rx.recv().await { stream.send((req, writeflags::default())).unwrap(); } stream.close().unwrap(); }); let reqs = vec![ proto::hellorequest::new(), proto::hellorequest::new(), proto::hellorequest::new(), ]; for req in reqs { tx.send(req).await.unwrap(); } for resp in stream.into_stream().await { println!({}, resp.unwrap().get_message()); }}struct greeterimpl {}impl proto::streaming::greeter for greeterimpl { fn say_hello_streaming(&self, _m: grpc::requestoptions, _stream: grpc::streamingrequest) - > grpc::streamingresponse { let (tx, rx) = grpc::channel::mpsc::channel(0); tokio::spawn(async move { for req in _stream.into_async_iter().await { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); tx.send((r, writeflags::default())).unwrap(); } tx.close().unwrap(); }); grpc::streamingresponse::new(rx) }}这个示例中，我们使用tokio::sync::mpsc库来创建一个通道，用于传输流数据。在客户端中，我们使用say_hello_streaming方法向服务器发送请求，并将请求通过通道发送给异步任务。在异步任务中，我们使用into_async_iter方法将请求流转换成异步迭代器，并将响应通过通道发送给客户端。在客户端中，我们使用into_stream方法将响应流转换成异步流，并等待响应。
使用 tls 加密在 rust 语言 grpc 模块中，可以使用 tls 加密来保护通信安全。下面是一个简单的示例：
use grpc::{channelbuilder, client};use rustls::{certificate, privatekey, serverconfig};use std::fs::file;use std::io::bufreader;fn main() { let mut config = serverconfig::new(rustls::noclientauth::new()); let cert_file = &mut bufreader::new(file::open(server.crt).unwrap()); let key_file = &mut bufreader::new(file::open(server.key).unwrap()); let cert_chain = rustls::internal::pemfile::certs(cert_file).unwrap(); let mut keys = rustls::internal::pemfile::rsa_private_keys(key_file).unwrap(); config.set_single_cert(cert_chain, keys.remove(0)).unwrap(); let mut server = grpc_tls::serverbuilder::new_plain(); server.http.set_port(50051); server.http.set_tls(config); server.add_service(proto::greeter_server::greeterserver::new_service_def(greeterimpl {})); let server = server.build().unwrap(); server.start(); let mut config = rustls::clientconfig::new(); let cert_file = &mut bufreader::new(file::open(client.crt).unwrap()); let key_file = &mut bufreader::new(file::open(client.key).unwrap()); let cert_chain = rustls::internal::pemfile::certs(cert_file).unwrap(); let mut keys = rustls::internal::pemfile::rsa_private_keys(key_file).unwrap(); config.set_single_client_cert(cert_chain, keys.remove(0)); let ch = channelbuilder::new_tls().rustls_config(config); let client = client::new(ch); let mut req = proto::hellorequest::new(); req.set_name(world.to_string()); let resp = client.say_hello(grpc::requestoptions::new(), req); println!({}, resp.wait().unwrap().get_message());}struct greeterimpl {}impl proto::greeter_server::greeter for greeterimpl { fn say_hello(&self, _m: grpc::requestoptions, req: proto::hellorequest) - > grpc::singleresponse { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); grpc::singleresponse::completed(r) }}这个示例中，我们使用rustls库来创建 tls 配置，并使用grpc_tls::serverbuilder和channelbuilder::new_tls方法来创建带有 tls 加密的服务器和客户端。在服务器中，我们使用set_single_cert方法来设置服务器证书和私钥。在客户端中，我们使用set_single_client_cert方法来设置客户端证书和私钥。
总结本教程介绍了 grpc 的基础使用方法，并针对 tokio 结合 grpc 的进阶使用进入入门级的探讨。希望能帮助同学们掌握 rust 语言 grpc 的应用。
村田量产面向汽车的1.0μF 0.18mm超薄LW逆转低ESL片状多层陶瓷电容器
如何在芯片制造中更有效地使用数据
这家公司已开始布局第四代半导体材料
WiFi技术的原理、特点和标准有哪些
人工智能是实现国产芯片换道超车的机会
GRPC的基础使用方法
浅析PCIe Gen 5 switch芯片内置的SerialTek PCIe抓包分析功能
比亚迪新能源汽车部分存在被低估的可能性
苹果为什么对正火热的区块链不感兴趣
关于固德威智慧能源管理系统的性能分析和应用
热电偶测温电路原理图
基于区块链技术的全球性粉丝生态平台FANS介绍
如何构造系统的三总线
印制电路板（PCB）布线在高速电路中具有关键的作用
微软提出了计划要支持Microsoft Store的应用商店原则的十诫
2019第一季全球前十大IC设计厂商排名出炉，多数企业营收衰退
HarmonyOS应用开发案例 剪贴板功能实现
Xilinx SDSoC开发环境面向公众开放
JESD204协议标准的分类和区别
PPLive成Adworld 2010最大赢家 ‘百事群音’
基础用法创建 grpc 服务器在 rust 语言 grpc 模块中，可以使用serverbuilder结构体来创建 grpc 服务器。下面是一个简单的示例：
use grpc::{server, serverbuilder};fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::greeter_server::greeterserver::new_service_def(greeterimpl {})); let server = server.build().unwrap(); server.start(); server.wait();}struct greeterimpl {}impl proto::greeter_server::greeter for greeterimpl { fn say_hello(&self, _m: grpc::requestoptions, req: proto::hellorequest) - > grpc::singleresponse { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); grpc::singleresponse::completed(r) }}这个示例中，我们创建了一个serverbuilder对象，并通过http字段设置了服务器的端口号。然后我们使用add_service方法将我们实现的greeter服务添加到服务器中。最后，我们通过build方法构建了服务器，并通过start方法启动了服务器。服务器启动后，我们通过wait方法等待客户端连接。
创建 grpc 客户端在 rust 语言 grpc 模块中，可以使用client结构体来创建 grpc 客户端。下面是一个简单的示例：
use grpc::{channelbuilder, client};fn main() { let ch = channelbuilder::new_plain(); let client = client::new(ch); let mut req = proto::hellorequest::new(); req.set_name(world.to_string()); let resp = client.say_hello(grpc::requestoptions::new(), req); println!({}, resp.wait().unwrap().get_message());}这个示例中，我们创建了一个channelbuilder对象，并使用client结构体创建了一个 grpc 客户端。然后我们创建了一个hellorequest对象，并设置了它的name字段。最后，我们使用say_hello方法向服务器发送请求，并通过wait方法等待响应。响应对象是一个singleresponse对象，我们通过unwrap方法获取了它的值，并打印了它的message字段。
使用流式 rpc在 rust 语言 grpc 模块中，可以使用流式 rpc 来传输流数据。下面是一个简单的示例：
use grpc::{client, clientstreamingsink, server, serverbuilder, serverstreamingsink, writeflags};fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::streaming::create_greeter_server(greeterimpl {})); let server = server.build().unwrap(); server.start(); let ch = channelbuilder::new_plain(); let client = client::new(ch); let reqs = vec![ proto::hellorequest::new(), proto::hellorequest::new(), proto::hellorequest::new(), ]; let (mut tx, rx) = client.say_hello_stream(grpc::requestoptions::new()).unwrap(); for req in reqs { tx = tx.send((req, writeflags::default())).unwrap(); } tx.close().unwrap(); for resp in rx.wait() { println!({}, resp.unwrap().get_message()); }}struct greeterimpl {}impl proto::streaming::greeter for greeterimpl { fn say_hello_stream(&self, _m: grpc::requestoptions, _stream: grpc::streamingrequest) - > grpc::streamingresponse { let (tx, rx) = grpc::channel::mpsc::channel(0); std::thread::spawn(move || { for req in _stream.into_iter() { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); tx.send((r, writeflags::default())).unwrap(); } tx.close().unwrap(); }); grpc::streamingresponse::new(rx) }}这个示例中，我们创建了一个greeter服务，并实现了一个say_hello_stream方法，该方法接收一个streamingrequest对象，并返回一个streamingresponse对象。在该方法中，我们使用mpsc::channel方法创建了一个通道，用于传输流数据。然后我们使用std::thread::spawn方法创建了一个线程，该线程会将接收到的请求转换成响应，并通过通道发送给客户端。最后，我们使用streamingresponse::new方法将通道包装成一个streamingresponse对象，并将其返回给客户端。
在客户端中，我们创建了一个say_hello_stream方法，并使用send方法向服务器发送请求。然后我们通过wait方法等待响应，并打印了响应的message字段。
使用双向流式 rpc在 rust 语言 grpc 模块中，可以使用双向流式 rpc 来传输双向流数据。下面是一个简单的示例：
use grpc::{client, clientstreamingsink, server, serverbuilder, serverstreamingsink, streamingsink, writeflags};fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::streaming::create_greeter_server(greeterimpl {})); let server = server.build().unwrap(); server.start(); let ch = channelbuilder::new_plain(); let client = client::new(ch); let (mut tx, rx) = client.say_hello_bidi(grpc::requestoptions::new()).unwrap(); let reqs = vec![ proto::hellorequest::new(), proto::hellorequest::new(), proto::hellorequest::new(), ]; std::thread::spawn(move || { for req in reqs { tx = tx.send((req, writeflags::default())).unwrap(); let resp = rx.into_future().wait().unwrap().0; println!({}, resp.unwrap().get_message()); } tx.close().unwrap(); });}struct greeterimpl {}impl proto::streaming::greeter for greeterimpl { fn say_hello_bidi(&self, _m: grpc::requestoptions, stream: grpc::streamingrequest) - > grpc::streamingresponse { let (tx, rx) = grpc::channel::mpsc::channel(0); std::thread::spawn(move || { for req in stream.into_iter() { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); tx.send((r, writeflags::default())).unwrap(); } tx.close().unwrap(); }); grpc::streamingresponse::new(rx) }}这个示例中，我们创建了一个greeter服务，并实现了一个say_hello_bidi方法，该方法接收一个streamingrequest对象，并返回一个streamingresponse对象。在该方法中，我们使用mpsc::channel方法创建了一个通道，用于传输流数据。然后我们使用std::thread::spawn方法创建了一个线程，该线程会将接收到的请求转换成响应，并通过通道发送给客户端。最后，我们使用streamingresponse::new方法将通道包装成一个streamingresponse对象，并将其返回给客户端。
在客户端中，我们使用say_hello_bidi方法向服务器发送请求，并通过into_future方法获取响应。然后我们通过println方法打印了响应的message字段。
进阶用法使用 tokio在 rust 语言 grpc 模块中，可以使用 tokio 来实现异步 rpc。下面是一个简单的示例：
use grpc::{client, clientstreamingsink, server, serverbuilder, serverstreamingsink, streamingsink, writeflags};#[tokio::main]async fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::greeter_server::greeterserver::new_service_def(greeterimpl {})); let server = server.build().unwrap(); server.start(); let ch = channelbuilder::new_plain(); let client = client::new(ch); let mut req = proto::hellorequest::new(); req.set_name(world.to_string()); let resp = client.say_hello_async(grpc::requestoptions::new(), req).await.unwrap(); println!({}, resp.get_message());}struct greeterimpl {}impl proto::greeter_server::greeter for greeterimpl { fn say_hello(&self, _m: grpc::requestoptions, req: proto::hellorequest) - > grpc::singleresponse { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); grpc::singleresponse::completed(r) }}这个示例中，我们使用tokio::main宏来创建异步运行时。在服务器和客户端中，我们使用async关键字来定义异步函数。在客户端中，我们使用await关键字来等待异步响应。
tokio 使用流式 rpc下面是一个使用 tokio 和流式 rpc 的示例：
use grpc::{client, clientstreamingsink, server, serverbuilder, serverstreamingsink, streamingsink, writeflags};use tokio::sync::mpsc;#[tokio::main]async fn main() { let mut server = serverbuilder::new_plain(); server.http.set_port(50051); server.add_service(proto::streaming::create_greeter_server(greeterimpl {})); let server = server.build().unwrap(); server.start(); let ch = channelbuilder::new_plain(); let client = client::new(ch); let (mut tx, rx) = mpsc::channel(10); let mut stream = client.say_hello_streaming(grpc::requestoptions::new()).unwrap(); tokio::spawn(async move { while let some(req) = rx.recv().await { stream.send((req, writeflags::default())).unwrap(); } stream.close().unwrap(); }); let reqs = vec![ proto::hellorequest::new(), proto::hellorequest::new(), proto::hellorequest::new(), ]; for req in reqs { tx.send(req).await.unwrap(); } for resp in stream.into_stream().await { println!({}, resp.unwrap().get_message()); }}struct greeterimpl {}impl proto::streaming::greeter for greeterimpl { fn say_hello_streaming(&self, _m: grpc::requestoptions, _stream: grpc::streamingrequest) - > grpc::streamingresponse { let (tx, rx) = grpc::channel::mpsc::channel(0); tokio::spawn(async move { for req in _stream.into_async_iter().await { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); tx.send((r, writeflags::default())).unwrap(); } tx.close().unwrap(); }); grpc::streamingresponse::new(rx) }}这个示例中，我们使用tokio::sync::mpsc库来创建一个通道，用于传输流数据。在客户端中，我们使用say_hello_streaming方法向服务器发送请求，并将请求通过通道发送给异步任务。在异步任务中，我们使用into_async_iter方法将请求流转换成异步迭代器，并将响应通过通道发送给客户端。在客户端中，我们使用into_stream方法将响应流转换成异步流，并等待响应。
使用 tls 加密在 rust 语言 grpc 模块中，可以使用 tls 加密来保护通信安全。下面是一个简单的示例：
use grpc::{channelbuilder, client};use rustls::{certificate, privatekey, serverconfig};use std::fs::file;use std::io::bufreader;fn main() { let mut config = serverconfig::new(rustls::noclientauth::new()); let cert_file = &mut bufreader::new(file::open(server.crt).unwrap()); let key_file = &mut bufreader::new(file::open(server.key).unwrap()); let cert_chain = rustls::internal::pemfile::certs(cert_file).unwrap(); let mut keys = rustls::internal::pemfile::rsa_private_keys(key_file).unwrap(); config.set_single_cert(cert_chain, keys.remove(0)).unwrap(); let mut server = grpc_tls::serverbuilder::new_plain(); server.http.set_port(50051); server.http.set_tls(config); server.add_service(proto::greeter_server::greeterserver::new_service_def(greeterimpl {})); let server = server.build().unwrap(); server.start(); let mut config = rustls::clientconfig::new(); let cert_file = &mut bufreader::new(file::open(client.crt).unwrap()); let key_file = &mut bufreader::new(file::open(client.key).unwrap()); let cert_chain = rustls::internal::pemfile::certs(cert_file).unwrap(); let mut keys = rustls::internal::pemfile::rsa_private_keys(key_file).unwrap(); config.set_single_client_cert(cert_chain, keys.remove(0)); let ch = channelbuilder::new_tls().rustls_config(config); let client = client::new(ch); let mut req = proto::hellorequest::new(); req.set_name(world.to_string()); let resp = client.say_hello(grpc::requestoptions::new(), req); println!({}, resp.wait().unwrap().get_message());}struct greeterimpl {}impl proto::greeter_server::greeter for greeterimpl { fn say_hello(&self, _m: grpc::requestoptions, req: proto::hellorequest) - > grpc::singleresponse { let mut r = proto::helloreply::new(); r.set_message(format!(hello, {}!, req.get_name())); grpc::singleresponse::completed(r) }}这个示例中，我们使用rustls库来创建 tls 配置，并使用grpc_tls::serverbuilder和channelbuilder::new_tls方法来创建带有 tls 加密的服务器和客户端。在服务器中，我们使用set_single_cert方法来设置服务器证书和私钥。在客户端中，我们使用set_single_client_cert方法来设置客户端证书和私钥。
总结本教程介绍了 grpc 的基础使用方法，并针对 tokio 结合 grpc 的进阶使用进入入门级的探讨。希望能帮助同学们掌握 rust 语言 grpc 的应用。
村田量产面向汽车的1.0μF 0.18mm超薄LW逆转低ESL片状多层陶瓷电容器
如何在芯片制造中更有效地使用数据
这家公司已开始布局第四代半导体材料
WiFi技术的原理、特点和标准有哪些
人工智能是实现国产芯片换道超车的机会
GRPC的基础使用方法
浅析PCIe Gen 5 switch芯片内置的SerialTek PCIe抓包分析功能
比亚迪新能源汽车部分存在被低估的可能性
苹果为什么对正火热的区块链不感兴趣
关于固德威智慧能源管理系统的性能分析和应用
热电偶测温电路原理图
基于区块链技术的全球性粉丝生态平台FANS介绍
如何构造系统的三总线
印制电路板（PCB）布线在高速电路中具有关键的作用
微软提出了计划要支持Microsoft Store的应用商店原则的十诫
2019第一季全球前十大IC设计厂商排名出炉，多数企业营收衰退
HarmonyOS应用开发案例 剪贴板功能实现
Xilinx SDSoC开发环境面向公众开放
JESD204协议标准的分类和区别
PPLive成Adworld 2010最大赢家 ‘百事群音’