浅谈PHP设计模式的工厂模式

浅谈PHP设计模式的工厂模式

【导语】本文通俗讲解 PHP 设计模式中创建型的工厂模式，分为简单工厂、工厂模式、抽象工厂三种：简单工厂用静态方法按参数生成对象（易理解但产品变动时改核心代码、违背开闭原则）；工厂模式把创建推迟到子类、职责清晰、符合开闭原则（代价是类增多、更抽象）；抽象工厂可一次创建一组互有关联的对象、减少工厂子类数量。文末用对照表比较三者实现难度、细节、优缺点与适用场景，并配 Keyboard/Mouse、Talk/Write 等 PHP 代码示例。

核心观点

• 简单工厂：通过静态 build($key) 按参数 new 对应对象；优点易懂，缺点是产品类变动时需改工厂核心代码、违背开闭原则
  
• 工厂模式：定义工厂接口、每个产品配子工厂（如 KeyboardFactory/MouseFactory），创建推迟到子类、符合开闭原则；缺点为类数量增加、更抽象
  
• 抽象工厂：由抽象工厂/具体工厂/抽象产品/具体产品四部分构成，一个工厂的方法可返回多个关联对象（如 EnglishFactory 同时 buildSay/buildWriteWord），减少工厂子类
  
• 三者对比：简单工厂适合类无关联且不常变动的简单场景；工厂模式适合产品易变动；抽象工厂适合类之间有关联且不常变动；抽象层级与维护成本随复杂度递增
  

适用场景
适用于 PHP 后端开发、设计模式学习与代码重构场景，适合 PHP 开发者与面试复习参考。

关键信息
（教程，文中 Keyboard/Mouse 简单工厂、Usb 工厂模式、Talk/Write 抽象工厂完整 PHP 代码与三者对照表见正文。）

---

简介

工厂模式属于创建型模式，可以分为三种：简单工厂、工厂模式、抽象工厂。
通俗讲就是用于如何优雅的创建对象而设计。当开发者不知道建什么对象，或者创建方式过于复杂的时候去使用（比如引入一个大composer项目或大型sdk，有些时候确实不知道需要使用那些对象，此时就需要参考官方文档，通过包里或sdk里提供的工厂方法，传入指定参数去生成指定对象。比如easyWechat项目。），适用于具有服务端和调用端的场景，既能优化调用端的使用体感，也能隐藏服务端创建对象的细节。
简单工厂

作用

帮忙创建对象（核心方法可以使用静态方法，称之为静态工厂）。
适用场景

• 当不知道创建什么对象的时候去使用
  
• 创建对象过于复杂的时候去使用。
  

优点

简单工厂是工厂模式中创建对象最简单的方式，通俗容易理解。
缺点

当要生产对象的模块发生了需求变更，此时要被实例化的类可能会增加或者减少，此时就需要改工厂模式的核心代码，违背了开闭原则。
代码

1. class Keyboard{
2.     public function run() {
3.         return '我能打字';
4.     }
5. }
7. class Mouse {
8.     public function run() {
9.         return '我能控制光标';
10.     }
11. }
13. class Factory {
14.     public static function build($key) {
15.         if($key == 'mouse') {
16.             return new Mouse();
17.         } else if ($key == 'keyboard') {
18.             return new Keyboard();
19.         }
20.     }
21. }
23. //----------调用端----------
24. $res = Factory::build('mouse')->run();
26. /*
27. 笔者认为，简单工厂可以简化为以下写法
28. 但是这会有三个缺陷：
29. 1. 能否做到类名写法一致？不一定能做到
30. 2. 缺少白名单机制，不安全，指不定new那个类，特别是这个参数守用户传参影响的场景，不过这个可以让需要实例化的类实现一个接口，工厂方法添加typehint （类型约束）限制。
31. 3. 如果修改白名单，又违背了开闭原则。
32. */
33. class Factory {
34.     public static function build($class) {
35.         return ucfirst($class);
36.     }
37. }

