用Rust实现23种设计模式之抽象工厂

在 Rust 中，可以使用 trait 和泛型来实现抽象工厂模式。抽象工厂模式是一种创建型设计模式，它提供了一个接口来创建一系列相关或依赖对象的家族，而无需指定具体的类。下面是一个简单的示例，展示了如何使用 Rust 实现抽象工厂模式：

// 定义抽象产品族
trait AbstractProductA {
    fn operation_a(&self);
}
 trait AbstractProductB {
    fn operation_b(&self);
}
 // 实现具体产品族1
struct ConcreteProductA1;
impl AbstractProductA for ConcreteProductA1 {
    fn operation_a(&self) {
        println!("ConcreteProductA1 operation");
    }
}
 struct ConcreteProductB1;
impl AbstractProductB for ConcreteProductB1 {
    fn operation_b(&self) {
        println!("ConcreteProductB1 operation");
    }
}
 // 实现具体产品族2
struct ConcreteProductA2;
impl AbstractProductA for ConcreteProductA2 {
    fn operation_a(&self) {
        println!("ConcreteProductA2 operation");
    }
}
 struct ConcreteProductB2;
impl AbstractProductB for ConcreteProductB2 {
    fn operation_b(&self) {
        println!("ConcreteProductB2 operation");
    }
}
 // 定义抽象工厂
trait AbstractFactory {
    fn create_product_a(&self) -> Box<dyn AbstractProductA>;
    fn create_product_b(&self) -> Box<dyn AbstractProductB>;
}
 // 实现具体工厂1
struct ConcreteFactory1;
impl AbstractFactory for ConcreteFactory1 {
    fn create_product_a(&self) -> Box<dyn AbstractProductA> {
        Box::new(ConcreteProductA1)
    }
    fn create_product_b(&self) -> Box<dyn AbstractProductB> {
        Box::new(ConcreteProductB1)
    }
}
 // 实现具体工厂2
struct ConcreteFactory2;
impl AbstractFactory for ConcreteFactory2 {
    fn create_product_a(&self) -> Box<dyn AbstractProductA> {
        Box::new(ConcreteProductA2)
    }
    fn create_product_b(&self) -> Box<dyn AbstractProductB> {
        Box::new(ConcreteProductB2)
    }
}
 fn main() {
    // 使用具体工厂1创建具体产品族
    let factory1: Box<dyn AbstractFactory> = Box::new(ConcreteFactory1);
    let product_a1 = factory1.create_product_a();
    let product_b1 = factory1.create_product_b();
    product_a1.operation_a();
    product_b1.operation_b();
     // 使用具体工厂2创建具体产品族
    let factory2: Box<dyn AbstractFactory> = Box::new(ConcreteFactory2);
    let product_a2 = factory2.create_product_a();
    let product_b2 = factory2.create_product_b();
    product_a2.operation_a();
    product_b2.operation_b();
}

在上述示例中，我们首先定义了抽象产品族的 trait AbstractProductA 和 AbstractProductB ，分别定义了产品族中的操作方法。然后，我们实现了具体产品族1和具体产品族2，它们分别实现了 AbstractProductA 和 AbstractProductB trait。

接下来，我们定义了抽象工厂的 trait AbstractFactory ，其中定义了创建产品族中产品的方法。然后，我们实现了具体工厂1和具体工厂2，它们分别实现了 AbstractFactory trait，并实现了创建具体产品族的方法。

在 main 函数中，我们使用具体工厂创建具体产品族，并调用产品的操作方法。

通过抽象工厂模式，我们可以在运行时动态选择具体工厂和产品族，实现了创建对象的解耦和灵活性。