PHP的五种常见设计模式

时间 2019-11-12

标签 php 五种常见设计模式栏目 PHP 繁體版

原文原文链接

工厂模式

最初在设计模式一书中，许多设计模式都鼓励使用松散耦合。要理解这个概念，让咱们最好谈一下许多开发人员从事大型系统的艰苦历程。在更改一个代码片断时，就会发生问题，系统其余部分 —— 您曾认为彻底不相关的部分中也有可能出现级联破坏。该问题在于紧密耦合。系统某个部分中的函数和类严重依赖于系统的其余部分中函数和类的行为和结构。您须要一组模式，使这些类可以相互通讯，但不但愿将它们紧密绑定在一块儿，以免出现联锁。在大型系统中，许多代码依赖于少数几个关键类。须要更改这些类时，可能会出现困难。例如，假设您有一个从文件读取的 User 类。您但愿将其更改成从数据库读取的其余类，可是，全部的代码都引用从文件读取的原始类。这时候，使用工厂模式会很方便。工厂模式是一种类，它具备为您建立对象的某些方法。您可使用工厂类建立对象，而不直接使用 new。这样，若是您想要更改所建立的对象类型，只需更改该工厂便可。使用该工厂的全部代码会自动更改。清单 1 显示工厂类的一个示列。等式的服务器端包括两个部分：数据库和一组 PHP 页面，这些页面容许您添加反馈、请求反馈列表并获取与特定反馈相关的文章。php

清单1：Factory1.phpmysql

Factory1.php

 1 <?php
 2 interface IUser
 3 {
 4     function getName();
 5 }
 6 class User implements IUser
 7 {
 8     public function __construct($id){}
 9     
10     public function getName()
11     {
12         return "Jack";
13     }
14 }
15 class UserFactory
16 {
17     public static function Create($id)
18     {
19         return new User($id);
20     }
21 }
22 $uo = UserFactory::Create(1);
23 echo($uo->getName()."\n");

清单1的UML表示算法

测试代码会向工厂请求 User 对象，并输出 getName 方法的结果。sql

有一种工厂模式的变体使用工厂方法。类中的这些公共静态方法构造该类型的对象。若是建立此类型的对象很是重要，此方法很是有用。例如，假设您须要先建立对象，而后设置许多属性。此版本的工厂模式会将该进程封装在单个位置中，这样，不用复制复杂的初始化代码，也没必要将复制好的代码在在代码库中处处粘贴。数据库

清单2：Factory2.php设计模式

Factory2.php

 1 <?php
 2 interface IUser
 3 {
 4     function getName();
 5 }
 6 
 7 class User implements IUser
 8 {
 9     public static function Load($id)
10     {
11         return new User($id);
12     }
13     public static function Create()
14     {
15         return new User(null);
16     }
17     public function __construct($id){}
18     public function getName()
19     {
20         return "Jack2";
21     }
22 }
23 $uo = User::Load(1);
24 echo($uo->getName()."\n");

清单2的RML表示服务器

单元素模式

某些应用程序资源是独占的，由于有且只有一个此类型的资源。例如，经过数据库句柄到数据库的链接是独占的。您但愿在应用程序中共享数据库句柄，由于在保持链接打开或关闭时，它是一种开销，在获取单个页面的过程当中更是如此。架构

单元素模式能够知足此要求。若是应用程序每次包含且仅包含一个对象，那么这个对象就是一个单元素（Singleton）。清单 3 中的代码显示了 PHP V5 中的一个数据库链接单元素。并发

清单3：Singleton.phpdom

 1 <?php
 2 require_once 'DB.php';
 3 
 4 class DatabaseConnection
 5 {
 6     public static function get()
 7     {
 8         static $db = null;
 9         if ($db == null)
10             $db = new DatabaseConnection();
11         return $db;
12     }
13     
14     private $_handle = null;
15     
16     private function __construct()
17     {
18         $dsn = 'mysql://root:password@localhost/photos';
19         $this->_handle =&DB::Connect( $dsn, array() );
20     }
21     public function handle()
22     {
23         return $this->_handle;
24     }
25 }
26 print("Handle = ".DatabaseConnection::get()->handle()."\n");
27 print("Handle = ".DatabaseConnection::get()->handle()."\n");

Singleton.php

清单3的UML表示

返回的两个句柄是同一对象。若是您在整个应用程序中使用数据库链接单元素，那么就能够在任何地方重用同一句柄。

您可使用全局变量存储数据库句柄，可是，该方法仅适用于较小的应用程序。在较大的应用程序中，应避免使用全局变量，并使用对象和方法访问资源。

观察者模式

观察者模式为您提供了避免组件之间紧密耦合的另外一种方法。该模式很是简单：一个对象经过添加一个方法（该方法容许另外一个对象，即观察者 注册本身）使自己变得可观察。当可观察的对象更改时，它会将消息发送到已注册的观察者。这些观察者使用该信息执行的操做与可观察的对象无关。结果是对象能够相互对话，而没必要了解缘由。

一个简单示例是系统中的用户列表。清单 4 中的代码显示一个用户列表，添加用户时，它将发送出一条消息。添加用户时，经过发送消息的日志观察者能够观察此列表。

清单4：Observer.php

 1 <?php
 2 interface IObserver
 3 {
 4     function onChanged($sender,$args);
 5 }
 6 interface IObservable
 7 {
 8     function addObserver($observer);
 9 }
