PHP常用的11种设计模式

本文简单介绍下,在 PHP 开发中涉及的常用的设计模式。包含:工厂模式、单例模式、注册器模式、适配器模式、策略模式、数据对象映射模式、观察者模式、原型模式、装饰器模式、迭代器模式、代理模式等。

1、工厂模式

使用一个工厂方法或类创建对象,而不是直接使用 new

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
 * 工厂类
 */
class Factory
{

    /**
     * 制造类PHPHa的对象
     */
    public static function createObject()
    {
        return new PHPHa();
    }
}

// 【调用示例】
$object = Factory::createObject();

2、单例模式

使某个类的对象只允许被创建一次。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
// 类
class Single
{

    /**
     * 唯一实例属性
     */
    protected static $instance;

    /**
     * 构造函数私有
     */
    private function __construct()
    {}

    /**
     * 析构函数私有
     */
    private function __destruct()
    {}

    /**
     * 克隆函数私有
     */
    private function __clone()
    {}

    /**
     * 创建唯一实例
     */
    public static function getInstance()
    {
        if (empty(self::$instance)) {
            self::$instance = new self();
        }
        return self::$instance;
    }
}

// 【调用示例】
$instance = Single::getInstance();

3、注册器模式

用来解决全局共享和交换对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
// 类
class Register
{

    /**
     * 对象数组
     */
    protected static $objects = [];

    /**
     * 设置对象
     */
    public static function set($name, $object)
    {
        self::$objects[$name] = $object;
    }

    /**
     * 获取对象
     */
    public static function get($name)
    {
        return self::$objects[$name];
    }

    /**
     * 删除对象
     */
    public static function unset($name)
    {
        unset(self::$objects[$name]);
    }
}

// 【调用示例】
Register::set('single', Single::getInstance());
$single = Register::get('single');
Register::unset('single');

4、适配器模式

可以将不同的函数接口封装成统一的 API

常见的场景,列如框架中的数据库驱动,对接有 mysql mysqli pdo ,可以用适配器模式对上层调用封装为统一的调用方式。同样还有各种缓存驱动文件,比如以 memcached redis file等作为缓存方式,是同样的道理。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
/**
 * 数据库驱动接口
 */
interface IDB
{
    // 连接数据库
    public function connect($host, $user, $pwd, $db);
    // 查询数据库
    public function query($sql);
    // 关闭连接
    public function close();
}

/**
 * MySQL驱动
 */
class MySQL implements IDB
{

    protected $conn;

    public function connect($host, $user, $pwd, $db)
    {
        $this->conn = mysql_connect($house, $user, $pwd);
        mysql_select_db($db, $this->conn);
    }

    public function query($sql)
    {
        return mysql_query($sql, $this->conn);
    }

    public function close()
    {
        mysql_close($this->conn);
    }
}

/**
 * MySQLi驱动
 */
class MySQLi implements IDB
{

    protected $conn;

    public function connect($host, $user, $pwd, $db)
    {
        $this->conn = mysqli_connect($host, $user, $pwd, $db);
    }

    public function query($sql)
    {
        return mysqli_query($this->conn, $sql);
    }

    public function close()
    {
        unset($this->conn);
    }
}

/**
 * PDO驱动
 */
class PDO implements IDB
{

    protected $conn;

    public function connect($host, $user, $pwd, $db)
    {
        $this->conn = new \PDO("mysql:host={$host};dbname={$db}", $user, $pwd);
    }

    public function query($sql)
    {
        return $this->conn->query($sql);
    }

    public function close()
    {
        $this->conn->close();
    }
}

// 【调用示例】
// MySQL
$conn = new MySQL('localhost', 'root', 'root', 'test');
$conn->query('SELECT * FROM news');
$conn->close();
// MySQLi
$conn = new MySQLi('localhost', 'root', 'root', 'test');
$conn->query('SELECT * FROM news');
$conn->close();
// PDO
$conn = new PDO('localhost', 'root', 'root', 'test');
$conn->query('SELECT * FROM news');
$conn->close();

5、策略模式

将一组特定的行为和算法封装成类,以适应某些特定的上下文环境。

使用策略模式可以实现 IoC 控制反转,这是 Laravel 框架的核心模式。

例如:电商网站中的广告位,针对访客的性别可以展示不同的商品。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/**
 * 广告页面
 */
class Page
{

    /**
     * 策略
     */
    protected $strategy;

    /**
     * 广告位
     */
    public function adSpace()
    {
        $this->strategy->showAd();
    }

