设计模式笔记

PHP常用的设计模式

Posted by jintang on 2014-09-22

1. 工厂模式

工厂方法或者类生成对象，而不是在代码中直接new

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<?php 
class Database
{
}

class Factory
{
    public static function createDatabase()
    {
        return new Database();
    }
}

$db = Factory::createDatabase();
?>

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
<?php
class Singleton
{
    protected static $obj;

    /**
     * 把构造函数设置成私有，防止使用new来实例化对象
     * Singleton constructor.
     */
    private function __construct()
    {
    }

    public static function getInstance()
    {
        if (!(self::$obj instanceof Singleton)) {
            self::$obj = new self();
        }
        return self::$obj;
    }
}

$single = Singleton::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
<?php

class Register
{
    protected static $objects;

    public function set($alias, $object)
    {
        self::$objects[$alias] = $object;
    }

    public function get($alias)
    {
        return self::$objects[$alias];
    }

    public function _unset($alias)
    {
        unset(self::$objects[$alias]);
    }
}

// 初始化
$single = Singleton::getInstance();
Register::set('s', $single);

// 在其他任何地方使用single
$s = Register::get('s');
?>

4. 适配器模式

适配器模式，可以将截然不同的函数接口封装成统一的API

如：mysql，mysqli，pdo3，类似cache适配器的场景，缓存有memcache，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
<?php

// 首先实现一个接口，约定方法
interface IDatabase
{
    public function connect($host, $user, $pass, $dbname);
    public function query($sql);
    public function close();
}

// 若干种扩展
class MySQL implements IDatabase
{
    // 实现connect方法
    public function connect($host, $user, $pass, $dbname)
    {
    }
    
    public function query($sql)
    {
    }
    
    public function close()
    {
    }
}

class MySQLi implements IDatabase
{
    // 实现connect方法
    public function connect($host, $user, $pass, $dbname)
    {
    }
    
    public function query($sql)
    {
    }
    
    public function close()
    {
    }
}

// 开发者可以选择其中一种扩展
$db = new MySQL();
$db = new MySQLi();
$db->connect('localhost', 'root', '123456', 'test');
$db->query('show databases');
$db->close();
?>

5. 策略模式

  1. 将一组特定的行为和算法封装成类，以适应某些特定的上下文环境，这种模式就是策略模式。
  2. 场景：假如一个点上网站系统，针对男女性用户要各自跳转到不同的商品类目，并且所有广告位展示不同的广告
  3. 应用：实现Ioc、依赖倒置和控制反转

策略定义：UserStrategy.php

1
2
3
4
5
6
7
8
<?php
// 策略接口
interface UserStrategy 
{
    public function showAd();
    public function showCategory();
}
?>

男性策略：MaleUserStrategy.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
class MaleUserStrategy implements UserStrategy
{
    public function showAd()
    {
        // TODO: Implement showAd() method.
        echo "2017款男装";
    }

    public function showCategory()
    {
        // TODO: Implement showCategory() method.
        echo "男装";
    }
}
?>

女性策略：FemaleUserStrategy.php

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<?php
class FemaleUserStrategy implements UserStrategy
{
    public function showAd()
    {
        // TODO: Implement showAd() method.
        echo "2017款女装";
    }

    public function showCategory()
    {
        // TODO: Implement showCategory() method.
        echo "女装";
    }
}
?>

应用：index.php

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
<?php
// 选择策略
$is_male = $_GET['male'];
if ($is_male) {
    $strategy = new MaleUserStrategy();
} else {
    $strategy = new FemaleUserStrategy();    
}

class Page
{  
    protected $strategy;
    
    public function index()
    {
        echo "AD:";
        echo $this->strategy->showAd();
        echo "Category:";
        echo $this->strategy->showCategory();
    }
    
    public function setStrategy(UserStrategy $strategy)
    {
        $this->strategy = $strategy;
        return $this;
    }
}

$page = new Page();
$page->setStrategy($strategy)->index();
?>

6. 数据对象映射模式

  1. 数据对象映射模式，是将对象和数据存储映射起来，对一个对象的操作会映射到对数据存储的操作。
  2. 比如实现一个ORM类，将复杂的sql语句映射成对象属性的操作

