引言
在设计模式中，责任链模式是一种行为设计模式，它允许多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合。这种模式通过将这些对象链接成一条链，并沿着链传递请求来实现。在实现责任链模式时，选择合适的数据结构至关重要。本文将从链表和数组的基本概念和特点出发，探讨为什么在责任链模式中使用链表而不是数组。
责任链模式概述
责任链模式的核心在于创建一个处理对象的链，每个处理对象都包含对下一个处理对象的引用。请求在链上传递，直到其中一个处理对象处理请求为止。这个模式的典型应用场景包括事件处理系统、任务处理系统和审批流程等。
责任链模式的定义和用途
责任链模式通过将处理者对象链接起来，形成一个链式结构，使得每个处理者都有机会处理请求。其主要用途是解耦请求的发送者和接收者，提供一种灵活的方式来组织和执行请求。
责任链模式的典型应用场景
1。事件处理系统：如GUI事件处理，其中每个控件都有机会处理事件。
2。任务处理系统：如任务调度和处理，其中不同的处理器处理不同类型的任务。
3。审批流程：如工作流系统中，各级审批人员按顺序处理审批请求。
链表 vs 数组
链表的结构和特性
链表是一种线性数据结构，其中每个元素（节点）包含一个数据部分和一个指向下一个节点的引用。链表分为单链表、双链表和循环链表等。
链表的优点
1。动态大小：链表不需要预先定义大小，可以根据需要动态扩展。
2。高效插入和删除：在链表中插入和删除节点只需调整指针，操作时间复杂度为O(1)。
链表的缺点
随机访问效率低：链表不支持高效的随机访问，访问第n个节点需要遍历链表。
数组的结构和特性
数组是一种线性数据结构，包含固定数量的相同类型元素。数组中的元素在内存中是连续存储的，可以通过索引直接访问。
数组的优点
1。高效随机访问：数组支持O(1)时间复杂度的随机访问。
2。缓存友好：由于元素在内存中是连续存储的，数组访问速度较快。
数组的缺点
1。固定大小：数组必须在创建时定义大小， 无法动态调整。
2。低效插入和删除：在数组中插入或删除元素需要移动大量元素，操作时间复杂度为O(n)。
使用链表实现责任链模式的优势
动态添加和删除处理器的灵活性
责任链模式通常需要动态添加或删除处理器。链表结构支持O(1)时间复杂度的插入和删除操作，使得管理处理器链更加灵活和高效。
不确定处理器数量时的可扩展性
链表能够根据需要动态调整大小，而无需像数组那样预先分配和调整内存。这使得链表在处理器数量不确定或频繁变化的场景下具有显著优势。
顺序处理请求的自然支持
链表的节点按照顺序链接，自然地支持责任链模式中顺序处理请求的需求。每个处理器处理完请求后，可以直接将请求传递给下一个处理器。
高效的插入和删除操作
在链表中插入或删除处理器只需调整相邻节点的指针，无需像数组那样移动大量元素，因此在责任链模式中使用链表可以显著提高处理器链的管理效率。
数组实现责任链模式的劣势
固定大小限制
数组在创建时需要定义固定大小，无法根据需要动态调整。这在处理器数量不确定或频繁变化的责任链模式中会带来很大的限制。
低效的插入和删除操作
在数组中插入或删除处理器需要移动大量元素，这使得这些操作的时间复杂度为O(n)，在处理器链较长时效率低下。
内存浪费的问题
数组在初始化时需要分配固定大小的内存，若实际使用的处理器数量小于数组大小，会造成内存浪费。此外，频繁扩展数组也会带来内存分配和复制的开销。
rust代码demo实现
使用链表实现处理器链
trait Handler {
fn handle(&self, request: &str);
}
struct ConcreteHandler1 {
successor: Option<Box<dyn Handler>>,
}
impl Handler for ConcreteHandler1 {
fn handle(&self, request: &str) {
if request == "Handler1" {
println!("Handled by ConcreteHandler1");
} else if let Some(ref succ) = self.successor {
succ.handle(request);
}
}
}
struct ConcreteHandler2 {
successor: Option<Box<dyn Handler>>,
}
impl Handler for ConcreteHandler2 {
fn handle(&self, request: &str) {
if request == "Handler2" {
println!("Handled by ConcreteHandler2");
} else if let Some(ref succ) = self.successor {
succ.handle(request);
}
}
}
fn main() {
// 创建处理器链
let handler_chain = ConcreteHandler1 {
successor: Some(Box::new(ConcreteHandler2 { successor: None })),
};
// 处理请求
handler_chain.handle("Handler1");
handler_chain.handle("Handler2");
}
动态添加和删除处理器
trait Handler {
fn handle(&self, request: &str);
}
struct DynamicHandlerChain {
head: Option<Box<dyn Handler>>,
}
impl DynamicHandlerChain {
fn new() -> Self {
DynamicHandlerChain { head: None }
}
fn add_handler(&mut self, handler: Box<dyn Handler>) {
if self.head.is_none() {
self.head = Some(handler);
} else {
let mut current = &mut self.head;
while let Some(ref mut succ) = current {
if succ.as_ref().successor().is_none() {
succ.as_mut().set_successor(handler);
break;
}
current = succ.as_mut().successor_mut();
}
}
}
fn remove_handler<T: 'static + Handler>(&mut self) {
let mut current = &mut self.head;
let mut previous: Option<&mut Box<dyn Handler>> = None;
while let Some(ref mut handler) = current {
if handler.as_any().is::<T>() {
if let Some(ref mut prev) = previous {
prev.set_successor(handler.successor().take().unwrap());
} else {
self.head = handler.successor().take();
}
break;
}
previous = Some(handler);
current = handler.successor_mut();
}
}
fn handle(&self, request: &str) {
if let Some(ref head) = self.head {
head.handle(request);
}
}
}
impl<T: 'static + Handler> Handler for Box<T> {
fn handle(&self, request: &str) {
T::handle(self, request);
}
}
impl<T: 'static + Handler> dyn Handler {
fn as_any(&self) -> &dyn std::any::Any {
self
}
fn successor(&self) -> Option<&Box<dyn Handler>> {
None
}
fn successor_mut(&mut self) -> Option<&mut Box<dyn Handler>> {
None
}
fn set_successor(&mut self, _handler: Box<dyn Handler>) {}
}
struct ConcreteHandler1 {
successor: Option<Box<dyn Handler>>,
}
impl Handler for ConcreteHandler1 {
fn handle(&self, request: &str) {
if request == "Handler1" {
println!("Handled by ConcreteHandler1");
} else if let Some(ref succ) = self.successor {
succ.handle(request);
}
}
fn successor(&self) -> Option<&Box<dyn Handler>> {
self.successor.as_ref()
}
fn successor_mut(&mut self) -> Option<&mut Box<dyn Handler>> {
self.successor.as_mut()
}
fn set_successor(&mut self, handler: Box<dyn Handler>) {
self.successor = Some(handler);
}
}
struct ConcreteHandler2 {
successor: Option<Box<dyn Handler>>,
}
impl Handler for ConcreteHandler2 {
fn handle(&self, request: &str) {
if request == "Handler2" {
println!("Handled by ConcreteHandler2");
} else if let Some(ref succ) = self.successor {
succ.handle(request);
}
}
fn successor(&self) -> Option<&Box<dyn Handler>> {
self.successor.as_ref()
}
fn successor_mut(&mut self) -> Option<&mut Box<dyn Handler>> {
self.successor.as_mut()
}
fn set_successor(&mut self, handler: Box<dyn Handler>) {
self.successor = Some(handler);
}
}
fn main() {
// 创建动态处理器链
let mut dynamic_chain = DynamicHandlerChain::new();
dynamic_chain.add_handler(Box::new(ConcreteHandler1 { successor: None }));
dynamic_chain.add_handler(Box::new(ConcreteHandler2 { successor: None }));
// 处理请求
dynamic_chain.handle("Handler1");
dynamic_chain.handle("Handler2");
// 删除处理器
dynamic_chain.remove_handler::<ConcreteHandler1>();
dynamic_chain.handle("Handler1");
}
在这个实现中，我们定义了一个 Handler trait 和两个具体的处理器 ConcreteHandler1 和 ConcreteHandler2。我们还定义了一个 DynamicHandlerChain 结构，用于动态添加和删除处理器。为了支持这种动态操作，我们在 Handler trait 中添加了一些方法来获取和设置处理器的后继处理器。
总结
在责任链模式中使用链表而不是数组的原因主要包括链表在动态添加和删除处理器时的灵活性、不确定处理器数量时的可扩展性、顺序处理请求的自然支持以及高效的插入和删除操作。选择适当的数据结构对于设计和实现高效的责任链模式至关重要。通过本文的探讨，可以更好地理解为什么链表在这种设计模式中更具优势。
