Rust语言从入门到精通系列 - 玩转“策略模式”

策略模式是面向对象编程中的一种设计模式，在该模式中，算法可以被独立于使用它的客户端和变化。该模式通过定义一个算法族，分别封装起来，使得它们之间可以互相替换，此模式让算法的变化独立于使用算法的客户。

在Rust中，策略模式可以用于替代函数指针的使用。在本文中，我们将通过讲解常用用法和示例，进阶用法，最佳实践等几个方面探讨Rust中的策略模式实践。

常用用法和示例#

在Rust中，我们可以将策略模式应用于以下两种场景：

能够在运行时动态地选择实现的功能。
通过实现不同的功能来清晰地描述某种实体的不同行为。

接下来，我们分别介绍这两种场景对应的示例。

运行时动态选择实现的功能#

假设我们正在构建一个程序，该程序可以计算几个数字之间的最大值。然而，我们希望用户能够自由地选择用来计算最大值的算法。我们可以通过策略模式实现这一目标。

首先，我们需要定义一个MaxStrategy trait，该trait定义了求最大值的方法：

1
trait MaxStrategy {
2
    /// 求一组数字的最大值
3
    fn find_max(&self, nums: &[i32]) -> i32;
4
}

然后，我们可以实现几种不同的求最大值的算法，如下所示：

1
// 使用快速排序求最大值
2
struct QuickSortStrategy;
3
impl MaxStrategy for QuickSortStrategy {
4
    fn find_max(&self, nums: &[i32]) -> i32 {
5
        let mut nums = nums.to_vec();
6
        nums.sort();
7
        *nums.last().unwrap()
8
    }
9
}
10

11
// 使用选择排序求最大值
12
struct SelectionSortStrategy;
13
impl MaxStrategy for SelectionSortStrategy {
14
    fn find_max(&self, nums: &[i32]) -> i32 {
15
        let mut nums = nums.to_vec();
16
        for i in 0..nums.len() {
17
            let max_index = (i..nums.len()).max_by_key(|&j| nums[j]).unwrap();
18
            nums.swap(i, max_index);
19
        }
20
        *nums.last().unwrap()
21
    }
22
}

现在，我们可以编写一个程序，该程序允许用户选择在运行时使用哪种算法来计算最大值。实现如下：

1
fn main() {
2
    // 读取用户输入
3
    let args: Vec<String> = std::env::args().collect();
4
    if args.len() < 2 {
5
        eprintln!("Usage: ./max <strategy>");
6
        std::process::exit(1);
7
    }
8

9
    // 根据用户输入选择算法
10
    let strategy: Box<dyn MaxStrategy> = match args[1].as_str() {
11
        "qs" => Box::new(QuickSortStrategy),
12
        "ss" => Box::new(SelectionSortStrategy),
13
        _ => {
14
            eprintln!("Invalid strategy");
15
            std::process::exit(1);
16
        }
17
    };
18

19
    // 读取一组数字，计算最大值
20
    let nums: Vec<i32> = read_line().split_whitespace().map(|x| x.parse().unwrap()).collect();
21
    let max = strategy.find_max(&nums);
22
    println!("Max: {}", max);
23
}

这个程序允许用户在运行时选择最大值的计算方法。用户可以执行以下命令来选择计算方法：

1
./max qs 1 2 3 4 5

该命令使用快速排序计算最大值。您也可以将qs替换为ss来使用选择排序。

通过实现不同的功能来清晰地描述实体的不同行为#

假设我们正在为一个游戏编写一个AI模块，该模块可以让NPC根据当前情况进行不同的操作。在这个游戏中，有两种可供选择的操作：战斗和逃跑。我们可以通过策略模式实现这个AI。

首先，我们需要定义一个CombatStrategy trait和一个FleeStrategy trait来描述战斗和逃跑的操作：

1
trait CombatStrategy {
2
    fn execute(&self);
3
}
4

5
trait FleeStrategy {
6
    fn execute(&self);
7
}

然后，我们可以实现不同的战斗和逃跑策略：

1
struct NormalAttackStrategy;
2
impl CombatStrategy for NormalAttackStrategy {
3
    fn execute(&self) {
4
        println!("Performing normal attack");
5
    }
6
}
7

8
struct HeavyAttackStrategy;
9
impl CombatStrategy for HeavyAttackStrategy {
10
    fn execute(&self) {
11
        println!("Performing heavy attack");
12
    }
13
}
14

15
struct RunAwayStrategy;
16
impl FleeStrategy for RunAwayStrategy {
17
    fn execute(&self) {
18
        println!("Running away");
19
    }
20
}
21