数据表user:

1
2
3
4
5
6
CREATE TABLE `user` (
  `id` int(10) unsigned NOT NULL COMMENT 'ID',
  `name` varchar(32) NOT NULL DEFAULT '' COMMENT '姓名',
  `mobile` varchar(11) NOT NULL DEFAULT '' COMMENT '电话号码',
  `regtime` int(11) NOT NULL DEFAULT '0' COMMENT '注册时间'
) ENGINE=InnoDB DEFAULT CHARSET=utf8

实例代码, User.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
class User
{
    public $id;
    public $name;
    public $mobile;
    public $regtime;

    protected $db;

    public function __construct($id)
    {
        // 根据id查询具体的某一行，然后赋值给对应的成员对象
    }

    public function __destruct()
    {
        // 根据成员变量，更新数据库
    }
}

7. 观察者模式

  1. 观察者模式，当以个对象发生改变时，依赖他的对象全部会收到通知，并自动更新
  2. 场景：一个事件发生后，要执行一连串的更新操作。传统的编程方式，就是在事件的代码之后直接加入处理逻辑。当更新的逻辑增加之后，代码会变得难以维护。这种方式是耦合的，侵入式的，增加新的逻辑需要修改事件主体代码。
  3. 观察者模式实现了低耦合，非侵入式的通知和更新机制。

观察者Observer:

1
2
3
4
5
6
<?php
interface Observer
{
    public funciton update($event_info = null);
}
?>

事件生产者EventGenerator：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php

abstract class EventGenerator 
{
    private $observers = [];
    public function addObserver(Observer $observer)
    {
        $this->observers[] = $observer;
    }
    
    public function notify()
    {
        if (count($this->observers) > 0) {
            foreach ($this->observers as $observer) {
                $observer->update();
            }
        }
    } 
}
?>

应用：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?php

class Event extends EventGenerator
{
    public function trigger()
    {
        echo "触发逻辑 \n";
        // 通知所有观察者做更新操作
        $this->notify();
    }
}

class Observer1 implement Observer
{
    public function update($event_info = null) 
    {
        echo "我是观察者1，我收到更新动作通知，我要做些操作";
    }
}

$event = new Event;
$event->addObserver(new Observer1);
$event->trigger();
?>

8. 原型模式

  1. 与工厂模式作用类似，都是用来创建对象
  2. 与工厂模式的实现不用，原型模式是先创建好一个原型对象，然后通过clone原型对象来创建新的对象，这样就免去了类创建时重复的初始化操作
  3. 原型模式适合于大对象的创建，创建一个大对象要很大的开销，如果每次new就会消耗很大，原型模式仅需要内存拷贝即可。
1
2
3
4
5
6
7
8
9
10
11
12
13
<?php 

# 假设有这么一个大类 Prototype

$prototype = new Prototype; // 实例化一个对象
$prototype->init();         // 初始化

$obj1 = clone $prototype;
$obj1->dosomething();

$obj2 = clone $prototype;
$obj2->dosomething();
?>

9. 装饰器模式

  1. 装饰器模式（Decorator），可以动态地添加修改类的功能
  2. 一个类提供一项功能，如果要在修改并添加额外的功能，传统的编程模式，需要写一个子类继承它，并重新实现类的方法
  3. 使用装饰器模式，仅需要在运行时添加一个装饰器对象即可实现，可以实现最大的灵活性。

某一个功能类，如画一条线：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
class DrawLine
{
    private $char = '';
    private $long = 0;
    
    public function init($char = '_', $long = 10)
    {
        $this->char = $char;
        $this->long = $long;
    }
    
    public function do()
    {
        echo str_repeat($this->char, $this->long);
    }
}
?>

以上类，想要修改线的样式，必须修改代码，首先必须给他添加具备使用装饰器的能力.

声明一个装饰器接口：

1
2
3
4
5
6
7
8
9
<?php

interface DrawDecorator
{
    public funciton beforeDraw();
    public function afterDraw();
}

?>