    /**
     * 设置策略
     */
    public function setStrategy(UserStrategy $strategy)
    {
        $this->strategy = $strategy;
    }
}

/**
 * 定义接口
 */
interface UserStrategy
{

    /**
     * 展示广告
     */
    public function showAd();
}

/**
 * 男性用户
 */
class MaleStrategy implements UserStrategy
{

    public function showAd()
    {
        echo '男性感兴趣的商品';
    }
}

/**
 * 女性用户
 */
class FemaleStrategy implements UserStrategy
{

    public function showAd()
    {
        echo '女性感兴趣的商品';
    }
}

// 【调用示例】
$page = new Page();
// 男性访客
isset($_GET['male']) && $page->setStrategy(new MaleStrategy());
// 女性访客
isset($_GET['female']) && $page->setStrategy(new FemaleStrategy());
// 展示广告
$page->adSpace();

6、数据对象映射模式

将对象和数据操作映射起来,对一个对象的操作会映射为对数据存储的操作。

在主流的 PHP 框架中,都包含有各自实现的 ORM 类。下面通过实现一个简单的 ORM 类来详细说明。

先创建一张用户表,如下:

1
2
3
4
5
CREATE TABLE `users`  (
  `id` int(10) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '用户ID',
  `name` varchar(30) NOT NULL DEFAULT '' COMMENT '用户姓名',
  PRIMARY KEY (`id`)
);

通过数据对象映射模式对数据进行读取和更新:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/**
 * 用户类
 */
class User
{

    /**
     * 字段属性映射|用户ID
     */
    public $id;

    /**
     * 字段属性映射|用户姓名
     */
    public $name;

    /**
     * 数据库连接
     */
    protected $db;

    /**
     * 构造函数|属性赋值
     */
    public function __construct($id)
    {
        // 采用文章上面封装的数据库驱动
        $this->db = new MySQLi();
        $this->db->connect('localhost', 'root', 'root', 'test');
        $res = $this->db->query('SELECT * FROM users WHERE id = ', intval($id));
        $data = $res->fetch_assoc();
        // 赋值
        $this->id = intval($data['id']);
        $this->name = trim($data['name']);
    }

    /**
     * 析构函数|更新数据库
     */
    public function __destruct()
    {
        $this->db->query("UPDATE users SET name = '{$this->name}' WHERE id = {$this->id}");
    }
}

// 【调用示例】
$user = new User(1);
// 输出当前用户名
echo $user->name;
// 更新用户名
$user->name = '新用户名';

7、观察者模式

定义:当一个对象状态发生改变时,依赖它的对象会全部收到通知,并自动更新。

场景:一个事件发生后,要执行一连串的更新操作。传统的编程方式,就是在事件代码之后硬编码的方式加入处理逻辑。但是,当更新的逻辑逐渐变多后,就变得难以维护。这种方式是耦合的,侵入式的。

观察者模式实现了低耦合,非侵入式的通知和更新机制。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
/**
 * 事件类
 */
class Event extends EventGenerator
{

    /**
     * 触发器
     */
    public function trigger()
    {
        // 事件发生后调用通知
        $this->notify();
    }
}

/**
 * 事件发生者
 */
abstract class EventGenerator
{

    /**
     * 观察者数组
     */
    private $observers = [];

    /**
     * 增加观察者
     */
    public function addObserver(Observer $observer)
    {
        $this->observers[] = $observer;
    }

    /**
     * 通知
     */
    public function notify()
    {
        // 依次通知更新
        foreach ($this->observers as $observer) {
            $observer->update();
        }
    }
}

/**
 * 观察者接口
 */
interface Observer
{

    /**
     * 更新操作
     */
    public function update($event_info = null);
}

/**
 * 观察者A
 */
class ObserverA implements Observer
{

    public function update($event_info = null)
    {
        echo '观察者A对应的逻辑处理' . PHP_EOL;
    }
}

/**
 * 观察者B
 */
class ObserverB implements Observer
{

    public function update($event_info = null)
    {
        echo '观察者B对应的逻辑处理' . PHP_EOL;
    }
}

// 【调用示例】
$event = new Event();
$event->addObserver(new ObserverA());
$event->addObserver(new ObserverB());
$event->trigger();

8、原型模式

与工厂模式类似,都是用来创建对象。

与工厂模式的实现不同,原型模式是先创建好一个原型对象,然后通过 clone 原型对象来创建新的对象。这样就免去了类创建时的初始化操作。

原型模式适用于大对象的创建。所谓大对象是指创建需要很大开销的对象,原型模式通过 clone 仅需内存拷贝即可。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
/**
 * 原型类
 */
