用Rust实现23种设计模式之 职责链模式

关注我，学习Rust不迷路！！

优点

• 解耦：职责链模式将请求发送者和接收者解耦，使得多个对象都有机会处理请求，而不是将请求的发送者和接收者紧密耦合在一起。
• 灵活性：可以动态地改变或扩展处理请求的顺序和责任链中的对象。
• 可维护性：每个处理者只需关注自己的责任，使得代码更易于理解、维护和扩展。

使用场景

• 当有多个对象可以处理同一个请求，但具体的处理者在运行时才确定时，职责链模式非常有用。
• 当需要在不明确接收者的情况下，将请求的发送者和接收者解耦时，职责链模式可以提供一种简单而灵活的解决方案。

代码示例

下面是一个简单的例子，演示如何使用 Rust 实现职责链模式。

// 请求结构体
struct Request {
    content: String,
}
 // 处理者 trait
trait Handler {
    fn set_next(&mut self, handler: Box<dyn Handler>);
    fn handle_request(&self, request: &Request);
}
 // 具体处理者 A
struct ConcreteHandlerA {
    next_handler: Option<Box<dyn Handler>>,
}
 impl Handler for ConcreteHandlerA {
    fn set_next(&mut self, handler: Box<dyn Handler>) {
        self.next_handler = Some(handler);
    }
     fn handle_request(&self, request: &Request) {
        if request.content.contains("A") {
            println!("Handled by ConcreteHandlerA");
        } else if let Some(ref handler) = self.next_handler {
            handler.handle_request(request);
        } else {
            println!("No handler can handle the request");
        }
    }
}
 // 具体处理者 B
struct ConcreteHandlerB {
    next_handler: Option<Box<dyn Handler>>,
}
 impl Handler for ConcreteHandlerB {
    fn set_next(&mut self, handler: Box<dyn Handler>) {
        self.next_handler = Some(handler);
    }
     fn handle_request(&self, request: &Request) {
        if request.content.contains("B") {
            println!("Handled by ConcreteHandlerB");
        } else if let Some(ref handler) = self.next_handler {
            handler.handle_request(request);
        } else {
            println!("No handler can handle the request");
        }
    }
}
 // 使用示例
fn main() {
    let mut handler_a = ConcreteHandlerA { next_handler: None };
    let mut handler_b = ConcreteHandlerB { next_handler: None };
     handler_a.set_next(Box::new(handler_b));
     let request_a = Request {
        content: String::from("Request A"),
    };
    handler_a.handle_request(&request_a);
     let request_b = Request {
        content: String::from("Request B"),
    };
    handler_a.handle_request(&request_b);
     let request_c = Request {
        content: String::from("Request C"),
    };
    handler_a.handle_request(&request_c);
}

解释说明

• 首先，我们定义了一个 Request 结构体，代表请求的内容。
• 然后，我们定义了一个 Handler trait，包含设置下一个处理者和处理请求的方法。
• 接着，我们实现了两个具体的处理者： ConcreteHandlerA 和 ConcreteHandlerB ，它们都实现了 Handler trait 的方法。如果当前处理者可以处理请求，则进行处理；否则，将请求传递给下一个处理者。
• 在 main 函数中，我们创建了两个具体的处理者对象，并使用 set_next 方法将它们连接成职责链。然后，我们创建了三个不同的请求，并通过第一个处理者来处理它们。

关注我，学习Rust不迷路！！