PHP 工厂模式

简介

在面向对象编程中，**工厂模式（Factory Pattern）**是一种创建型设计模式，它提供了一个用于创建对象的接口，而无需指定具体类。使用工厂模式可以将实例化逻辑封装起来，并通过工厂方法返回所需的对象，从而降低代码的耦合度，提高了代码的可维护性和扩展性。

本文将详细介绍如何在 PHP 中实现工厂模式，包括简单工厂、工厂方法和抽象工厂三种常见的工厂模式类型。

一、简单工厂（Simple Factory）

1.1 定义

简单工厂模式是最简单的工厂模式，它由一个工厂类负责创建产品对象。根据参数的不同返回不同类的实例，被创建的实例通常都具有共同的父类或接口。

1.2 UML 图示

classDiagram
    class Factory {
        +createProduct(type: string): Product
    }
    class Product {
        <<interface>>
        +operation(): void
    }
    class ConcreteProductA {
        +operation(): void
    }
    class ConcreteProductB {
        +operation(): void
    }
    Factory --> Product : creates
    ConcreteProductA --|> Product : implements
    ConcreteProductB --|> Product : implements

1.3 PHP 代码实例

<?php
interface Product {
    public function operation();
}
class ConcreteProductA implements Product {
    public function operation() {
        // ...具体操作逻辑...
    }
}
class ConcreteProductB implements Product {
    public function operation() {
        // ...具体操作逻辑...
    }
}
class Factory {
    public static function createProduct($type) {
        switch ($type) {
            case 'A':
                return new ConcreteProductA();
            case 'B':
                return new ConcreteProductB();
            default:
                throw new InvalidArgumentException("Invalid product type.");
        }
    }
}
// 使用简单工厂创建对象
$product = Factory::createProduct('A');
$product->operation();

二、工厂方法（Factory Method）

2.1 定义

工厂方法模式是简单工厂的一种升级，它将创建对象的逻辑放在了子类中。每个具体产品类都有一个相应的具体工厂类来创建该产品。

2.2 UML 图示

classDiagram
    class Factory {
        <<interface>>
        +createProduct(): Product
    }
    class ConcreteFactoryA {
        +createProduct(): Product
    }
    class ConcreteFactoryB {
        +createProduct(): Product
    }
    class Product {
        <<interface>>
        +operation(): void
    }
    class ConcreteProductA {
        +operation(): void
    }
    class ConcreteProductB {
        +operation(): void
    }
    Factory <|-- ConcreteFactoryA : implements
    Factory <|-- ConcreteFactoryB : implements
    ConcreteFactoryA --> ConcreteProductA : creates
    ConcreteFactoryB --> ConcreteProductB : creates
    Product <|.. ConcreteProductA : extends
    Product <|.. ConcreteProductB : extends

2.3 PHP 代码实例

<?php
interface Product {
    public function operation();
}
class ConcreteProductA implements Product {
    public function operation() {
        // ...具体操作逻辑...
    }
}
class ConcreteProductB implements Product {
    public function operation() {
        // ...具体操作逻辑...
    }
}
interface Factory {
    public function createProduct(): Product;
}
class ConcreteFactoryA implements Factory {
    public function createProduct(): Product {
        return new ConcreteProductA();
    }
}
class ConcreteFactoryB implements Factory {
    public function createProduct(): Product {
        return new ConcreteProductB();
    }
}
// 使用工厂方法创建对象
$factory = new ConcreteFactoryA();
$product = $factory->createProduct();
$product->operation();

三、抽象工厂（Abstract Factory）

3.1 定义

抽象工厂模式是工厂方法的一种升级，它可以创建一系列相关或相互依赖的对象。每个具体工厂都生产一个特定主题的产品，而客户端只需要与具体工厂进行交互，无需关心所创建的具体产品是什么。

3.2 UML 图示

classDiagram
    class AbstractFactory {
        <<interface>>
        +createProductA(): AbstractProductA
        +createProductB(): AbstractProductB
    }
    class ConcreteFactory1 {
        +createProductA(): AbstractProductA
        +createProductB(): AbstractProductB
    }
    class ConcreteFactory2 {
        +createProductA(): AbstractProductA
        +createProductB(): AbstractProductB
    }
    class AbstractProductA {
        <<interface>>
        +operationA(): void
    }
    class ConcreteProductA1 {
        +operationA(): void
    }
    class ConcreteProductA2 {
        +operationA(): void
    }
    class AbstractProductB {
        <<interface>>
        +operationB(): void
    }
    class ConcreteProductB1 {
        +operationB(): void
    }
    class ConcreteProductB2 {
        +operationB(): void
    }
    AbstractFactory <|-- ConcreteFactory1 : implements
    AbstractFactory <|-- ConcreteFactory2 : implements
    ConcreteFactory1 --> ConcreteProductA1 : creates
    ConcreteFactory1 --> ConcreteProductB1 : creates
    ConcreteFactory2 --> ConcreteProductA2 : creates
    ConcreteFactory2 --> ConcreteProductB2 : creates
    AbstractProductA <|.. ConcreteProductA1 : implements
    AbstractProductA <|.. ConcreteProductA2 : implements
    AbstractProductB <|.. ConcreteProductB1 : implements
    AbstractProductB <|.. ConcreteProductB2 : implements

3.3 PHP 代码实例

<?php
interface AbstractProductA {
    public function operationA();
}
class ConcreteProductA1 implements AbstractProductA {
    public function operationA() {
        // ...具体操作逻辑...
    }
}
class ConcreteProductA2 implements AbstractProductA {
    public function operationA() {
        // ...具体操作逻辑...
    }
}
interface AbstractProductB {
    public function operationB();
}
class ConcreteProductB1 implements AbstractProductB {
    public function operationB() {
        // ...具体操作逻辑...
    }
}
class ConcreteProductB2 implements AbstractProductB {
    public function operationB() {
        // ...具体操作逻辑...
    }
}
interface AbstractFactory {
    public function createProductA(): AbstractProductA;
    public function createProductB(): AbstractProductB;
}
class ConcreteFactory1 implements AbstractFactory {
    public function createProductA(): AbstractProductA {
        return new ConcreteProductA1();
    }
    public function createProductB(): AbstractProductB {
        return new ConcreteProductB1();
    }
}
class ConcreteFactory2 implements AbstractFactory {
    public function createProductA(): AbstractProductA {
        return new ConcreteProductA2();
    }
    public function createProductB(): AbstractProductB {
        return new ConcreteProductB2();
    }
}
// 使用抽象工厂创建对象
$factory = new ConcreteFactory1();
$productA = $factory->createProductA();
$productB = $factory->createProductB();
$productA->operationA();
$productB->operationB();

结论

工厂模式是一种常用的设计模式，在 PHP 中可以通过简单工厂、工厂方法和抽象工厂三种不同的实现方式来实现。每种方式都有自己的优缺点，根据具体情况选择合适的方式可以提高代码的可维护性、扩展性和灵活性。熟练掌握工厂模式对于编写高质量的 PHP 代码至关重要。