22
struct HideStrategy;
23
impl FleeStrategy for HideStrategy {
24
    fn execute(&self) {
25
        println!("Hiding");
26
    }
27
}

现在，我们可以实现一个AI结构体，该结构体包含了一个战斗策略和一个逃跑策略。这个AI结构体可以通过选择战斗和逃跑策略来适应不同的游戏情境：

1
struct AI<T: CombatStrategy, U: FleeStrategy> {
2
    combat_strategy: T,
3
    flee_strategy: U,
4
}
5

6
impl<T: CombatStrategy, U: FleeStrategy> AI<T, U> {
7
    fn new(combat_strategy: T, flee_strategy: U) -> Self {
8
        Self {
9
            combat_strategy,
10
            flee_strategy,
11
        }
12
    }
13

14
    fn attack(&self) {
15
        self.combat_strategy.execute();
16
    }
17

18
    fn flee(&self) {
19
        self.flee_strategy.execute();
20
    }
21
}

现在，我们可以创建不同的AI实例，该实例可以根据当前情况执行不同的操作：

1
fn main() {
2
    // 创建一个能够攻击并逃跑的AI let ai1 = AI::new(NormalAttackStrategy, RunAwayStrategy);
3
    ai1.attack();
4
    ai1.flee();
5

6
    // 创建一个能够进行重型攻击并隐藏的AI
7
    let ai2 = AI::new(HeavyAttackStrategy, HideStrategy);
8
    ai2.attack();
9
    ai2.flee();
10
}

进阶用法#

在本节中，我们将介绍一些高级用法，以提高策略模式的可定制性和代码的重用性。

使用associated type#

在Rust中，我们可以将associated type用于定义策略模式的实现。通过关联类型，我们可以让实现具有更高的灵活性（可以定义impl中的任何类型）。

使用associated type，我们可以将上面的MaxStrategy trait改写成如下的形式：

1
trait MaxStrategy {
2
    /// 计算一组数字的最大值
3
    type Output;
4
    fn find_max(&self, nums: &[i32]) -> Self::Output;
5
}

我们可以在每个实现中定义Associated Type的类型别名：

1
struct QuickSortStrategy;
2
impl MaxStrategy for QuickSortStrategy {
3
    type Output = i32;
4
    fn find_max(&self, nums: &[i32]) -> Self::Output {
5
        let mut nums = nums.to_vec();
6
        nums.sort();
7
        *nums.last().unwrap()
8
 }
9
}
10

11
struct SelectionSortStrategy;
12
impl MaxStrategy for SelectionSortStrategy {
13
    type Output = i32;
14
    fn find_max(&self, nums: &[i32]) -> Self::Output {
15
        let mut nums = nums.to_vec();
16
        for i in 0..nums.len() {
17
            let max_index = (i..nums.len()).max_by_key(|&j| nums[j]).unwrap();
18
            nums.swap(i, max_index);
19
        }
20
        *nums.last().unwrap()
21
    }
22
}

使用泛型#

Rust中的策略模式还可以使用泛型来提高代码的灵活性和可重用性。例如，在上面的战斗和逃跑的示例中，我们可以将AI结构体改写成以下的形式：

1
struct AI<T> {
2
    combat_strategy: T,
3
}
4

5
impl<T: CombatStrategy> AI<T> {
6
    fn new(combat_strategy: T) -> Self {
7
        Self {
8
            combat_strategy,
9
        }
10
    }
11

12
    fn execute_strategy(&self) {
13
        self.combat_strategy.execute();
14
    }
15
}

现在，我们只需要一个CombatStrategy trait来定义所有的AI操作。这使得对于AI而言，战斗和逃跑等操作可以相互替换。

最佳实践#

在使用策略模式时，为了实现代码的可维护性和可读性，需要遵循一些最佳实践：

将策略模式的变量作为trait对象使用，而不是作为struct实例使用。
提高使用associated type定义的trait的灵活性。
对于涉及到多个策略的情况，需要使用泛型。
对于每个策略，使用单独的模块定义该策略的实现，以提高代码的可维护性。
尽量避免过度使用策略模式。

结论#

Rust中的策略模式是一种非常灵活和可定制的设计模式，可以用于在运行时动态地选择实现、或者通过实现不同的功能来清晰地描述某种实体的不同行为。在实现策略模式时，我们可以使用associated type和泛型来增强策略模式的可定制性和代码的重用性。如果你想将这些概念应用于实际项目中，请根据最佳实践编写代码，以提高代码的可读性和可维护性。

音乐

音乐