Rust语言从入门到精通系列 - 玩转“责任链路模式”

1
enum Request {
2
    Get,
3
    Post(String),
4
    Delete,
5
}
6

7
trait Handler {
8
    fn handle(&mut self, req: Request);
9
}
10

11
struct GetHandler;
12
struct PostHandler {
13
    next: Option<Box<dyn Handler>>,
14
}
15
struct DeleteHandler;
16

17
impl Handler for GetHandler {
18
    fn handle(&mut self, req: Request) {
19
        match req {
20
            Request::Get => println!("Handled GET request."),
21
            _ => println!("Failed to handle request."),
22
        }
23
    }
24
}
25

26
impl Handler for PostHandler {
27
    fn handle(&mut self, req: Request) {
28
        match req {
29
            Request::Post(data) => println!("Handled POST request with data: {}", data),
30
            _ => {
31
                if let Some(ref mut next) = self.next {
32
                    next.handle(req);
33
                } else {
34
                    println!("Failed to handle request.");
35
                }
36
            }
37
        }
38
    }
39
}
40

41
impl Handler for DeleteHandler {
42
    fn handle(&mut self, req: Request) {
43
        match req {
44
            Request::Delete => println!("Handled DELETE request."),
45
            _ => println!("Failed to handle request."),
46
        }
47
    }
48
}
49

50
fn main() {
51
    let mut get_handler = GetHandler {};
52
    let mut post_handler = PostHandler {
53
        next: Some(Box::new(DeleteHandler {})),
54
    };
55

56
    get_handler.handle(Request::Get);
57
    post_handler.handle(Request::Post("Some data".to_string()));
58
    post_handler.handle(Request::Delete);
59
}

1
use actix_web::{web, App, HttpServer, Responder};
2

3
fn index(info: web::Path<(String, u32)>) -> impl Responder {
4
    format!("Hello {}! id:{}", info.0, info.1)
5
}
6

7
fn main() -> std::io::Result<()> {
8
    HttpServer::new(|| {
9
        App::new()
10
            .service(
11
                web::resource("/{name}/{id}")
12
                    .route(web::get().to(index)),
13
            )
14
    })
15
        .bind("127.0.0.1:8080")?
16
        .run()
17
}

1
use std::sync::Arc;
2
use tokio::sync::oneshot;
3

4
#[tokio::main]
5
async fn main() {
6
    let (tx, mut rx) = oneshot::channel();
7
    let mut handler = AsyncHandler {};
8

9
    let request = Arc::new(Request::new());
10
    async {
11
        handler.handle(request.clone()).await;
12
        tx.send(request).unwrap();
13
    }.await;
14

15
    let result = rx.try_recv().unwrap();
16
}
17

18
struct AsyncHandler;
19

20
impl AsyncHandler {
21
    pub async fn handle(&mut self, req: Arc<Request>) {
22
        // async task
23
    }
24
}

1
extern crate rustast;
2
use rustast::generate_handler_chain;
3

4
fn main() {
5
    let handler_chain = generate_handler_chain! {
6
        "用户名校验" => |req| -> Result<Request, UserError> {
7
            // ...
8
            Ok(req)
9
        },
10

11
        "密码校验" => |req| -> Result<Request, UserError> {
12
            // ...
13
            Ok(req)
14
 },
15

16
        "权限校验" => |req| -> Result<Request, UserError> {
17
            // ...
18
            Ok(req)
19
        },
20
        // ...
21
    };
22

23
    handler_chain.handle(Request::new());
24
}