用法

将以下依赖项添加到您的Cargo.toml中

lrcall = "0.1"

lrcall::service属性展开为形成一个rpc服务的项目集合。这些生成的类型使编写具有较少样板代码的服务变得简单而方便。只需实现生成的服务特质，然后就可以开始比赛了！

示例

此示例使用tokio，因此请将以下依赖项添加到您的Cargo.toml

anyhow = "1.0"
futures = "0.3"
lrcall = { version = "0.1", features = ["tokio1"] }
tokio = { version = "1.0", features = ["macros"] }

在以下示例中，我们使用进程内通道在客户端和服务器之间进行通信。在实际代码中，您可能会通过网络进行通信。有关更实际的示例，请参阅lrcall-example。

首先，让我们设置依赖关系和服务定义。

# extern crate futures;

use futures::{
    prelude::*,
};
use lrcall::{
    client, context,
    server::{self, incoming::Incoming, Channel},
};

// This is the service definition. It looks a lot like a trait definition.
// It defines one RPC, hello, which takes one arg, name, and returns a String.
#[lrcall::service]
trait World {
    /// Returns a greeting for name.
    async fn hello(name: String) -> String;
}

此服务定义生成一个名为World的特质。接下来我们需要为我们的Server结构体实现它。

# extern crate futures;
# use futures::{
#     prelude::*,
# };
# use lrcall::{
#     client, context,
#     server::{self, incoming::Incoming},
# };
# // This is the service definition. It looks a lot like a trait definition.
# // It defines one RPC, hello, which takes one arg, name, and returns a String.
# #[lrcall::service]
# trait World {
#     /// Returns a greeting for name.
#     async fn hello(name: String) -> String;
# }
// This is the type that implements the generated World trait. It is the business logic
// and is used to start the server.
#[derive(Clone)]
struct HelloService;

impl World for HelloService {
    // Each defined rpc generates an async fn that serves the RPC
    async fn hello(self, _: context::Context, name: String) -> String {
        format!("Hello, {name}!")
    }
}

最后，让我们编写我们的main，它将启动服务器。虽然此示例使用进程内通道，但lrcall还提供了一个位于serde-transport功能之后的泛型serde_transport，该功能在tcp功能之后提供了额外的TCP功能。

# extern crate futures;
# use futures::{
#     prelude::*,
# };
# use lrcall::{
#     client, context,
#     server::{self, Channel},
# };
# // This is the service definition. It looks a lot like a trait definition.
# // It defines one RPC, hello, which takes one arg, name, and returns a String.
# #[lrcall::service]
# trait World {
#     /// Returns a greeting for name.
#     async fn hello(name: String) -> String;
# }
# // This is the type that implements the generated World trait. It is the business logic
# // and is used to start the server.
# #[derive(Clone)]
# struct HelloService;
# impl World for HelloService {
    // Each defined rpc generates an async fn that serves the RPC
#     async fn hello(self, _: context::Context, name: String) -> String {
#         format!("Hello, {name}!")
#     }
# }
# #[cfg(not(feature = "tokio1"))]
# fn main() {}
# #[cfg(feature = "tokio1")]
#[tokio::main]
async fn main() -> anyhow::Result<()> {
    let (client_transport, server_transport) = lrcall::transport::channel::unbounded();

    let server = server::BaseChannel::with_defaults(server_transport);
    tokio::spawn(
        server.execute(HelloService.serve())
            // Handle all requests concurrently.
            .for_each(|response| async move {
                tokio::spawn(response);
            }));

    // WorldClient is generated by the #[lrcall::service] attribute. It has a constructor `new`
    // that takes a config and any Transport as input.
    let mut client = WorldClient::<HelloService>::rpc_client(WorldChannel::spawn(client::Config::default(), client_transport));

    // The client has an RPC method for each RPC defined in the annotated trait. It takes the same
    // args as defined, with the addition of a Context, which is always the first arg. The Context
    // specifies a deadline and trace information which can be helpful in debugging requests.
    let hello = client.hello(context::rpc_current(), "Andeya".to_string()).await?;

    println!("{hello}");

    Ok(())
}