复制代码

工厂模式

作用

解决了简单工厂模式中违背开闭原则的问题。
适用场景

• 并解决了简单工厂模式下，一旦类发生变化，就需要修改核心模块的作用，遵循开闭原则。
  
• 产品层变化较大的的场景
  

优点

• 将创建对象的过程推迟的子类去实现，职责清晰，比较符合开闭原则。
  
• 并解决了简单工厂模式下，一旦类发生变化，就需要修改核心模块的作。
  

缺点

额外增加设计复杂度，每增加一个类，就需要增加一个子工厂。增加了系统抽象性。
代码

1. interface Usb {
2.     public function run();
3. }
5. class Keyboard implements USb {
6.     public function run() {
7.         return '我能打字';
8.     }
9. }
11. class Mouse implements USb {
12.     public function run() {
13.         return '我能控制光标';
14.     }
15. }
17. interFace Factory {
18.     public static function build();
19. }
21. class KeyboardFactory implements Factory {
22.     public static function build() :Keyboard {
23.         return new Keyboard();
24.     }
25. }
27. class MouseFactory implements Factory {
28.     public static function build() :Mouse {
29.         return new Mouse();
30.     }
31. }
32. //----------调用端----------
33. $res = MouseFactory::build()->run();

复制代码

抽象工厂

作用

• 抽象工厂相比于工厂模式，可以创建一堆互有关联对象。
  
• 抽象工厂的实现由4部分构成：抽象工厂，具体工厂，抽象产品，具体产品。
  

适用场景

对象创建过程复杂，并且类与类之间有关联的时候。
优点

抽象工厂可以用一个类的不同方法返回不同对象，（工厂模式一个子类生产一个对象，抽象工厂可以生产出多个对象），替代系统中存在大量的工厂类。
缺点

会产生较大的变动，需要添加指定的方法去维护抽象工厂的完整性。
代码

1. interface Talk {
2.     public function say();
3. }
5. class EnglishTalk implements Talk {
6.     public function say() {
7.         return 'I can speak English';
8.     }
9. }
11. class ChineseTalk implements Talk {
12.     public function say() {
13.         return '我会说中文';
14.     }
15. }
17. interface Write {
18.     public function writeWord();
19. }
21. class EnglishWrite implements Write {
22.     public function writeWord() {
23.         return 'I can write English words';
24.     }
25. }
27. class ChineseWrite implements Write {
28.     public function writeWord() {
29.         return '我会写汉字';
30.     }
31. }
33. interface Factory {
34.     public static function buildSay();
35.     public static function buildWriteWord();
36. }
38. class EnglishFactory implements Factory {
39.     public static function buildSay() :EnglishTalk {
40.         return new EnglishTalk();
41.     }
43.     public static function buildWriteWord() :EnglishWrite {
44.         return new EnglishWrite();
45.     }
46. }
48. class ChineseFactory implements Factory {
49.     public static function buildSay() :ChineseTalk {
50.         return new ChineseTalk();
51.     }
53.     public static function buildWriteWord():ChineseWrite {
54.         return new ChineseWrite();
55.     }
56. }
58. //----------调用端----------
59. //中国人对应会说汉语，或写汉字，这就是有关联，
60. $chinese_say        = ChineseFactory::buildSay()->say();
61. $chinese_write_word = ChineseFactory::buildWriteWord()->writeWord();

复制代码

三者对比

简单工厂工厂模式抽象工厂实现难度相对简单相对复杂相对复杂实现细节通过方法生产对象（不需要子类）通过子类方法去生产对象通过子类方法去生产有关联的对象优点实现简单解决了简单工厂违背开闭原则的问题可以制造一堆有关联的对象，减少工厂模式下工厂子类的数量缺点违背开闭原则，不适用修改产品更加抽象，类数量增加，不方便维护更加抽象，类数量增加，不方便维护适用场景简单场景，类之间无关联且不经常变动需要实例化的产品容易有变动类之间有关联，且不经常变动