class Prototype
{

    /**
     * 初始化
     */
    public function init()
    {
        // 一些消耗资源的逻辑
    }

    /**
     * 具体功能
     */
    public function do()
    {
        echo '做一些事情';
    }
}

// 【调用示例】
$object = new Prototype();
$object->init();
$object1 = clone $object;
$object1->do();
$object2 = clone $object;
$object2->do();

9、装饰器模式

可以动态的添加修改类的功能。

一个类提供了一项功能,如果要添加额外的功能,传统的编程模式是通过创建一个子类继承这个类,并重新实现父类的方法。

使用装饰器模式,仅需在运行时添加一个装饰器对象即可,可以实现最大的灵活性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/**
 *  装饰器接口
 */
interface Decorator
{

    /**
     * 前置操作
     */
    public function before();

    /**
     * 后置操作
     */
    public function after();
}

/**
 * 装饰器A
 */
class DecoratorA implements Decorator
{

    public function before()
    {
        echo '装饰器A前置操作' . PHP_EOL;
    }

    public function after()
    {
        echo '装饰器A后置操作' . PHP_EOL;
    }
}

/**
 * 装饰器B
 */
class DecoratorB implements Decorator
{

    public function before()
    {
        echo '装饰器B前置操作' . PHP_EOL;
    }

    public function after()
    {
        echo '装饰器B后置操作' . PHP_EOL;
    }
}

/**
 * 演示类
 */
class Test
{

    /**
     * 装饰器数组
     */
    protected $decorators = [];

    /**
     * 挂载装饰器
     */
    public function addDecorator(Decorator $decorator)
    {
        $this->decorators[] = $decorator;
    }

    /**
     * 依次调用前置操作
     */
    private function doBefore()
    {
        // 正序
        foreach ($this->decorators as $decorator) {
            $decorator->before();
        }
    }

    /**
     * 依次调用后置操作
     */
    private function doAfter()
    {
        // 倒序|反转数组
        $decorators = array_reverse($this->decorators);
        foreach ($decorators as $decorator) {
            $decorator->after();
        }
    }

    /**
     * 演示类主逻辑
     */
    public function do()
    {
        $this->doBefore();
        echo '演示类主逻辑' . PHP_EOL;
        $this->doAfter();
    }
}

// 【调用示例】
$test = new Test();
$test->addDecorator(new DecoratorA());
$test->addDecorator(new DecoratorB());
$test->do();

10、迭代器模式

在不需要了解内部实现的前提下,遍历一个聚合对象的内部元素。

相比于传统编程模式,迭代器模式可以隐藏遍历元素所需的操作。

PHP 中迭代器的实现需要继承 PHP 标准库中的 Iterator interface,并实现其对应的 5 个接口方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
/**
 * 查询数据库中的用户信息
 */
class Users implements \Iterator
{

    /**
     * 当前索引
     */
    protected $index;

    /**
     * 数据集合
     */
    protected $data;

    /**
     * 构造函数
     */
    public function __construct()
    {
        // 链接数据库|仅做演示
        // 此处代码应用工厂模式拆分
        $db = new MySQLi('localhost', 'root', 'root', 'test');
        $query = $db->query('SELECT * FROM users');
        $this->data = $query->fetch_all(MYSQLI_ASSOC);
    }

    /**
     * 当前元素
     */
    public function current()
    {
        return $this->data[$this->index];
    }

    /**
     * 下一个元素
     */
    public function next()
    {
        $this->index ++;
    }

    /**
     * 验证是否还有下一个元素
     */
    public function valid()
    {
        return $this->index < count($this->data);
    }

    /**
     * 重置索引
     */
    public function rewind()
    {
        $this->index = 0;
    }

    /**
     * 索引位置
     */
    public function key()
    {
        return $this->index;
    }
}

// 【调用示例】
$users = new Users();
foreach ($users as $user) {
    print_r($user);
}

11、代理模式

在客户端与实体之间建立一个代理对象 Proxy,客户端对实体进行的操作全部委派给代理对象,隐藏具体的实现细节。

Proxy 还可以与业务代码分离,部署到另外的服务器,业务代码中通过 RPC 来委派任务。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * 代理接口
 */
interface IProxy
{

    public function doA();

    public function doB();
}

/**
 * 代理类
 */
class Proxy implements IProxy
{

    public function doA()
    {
        echo '一些操作A';
    }

    public function doB()
    {
        echo '一些操作B';
    }
}

// 【调用示例】
$proxy = new Proxy();
// 通过代理进行操作
$proxy->doA();
$proxy->doB();