抽象工厂模式探索：系统族的制造机！

雍一辰
55 阅读3分钟

抽象工厂模式是一种创建模式，专为生成产品族设计，而不仅仅是一个产品系列。它通过定义多个抽象产品，使得一系列相关的产品能够同时创建，而不显示它们的实现类。

为什么选择抽象工厂模式？

  • 当一个系统应该独立于其产品的创建、组合和表示时。
  • 当系统需要多个产品系列，而要确保一个系列的产品是同时创建的。
  • 当产品的家族需要约束关系。

业务场景深入分析：

  1. 跨平台应用开发：如果你正在为多个操作系统开发应用，你可能希望使用不同的用户界面组件（如按钮、列表和窗口）。抽象工厂可以为每个操作系统提供一个具体工厂，所有这些工厂都实现相同的抽象工厂接口。

  2. 在线购物平台：考虑一家在线购物平台，该平台支持多种支付方式如信用卡、电子钱包、银行转账等。每种支付方式可能需要不同的验证机制和支付网关。抽象工厂可以为每种支付方式提供不同的实现，但所有这些都遵循相同的接口。

  3. GUI库：不同的操作系统提供不同风格的GUI组件，如按钮、菜单和滚动条。抽象工厂允许创建针对特定操作系统的组件，同时为应用开发人员提供一致的API。

优势：

  • 隔离具体类：帮助将应用与它使用的类的实现分隔。
  • 增加或更换产品族容易。
  • 保证同一产品族中的产品是一起创建的。

缺点：

  • 难以支持新种类的产品，这会违反开闭原则。

代码示例：

1. C#:

public abstract class AbstractProductA
{
    public abstract void DescribeA();
}

public abstract class AbstractProductB
{
    public abstract void DescribeB();
}

public class ProductA1 : AbstractProductA
{
    public override void DescribeA() => Console.WriteLine("This is ProductA1");
}

public class ProductB1 : AbstractProductB
{
    public override void DescribeB() => Console.WriteLine("This is ProductB1");
}

public abstract class AbstractFactory
{
    public abstract AbstractProductA CreateProductA();
    public abstract AbstractProductB CreateProductB();
}

public class ConcreteFactory1 : AbstractFactory
{
    public override AbstractProductA CreateProductA() => new ProductA1();
    public override AbstractProductB CreateProductB() => new ProductB1();
}

2. C++:

#include <iostream>

// Abstract products
class AbstractProductA {
public:
    virtual void DescribeA() = 0;
};

class AbstractProductB {
public:
    virtual void DescribeB() = 0;
};

// Concrete products
class ProductA1 : public AbstractProductA {
public:
    void DescribeA() override {
        std::cout << "This is ProductA1" << std::endl;
    }
};

class ProductB1 : public AbstractProductB {
public:
    void DescribeB() override {
        std::cout << "This is ProductB1" << std::endl;
    }
};

// Abstract factory
class AbstractFactory {
public:
    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

// Concrete factory
class ConcreteFactory1 : public AbstractFactory {
public:
    AbstractProductA* CreateProductA() override {
        return new ProductA1();
    }

    AbstractProductB* CreateProductB() override {
        return new ProductB1();
    }
};

3. Java:

// Abstract products
abstract class AbstractProductA {
    public abstract void describeA();
}

abstract class AbstractProductB {
    public abstract void describeB();
}

// Concrete products
class ProductA1 extends AbstractProductA {
    @Override
    public void describeA() {
        System.out.println("This is ProductA1");
    }
}

class ProductB1 extends AbstractProductB {
    @Override
    public void describeB() {
        System.out.println("This is ProductB1");
    }
}

// Abstract factory
abstract class AbstractFactory {
    public abstract AbstractProductA createProductA();
    public abstract AbstractProductB createProductB();
}

// Concrete factory
class ConcreteFactory1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ProductB1();
    }
}

4. Python:

from abc import ABC, abstractmethod

# Abstract products
class AbstractProductA(ABC):
    @abstractmethod
    def describe_a(self):
        pass

class AbstractProductB(ABC):
    @abstractmethod
    def describe_b(self):
        pass

# Concrete products
class ProductA1(AbstractProductA):
    def describe_a(self):
        print("This is ProductA1")

class ProductB1(AbstractProductB):
    def describe_b(self):
        print("This is ProductB1")

# Abstract factory
class AbstractFactory(ABC):
    @abstractmethod
    def create_product_a(self):
        pass

    @abstractmethod
    def create_product_b(self):
        pass

# Concrete factory
class ConcreteFactory1(AbstractFactory):
    def create_product_a(self):
        return ProductA1()

    def create_product_b(self):
        return ProductB1()

5. Go:

package main

import "fmt"

// Abstract products
type AbstractProductA interface {
	DescribeA()
}

type AbstractProductB interface {
	DescribeB()
}

// Concrete products
type ProductA1 struct{}

func (p *ProductA1) DescribeA() {
	fmt.Println("This is ProductA1")
}

type ProductB1 struct{}

func (p *ProductB1) DescribeB() {
	fmt.Println("This is ProductB1")
}

// Abstract factory
type AbstractFactory interface {
	CreateProductA() AbstractProductA
	CreateProductB() AbstractProductB
}

// Concrete factory
type ConcreteFactory1 struct{}

func (f *ConcreteFactory1) CreateProductA() AbstractProductA {
	return &ProductA1{}
}

func (f *ConcreteFactory1) CreateProductB() AbstractProductB {
	return &ProductB1{}
}

6. TypeScript:

// Abstract products
interface AbstractProductA {
    describeA(): void;
}

interface AbstractProductB {
    describeB(): void;
}

// Concrete products
class ProductA1 implements AbstractProductA {
    describeA(): void {
        console.log("This is ProductA1");
    }
}

class ProductB1 implements AbstractProductB {
    describeB(): void {
        console.log("This is ProductB1");
    }
}

// Abstract factory
interface AbstractFactory {
    createProductA(): AbstractProductA;
    createProductB(): AbstractProductB;
}

// Concrete factory
class ConcreteFactory1 implements AbstractFactory {
    createProductA(): AbstractProductA {
        return new ProductA1();
    }

    createProductB(): AbstractProductB {
        return new ProductB1();
    }
}

这些是抽象工厂模式的代码实现。在真实的应用中，您可能会遇到多个具体产品和多个具体工厂，这取决于您的需求和设计。

avatar
文章
阅读
粉丝