Feign-RS (Rest client of Rust)

How to use

Demo server

A server has any restful interface (like this : finduserbyid, newuser)

```shell curl 127.1:3000/user/findbyid/1

-> {"id":1,"name":"hello"}

curl -X POST 127.1:3000/user/new_user \ -H 'Content-Type: application/json' \ -d '{"id":1,"name":"Link"}'

-> "Link" ➜ ~

```

Dependencies

• Add feign dependency to Cargo.toml
• Add reqwest dependency to Cargo.toml and enable feature json
• Add serde's dependencies to Cargo.toml, because inputs or outputs entities must be Serialize / Deserialize

```toml [dependencies] feign = "0" reqwest = { version = "0.11", features = ["json"] } serde = "1.0" serdederive = "1.0" serdejson = "1.0"

runtime

tokio = { version = "1.15", features = ["macros", "rt-multi-thread"] } ```

Entites

Add a user entity add derives serdederive::Deserialize and serdederive::Serialize

```rust use serdederive::Deserialize; use serdederive::Serialize;

[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]

pub struct User { pub id: i64, pub name: String, } ```

Feign client

• Use feign::client macro and trait make a feign client, host is server address, path is controller context. (The host can be dynamically replaced and can be ignored)
• In the trait, use the method macro and path args make a request, the member method must async and first arg is recover(&self)
• Use #[json] / #[form] post body, use #[path] for replace \ in request path

```rust

use feign::{client, ClientResult};

[client(host = "http://127.0.0.1:3000", path = "/user")]

pub trait UserClient { #[get(path = "/findbyid/")] async fn findbyid(&self, #[path] id: i64) -> ClientResult>; #[post(path = "/newuser")] async fn newuser(&self, #[json] user: &User) -> ClientResult>; } ```

Demo

Use

```rust

[tokio::main]

async fn main() { let user_client: UserClient = UserClient::new();

match user_client.find_by_id(12).await {
    Ok(option) => match option {
        Some(user) => println!("user : {}", user.name),
        None => println!("none"),
    },
    Err(err) => panic!("{}", err),
};

match user_client
    .new_user(&User {
        id: 123,
        name: "name".to_owned(),
    })
    .await
{
    Ok(option) => match option {
        Some(result) => println!("result : {}", result),
        None => println!("none"),
    },
    Err(err) => panic!("{}", err),
};

} ```

text user : hello result : name

Options

Put headers

rust #[get(path = "/headers")] async fn headers( &self, #[json] age: &i64, #[headers] headers: HashMap<String, String>, ) -> ClientResult<Option<User>>;

Dynamic modify host with configure_host

```rust

[client(path = "/user")]

pub trait UserClient {}

[tokio::main]

async fn main() { let userclient: UserClient = UserClient::new(); userclient .configure_host(String::from("http://127.0.0.1:3000")) .await; } ```

Customer reqwest client builder

Impl a async fn Result>, put fn name to arg client_builder

```rust use feign::{client, ClientResult};

async fn client_builder() -> ClientResult { Ok(reqwest::ClientBuilder::new().build().unwrap()) }

[client(

host = "http://127.0.0.1:3000", path = "/user", clientbuilder = "clientbuilder" )] pub trait UserClient {} ```

Customer additional reqwest request builder

before_send

If you want check hash of json body, sign to header. Or log the request.

rust async fn before_send( request_builder: reqwest::RequestBuilder, http_method: HttpMethod, host: String, client_path: String, request_path: String, body: RequestBody, headers: Option<HashMap<String, String>>, ) -> ClientResult<reqwest::RequestBuilder> { println!( "============= (Before_send)\n\ {:?} => {}{}{}\n\ {:?}\n\ {:?}", http_method, host, client_path, request_path, headers, body ); Ok(request_builder.header("a", "b")) }

Set before_send arg with function name

```rust

[client(

host = "http://127.0.0.1:3000", path = "/user", clientbuilder = "clientbuilder", beforesend = "beforesend" )] pub trait UserClient { #[get(path = "/findbyid/")] async fn findbyid(&self, #[path] id: i64) -> ClientResult>; #[post(path = "/newuser")] async fn newuser(&self, #[json] user: &User) -> ClientResult>; } Result text ============= (Beforesend) Get => http://127.0.0.1:3000/user/findbyid/12 None None ============= (Beforesend) Post => http://127.0.0.1:3000/user/new_user None Json(Object({"id": Number(123), "name": String("name")})) ```

Custom deserialize

create async deserializer, result type same as field method rust async fn bare_string(body: String) -> ClientResult<String> { Ok(body) }

set deserialize, field method result type same as deserializer rust #[post(path = "/new_user", deserialize = "bare_string")] async fn new_user_bare_string(&self, #[json] user: &User) -> ClientResult<String>;

rust match user_client .new_user_bare_string(&User { id: 123, name: "name".to_owned(), }) .await { Ok(result) => println!("result : {}", result), Err(err) => panic!("{}", err), };

result (Raw text) text result : "name"