具备使用装饰器能力的画图类

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
<?php

abstract draw
{
    protected $decorators = [];
    
    public function addDecorator(DrawDecorator $decorator)
    {
        $this->decorators[] = $decorator;
    }
    
    public function beforeDraw()
    {
        if (count($this->decorators) > 0) {
            foreach ($this->decorators as $decorator) {
                $decorator->beforeDraw();
            }
        }
    }
    
    public function afterDraw()
    {
        $decorators = array_reverse($this->decorators);
        if (count($decorators) > 0) {
            foreach ($decorators as $dec) {
                $dec->afterDraw();
            }
        }
    }
}

# 刚刚的画线类，继承draw
class DrawLine extends draw
{
    private $char = '';
    private $long = 0;
    
    public function init($char = '_', $long = 10)
    {
        $this->char = $char;
        $this->long = $long;
    }
    
    public function do()
    {
        $this->beforeDraw();    // 执行画线前动作
        echo str_repeat($this->char, $this->long);
        $this->afterDraw();     // 执行画线后动作
    }
}
?>

应用：

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
<?php
# 实现一个装饰器
class ColorDrawDecorator implements DrawDecorator
{
    private $color;
    public function __constructor($color)
    {
        $this->color = $color;
    }
    
    public function beforeDraw()
    {
        echo "<div style='color:{$this->color}'>";
    }
    
    public function afterDraw()
    {
        echo "</div>";
    }
}

$line = new DrawLine;
$line->init('-', 20);

// 实例化颜色装饰器，并且添加装饰器到line
$line->addDecorator(new ColorDrawDecoration('red'));

$line->do();

10. 迭代器模式

  1. 迭代器模式，在不需要了解内部实现的前提下，遍历一个聚合对象的内部元素
  2. 相对于传统的编程模式，迭代器可以隐藏遍历元素的所需的操作。
  3. PHP中使用迭代器，只要实现接口Iterator

查询所有用户：

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
<?php
class AllUser implements \Iterator
{
    protected $ids;
    protected $index;
    protected $data;

    public function __construct()
    {
        $db = Factory::getDatabase();
        $result = $db->query("SELECT id FROM user", MYSQLI_ASSOC);
        $this->ids = $result->fetch_all(MYSQLI_ASSOC);
    }

    public function next()
    {
        $this->index++;
    }

    public function valid()
    {
        return $this->index < count($this->ids);
    }

    public function rewind()
    {
        $this->index = 0;
    }

    public function key()
    {
        return $this->index;
    }

    public function current()
    {
        $id = $this->ids[$this->index]['id'];
        return Factory::getUser($id);
    }
}

11. 代理模式

  1. 在客户端与实体之间建立一个代理对象（proxy），客户端对实体进行操作全部委派给代理对象，隐藏实体的具体实现细节。
  2. Proxy还可以与业务代码分离，部署到另一个的服务器。业务代码中通过RPC来委派任务。

12. 配置化

PHP中使用ArrayAccess实现配置文件的加载

Config.php

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
<?php
class Config implements \ArrayAccess
{
    protected $path;
    protected $configs = [];

    public function __construct($path)
    {
        $this->path = $path;
    }

    public function offsetExists($offset)
    {
        // TODO: Implement offsetExists() method.
    }

    public function offsetGet($offset)
    {
        if (empty($this->configs[$offset])) {
            $file_path = $this->path . '/' . $offset . '.php';
            $config = require $file_path;
            $this->configs[$offset] = $config;
        }
        return $this->configs[$offset];
    }

    public function offsetSet($offset, $value)
    {
        // TODO: Implement offsetSet() method.
    }

    public function offsetUnset($offset)
    {
        // TODO: Implement offsetUnset() method.
    }
}

有配置文件controller.php：

1
2
3
4
5
6
7
8
9
10
<?php
# Config/controller.php
return [
    'home' => [
        'decorator' => [
            'Imooc\Decorator\Template'
        ]
    ],
    'default' => 'hello world'
];

应用：
1
2
3
<?php
$config = new Config(__DIR__ . '/Config/controller.php');
var_dump($config['controller']);