10 class UserList implements IObservable
11 {
12     private $_observers = array();
13     public function addCustomer($name)
14     {
15         foreach($this->_observers as $obs)
16             $obs->onChanged($this,$name);
17     }
18     public function addObserver($observer)
19     {
20         $this->_observers[] = $observer;
21     }
22 }
23 class UserListLogger implements IObserver
24 {
25     public function onChanged($sender,$args)
26     {
27         echo("$args added to user list\n");
28     }
29 }
30 $ul = new UserList();
31 $ul->addObserver(new UserListLogger());
32 $ul->addCustomer("Jack");

Observer.php

清单4的UML表示

测试代码建立 UserList，并将 UserListLogger 观察者添加到其中。而后添加一个消费者，并将这一更改通知 UserListLogger。

认识到 UserList 不知道日志程序将执行什么操做很关键。可能存在一个或多个执行其余操做的侦听程序。例如，您可能有一个向新用户发送消息的观察者，欢迎新用户使用该系统。这种方法的价值在于 UserList 忽略全部依赖它的对象，它主要关注在列表更改时维护用户列表并发送消息这一工做。

此模式不限于内存中的对象。它是在较大的应用程序中使用的数据库驱动的消息查询系统的基础。

命令链模式

命令链模式以松散耦合主题为基础，发送消息、命令和请求，或经过一组处理程序发送任意内容。每一个处理程序都会自行判断本身可否处理请求。若是能够，该请求被处理，进程中止。您能够为系统添加或移除处理程序，而不影响其余处理程序。清单 5 显示了此模式的一个示例。

清单5：Chain.php

 1 <?php
 2 interface ICommand
 3 {
 4     function onCommand($name,$args);
 5 }
 6 class CommandChain
 7 {
 8     private $_commands = array();
 9     public function addCommand($cmd)
10     {
11         $this->_commands[] = $cmd;
12     }
13     public function runCommand($name,$args)
14     {
15         foreach($this->_commands as $cmd)
16         {
17             if ($cmd->onCommand($name,$args))
18                 return;
19         }
20     }
21 }
22 class UserCommand implements ICommand
23 {
24     public function onCommand($name,$args)
25     {
26         if ($name != 'addUser') return false;
27         echo("UserCommand handling 'addUser'\n");
28         return true;
29     }
30 }
31 class MailCommand implements ICommand
32 {
33     public function onCommand($name,$args)
34     {
35         if ($name != 'mail') return false;
36         echo("MailCommand handling 'mail'\n");
37         return true;
38     }
39 }
40 
41 $cc = new CommandChain();
42 $cc->addCommand(new UserCommand());
43 $cc->addCommand(new MailCommand());
44 $cc->runCommand('addUser', null);
45 $cc->runCommand('mail', null);

Chain.php

清单5的UML表示

代码首先建立 CommandChain 对象，并为它添加两个命令对象的实例。而后运行两个命令以查看谁对这些命令做出了响应。若是命令的名称匹配 UserCommand 或 MailCommand，则代码失败，不发生任何操做。

为处理请求而建立可扩展的架构时，命令链模式颇有价值，使用它能够解决许多问题。

策略模式

咱们讲述的最后一个设计模式是策略模式。在此模式中，算法是从复杂类提取的，于是能够方便地替换。例如，若是要更改搜索引擎中排列页的方法，则策略模式是一个不错的选择。思考一下搜索引擎的几个部分 —— 一部分遍历页面，一部分对每页排列，另外一部分基于排列的结果排序。在复杂的示例中，这些部分都在同一个类中。经过使用策略模式，您可将排列部分放入另外一个类中，以便更改页排列的方式，而不影响搜索引擎的其他代码。

做为一个较简单的示例，清单 6 显示了一个用户列表类，它提供了一个根据一组即插即用的策略查找一组用户的方法。

清单6：Strategy.php

 1 <?php
 2 interface IStrategy
 3 {
 4     function filter($record);
 5 }
 6 class FindAfterStrategy implements IStrategy
 7 {
 8     private $_name;
 9     public function __construct($name)
10     {
11         $this->_name = $name;
12     }
13     public function filter($record)
14     {
15         return strcmp($this->_name,$record) <= 0;
16     }
17 }
18 class RandomStrategy implements IStrategy
19 {
20     public function filter($record)
21     {
22         return rand(0,1) >= 0.5;
23     }
24 }
25 class UserList
26 {
27     private $_list = array();
28     public function __construct($names)
29     {
30         if ($names != null)
31         {
32             foreach($names as $name)
33                 $this->_list[] = $name;
34         }
35     }
36     public function add($name)
37     {
38         $this->_list[] = $name;
39     }
40     public function find($filter)
41     {
42         $recs = array();
43         foreach($this->_list as $user)
44         {
45             if ($filter->filter($user))
46                 $recs[] = $user;
47         }
48         return $recs;
49     }
50 }
51 
52 $ul = new UserList(array("Andy","Jack","Lori","Megan"));
53 $f1 = $ul->find(new FindAfterStrategy("J"));
54 print_r($f1);
55 $f2 = $ul->find(new RandomStrategy());
56 print_r($f2);

Strategy.php

清单6的UML表示

测试代码为两个策略运行同一用户列表，并显示结果。在第一种状况中，策略查找排列在 J 后的任何名称，因此您将获得 Jack、Lori 和 Megan。第二个策略随机选取名称，每次会产生不一样的结果。在这种状况下，结果为 Andy 和 Megan。

策略模式很是适合复杂数据管理系统或数据处理系统，两者在数据筛选、搜索或处理的方式方面须要较高的灵活性。