共计 22872 个字符，预计需要花费 58 分钟才能阅读完成。
phpms 框架源码 https://github.com/wuxiumu/ms
一、PHP 常用的四种数据结构
简介：spl 是 php 的一个标准库。
官方文档：http://php.net/manual/zh/book…
<?php
//spl（php 标准库）数据结构
/**
* 栈（先进后出）
*/
function zan(){
$stack = new SplStack();
$stack->push(‘data1’);// 入栈（先进后出）
$stack->push(‘data2’);// 入栈
$stack->push(‘data3’);// 入栈
echo $stack->pop().PHP_EOL;// 出栈
echo $stack->pop().PHP_EOL;// 出栈
echo $stack->pop().PHP_EOL;// 出栈
}
/**
* 队列(先进先出）
*/
function duilie(){
$queue = new SplQueue();
$queue->enqueue(‘data4’);// 入队列
$queue->enqueue(‘data5’);// 入队列
$queue->enqueue(‘data6’);// 入队列
echo $queue->dequeue().PHP_EOL;// 出队列
echo $queue->dequeue().PHP_EOL;// 出队列
echo $queue->dequeue().PHP_EOL;// 出队列
}
/**
* 堆
*/
function dui(){
$heap = new SplMinHeap();
$heap->insert(‘data8’);// 入堆
$heap->insert(‘data9’);// 入堆
$heap->insert(‘data10’);// 入堆
echo $heap->extract().PHP_EOL;// 从堆中提取数据
echo $heap->extract().PHP_EOL;// 从堆中提取数据
echo $heap->extract().PHP_EOL;// 从堆中提取数据
}
/**
* 固定数组（不论使不使用，都会分配相应的内存空间）
*/
$array = new SplFixedArray(15);
$array[‘0’] = 54;
$array[‘6′] = 69;
$array[’10’] = 32;
var_dump($array);
二、PHP 链式操作的实现（原理）
1、入口文件
index.php
header(“content-type:text/html;charset=utf-8”);
define(‘PHPMSFRAME’,__DIR__);
define(‘CORE’,PHPMSFRAME.’/core’);
define(‘APP’,PHPMSFRAME.’/app’);
define(‘MODULE’,’app’);
define(‘DEBUG’,true);
include “vendor/autoload.php”;
if(DEBUG){
$whoops = new \Whoops\Run;
$whoops->pushHandler(new \Whoops\Handler\PrettyPageHandler);
$whoops->register();
ini_set(‘display_error’, ‘On’);
}else{
ini_set(‘display_error’, ‘Off’);
}
include CORE.’/common/function.php’;
include CORE.’/phpmsframe.php’;
spl_autoload_register(‘\core\phpmsframe::load’);
\core\phpmsframe::run();
2、自动加载类
corephpmsframe.php
<?php
namespace core;
class phpmsframe
{
public static $classMap = array();
public $assign;
static public function run()
{
$route = new \core\lib\route();
$ctrlClass = $route->ctrl;
$action = $route->action;
$ctrlfile = APP.’/ctrl/’.$ctrlClass.’Ctrl.php’;
$ctrlClass = ‘\\’.MODULE.’\ctrl\\’.$ctrlClass.’Ctrl’;
if(is_file($ctrlfile)){
include $ctrlfile;
$ctrl = new $ctrlClass();
$ctrl->$action();
}else{
$msg = “ 控制器 $ctrlClass 不存在 \n”;
self::reportingDog($msg);
}
}
static public function load($class)
{
if(isset($classMap[$class])){
return true;
}else{
$class = str_replace(‘\\’, ‘/’, $class);
$file = PHPMSFRAME.’/’.$class.’.php’;
if(is_file($file)){
include $file;
self::$classMap[$class] = $class;
}else{
return false;
}
}
}
public function assign($name,$value){
$this->assign[$name]=$value;
}
public function display($file){
$file_path = APP.’/views/’.$file;
if(is_file($file_path)){
/***********twig 模板 ***********/
$loader = new \Twig_Loader_Filesystem(APP.’/views’);
$twig = new \Twig_Environment($loader, array(
‘cache’ => PHPMSFRAME.’/cache’,
‘debug’=>DEBUG,
));
$template = $twig->load($file);
$template->display($this->assign?$this->assign:”);
/***********twig 模板 end***********/
/*********** 原生模板 ***********/
//extract($this->assign);
//include $file_path;
/*********** 原生模板 end***********/
}
}
static private function reportingDog($msg){
echo $msg.”\n”;
include ‘smile/havefun.php’;
$num = str_pad(rand(00,32),2,”0″,STR_PAD_LEFT);
$num = “str_”.$num;
$Parsedown = new \Parsedown();
echo $Parsedown->text($$num);
$num = “str_”.rand(50,84);
echo $Parsedown->text($$num);
exit;
}
}
3、数据库类
注：只是原理，并没有对方法进行具体的封装，具体的封装还是看个人喜好去定链式查询的风格。
corelibmodel.php
<?php
namespace core\lib;
use core\lib\drive\database\medooModel;
class model extends medooModel
{
}
corelibdrivedatabasemedooModel.php
<?php
/**
* 继承 medoo 第 3 方类库，模型基类
*/
namespace core\lib\drive\database;
use core\lib\conf;
use Medoo\Medoo;
class medooModel extends Medoo{
// 初始化，继承 pdo 应该是就可以直接用手册中的 pdo 中的方法了
public function __construct()
{
$option = conf::all(‘database’);
parent::__construct($option[‘mysql_medoo_conf’]);
}
}
三、PHP 魔术方法的使用
在 php 设计模式中，会涉及到很多魔术方法的使用，这里也对经常会用到的魔术方法进行简单总结。
1、框架入口文件
corephpmsframe.php
/**
* 魔术方法的使用
*/
/* 这是一个魔术方法，当一个对象或者类获取其不存在的属性的值时，
* 如：$obj = new BaseController ;
* $a = $obj -> a ;
* 该方法会被自动调用, 这样做很友好，可以避免系统报错
*/
public function __get($property_name){
$msg = “ 属性 $property_name 不存在 \n”;
self::reportingDog($msg);
}
/* 这是一个魔术方法，当一个对象或者类给其不存在的属性赋值时，
* 如：$obj = new BaseController ;
* $obj -> a = 12 ;
* 该方法 (__set(属性名, 属性值)) 会被自动调用, 这样做很友好，可以避免系统报错
*/
public function __set($property_name,$value){
$msg = “ 属性 $property_name 不存在 \n”;
self::reportingDog($msg);
}
/* 这是一个魔术方法，当一个对象或者类的不存在属性进行 isset()时，
* 注意：isset 用于检查一个量是否被赋值 如果为 NULL 会返回 false
* 如：$obj = new BaseController ;
* isset($obj -> a) ;
* 该方法会被自动调用, 这样做很友好，可以避免系统报错
*/
public function __isset($property_name){
$msg = “ 属性 $property_name 不存在 \n”;
self::reportingDog($msg);
}
/* 这是一个魔术方法，当一个对象或者类的不存在属性进行 unset()时，
* 注意：unset 用于释放一个变量所分配的内存空间
* 如：$obj = new BaseController ;
* unset($obj -> a) ;
* 该方法会被自动调用, 这样做很友好，可以避免系统报错
*/
public function __unset($property_name){
$msg = “ 属性 $property_name 不存在 \n”;
self::reportingDog($msg);
}
/* 当对这个类的对象的不存在的实例方法进行“调用”时，会自动调用该方法，
* 这个方法有 2 个参数（必须带有的）：
* $methodName 表示要调用的不存在的方法名;
* $argument 是一个数组，表示要调用该不存在的方法时，所使用的实参数据，
*/
public function __call($methodName,$argument){
$msg = “ 实例方法 $methodName 不存在 \n”;
self::reportingDog($msg);
}
四、三种基础设计模式
1、工厂模式
通过传入参数的不同，来实例化不同的类。
$cache =\Core\extend\CacheFactory::getCacheObj(‘redis’,array(
‘host’ => ‘127.0.0.1’,
‘pass’ => ‘myRedis&&&’
));
var_dump($cache);
coreextendCacheFactory.php
<?php
namespace core\extend;
class CacheFactory
{
const FILE = 1;
const MEMCACHE = 2;
const REDIS = 3;
static $instance;// 定义静态属性，用于存储对象
/**
* 工厂类创建缓存对象
* @param $type 指定缓存类型
* @param array $options 传入缓存参数
* @return FileCache|Memcache|RedisCache
*/
static function getCacheObj($type, array $options)
{
switch ($type) {
case ‘file’:
case self::FILE:
self::$instance = new FileCache($options);
break;
case ‘memcache’:
case self::MEMCACHE:
self::$instance = new Memcache($options);
break;
case ‘redis’:
case self::REDIS:
self::$instance = new RedisCache($options);
break;
default:
self::$instance = new FileCache($options);
break;
}
return self::$instance;
}
}
2、单例模式
保证一个类只实例化一个类对象，进而减少系统开销和资源的浪费
// 单例模式创建对象
$obj = Extend\SingleObject::getInstance();
$obj2 = Extend\SingleObject::getInstance();
var_dump($obj,$obj2);// 从结果可以看出，两个实例化的对象其实是一个对象
coreextendSingleObject.php
<?php
namespace core\extend;
class SingleObject
{
// 私有的静态属性，用于存储类对象
private static $instance = null;
// 私有的构造方法, 保证不允许在类外 new
private function __construct(){
}
// 私有的克隆方法, 确保不允许通过在类外 clone 来创建新对象
private function __clone(){
}
// 公有的静态方法，用来实例化唯一当前类对象
public static function getInstance()
{
if(is_null(self::$instance)){
self::$instance = new self;
}
return self::$instance;
}
}
3、注册树模式
将我们用到的对象注册到注册树上，然后在之后要用到这个对象的时候，直接从注册树上取下来就好。（就和我们用全局变量一样方便）
coreextendRegisterTree,php
<?php
namespace core\extend;
class RegisterTree
{
static protected $objects;// 静态类属性，用于储存注册到注册树上的对象
/**
* 将对象注册到注册树上
* @param $alias 对象的别名
* @param $object 对象
*/
static function setObject($alias,$object)
{
self::$objects[$alias] = $object;
}
/**
* 从注册树上取出给定别名相应的对象
* @param $alias 将对象插入到注册树上时写的别名
* @return mixed 对象
*/
static protected function getObject($alias)
{
return self::$objects[$alias];
}
/**
* 将对象从注册树上删除
* @param $alias 将对象插入到注册树上时写的别名
*/
public function unsetObject($alias)
{
unset(self::$objects[$alias]);
}
}
关于注册树模式，这里推荐一篇文章，可以方便理解。https://segmentfault.com/a/11…
五、其他常见的 8 种 PHP 设计模式
1、适配器模式
将一个类的接口转换成客户希望的另一个接口, 适配器模式使得原本的由于接口不兼容而不能一起工作的那些类可以一起工作。应用场景：老代码接口不适应新的接口需求，或者代码很多很乱不便于继续修改，或者使用第三方类库。
常见的有两种适配器，分别是类适配器和对象适配器，这里拿更看好的对象适配器举例：
<?php
namespace Extend;
/**
* 对象适配器模式具体流程
* 1、根据需求定义接口，进而满足新需求功能
* 2、定义新类，继承并实现定义的接口
* 3、在实现接口时，原有的功能，只通过原有类对象调用原有类功能（委托）
* 4、再根据需求，在新类中实现新需求功能
*【适用性】
*（1）你想使用一个已经存在的类，而它的接口不符合你的需求
*（2）你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类协同工作
*（3）你想使用一个已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口（仅限于对
*/
/**
* 目标角色（根据需求定义含有旧功能加上新功能的接口）
* Interface Target 我们期望得到的功能类
* @package Extend
*/
interface Target
{
public function simpleMethod1();
public function simpleMethod2();
}
/**
* 源角色（在新功能提出之前的旧功能类和方法）
* Class Adaptee
* @package Extend
*/
class Adaptee
{
public function simpleMethod1()
{
echo ‘Adapter simpleMethod1’.”<br>”;
}
}
/**
* 类适配器角色（新定义接口的具体实现）
* Class Adapter
* @package Extend
*/
class Adapter implements Target
{
private $adaptee;
function __construct()
{
// 适配器初始化直接 new 原功能类，以方便之后委派
$adaptee = new Adaptee();
$this->adaptee = $adaptee;
}
// 委派调用 Adaptee 的 sampleMethod1 方法
public function simpleMethod1()
{
echo $this->adaptee->simpleMethod1();
}
public function simpleMethod2()
{
echo ‘Adapter simpleMethod2’.”<br>”;
}
}
/**
* 客户端调用
*/
$adapter = new Adapter();
$adapter->simpleMethod1();
$adapter->simpleMethod2();
这篇文章介绍了类适配器的使用，感兴趣的可以了解一下 https://segmentfault.com/a/11…
2、策略模式
将一组特定的行为和算法封装成类，以适应某些特定的上下文环境，这种模式就是策略模式，策略模式可以实现依赖倒置以及控制反转。
实例举例：假如一个电商网站系统，针对男性女性用户要各自跳转到不同的商品类目，并且所有的广告位展示展示不同的广告。
<?php
/**
* 首页数据控制器
* Class Index
*/
class Home
{
/**
* 最好写上这个注释，告诉 phpstorm 是对应的哪个接口类，否则虽然程序执行正确，但 phpstorm 识别不了
* @var \Extend\UserType
*/
protected $userType;
/**
* 首页展示数据
* 使用策略模式
* Index constructor.
*/
function index()
{
echo “AD：”;
$this->userType->showAd();
echo “Category：”;
$this->userType->showCategory();
}
/**
* 策略模式
* 根据传递的用户性别展示不同类别数据
* @param \Extend\UserType $userType
*/
function setUserType(\Extend\UserType $userType)
{
$this->userType = $userType;
}
}
$obj = new Home();
if ($_GET[‘userType’] == ‘female’){
$userType = new \Extend\FemaleUserType();
} else {
$userType = new \Extend\MaleUserType();
}
$obj->setUserType($userType);
$obj->index();
Extend/userType.php（定义的接口）
<?php
namespace Extend;
/**
* 策略模式
* 定义根据性别不同展示不同商品类目和广告接口
* Interface UserType
* @package Extend
*/
interface UserType
{
// 显示广告
function showAd();
// 展示类目
function showCategory();
}
MaleUserType.php、FemaleUserType.php（具体实现的类）
<?php
namespace Extend;
/**
* 定义男性商品类目和广告位数据接口
* Class MaleUserType
* @package Extend
*/
class MaleUserType implements UserType
{
/**
* 广告栏数据展示
*/
function showAd()
{
echo “this is 男性’s 广告条目数据 ”;
}
/**
* 商品类目数据展示
*/
function showCategory()
{
echo “this is 男性’s 商品类目数据 ”;
}
}
<?php
namespace Extend;
/**
* 定义女性商品类目和广告位数据接口
* Class FemaleUserType
* @package Extend
*/
class FemaleUserType implements UserType
{
/**
* 广告栏数据展示
*/
function showAd()
{
echo “this is 女性’s 广告条目数据 ”;
}
/**
* 商品类目数据展示
*/
function showCategory()
{
echo “this is 女性’s 商品类目数据 ”;
}
}
3、数据对象映射模式
将对象和数据存储映射起来，对一个对象的操作会映射为对数据存储的操作。
下面在代码中实现数据对象映射模式，我们将实现一个 ORM 类，将复杂的 sql 语句映射成对象属性的操作。并结合使用数据对象映射模式、工厂模式、注册模式。
（1）数据库映射模式简单实例实现
<?php
// 使用数据对象映射模式代替写 sql
$user = new Extend\User(25);
$user->name = ‘ 小卜丢饭团子 ’;
$user->salary = ‘20000’;
$user->city = ‘ 浙江省 ’;
Extend/User.php
<?php
namespace Extend;
class User
{
// 对应数据库中的 4 个字段
public $id;
public $name;
public $salary;
public $city;
// 存储数据库连接对象属性
protected $pdo;
public $data;
function __construct($id)
{
$this->id = $id;
$this->pdo = new \PDO(‘mysql:host=127.0.0.1;dbname=test’,’root’,’123456′);
}
function __destruct()
{
$this->pdo->query(“update user set name = ‘{$this->name}’,salary = ‘{$this->salary}’,city = ‘{$this->city}’ where id='{$this->id}'”);
}
}
这样，执行 index.php 文件，数据库就会发生相应的操作，也就实现了基本的数据对象映射。
（2）数据库映射模式复杂案例实现
<?php
class EX
{
function index()
{
// 使用数据对象映射模式代替写 sql
$user = Extend\Factory::getUserObj(25);
$user->name = ‘ 小卜丢饭团子 ’;
$user->salary = ‘20000’;
$user->city = ‘ 浙江省 ’;
}
function test()
{
$user = Extend\Factory::getUserObj(25);
$user->city = ‘ 广东省 ’;
}
}
$ex = new EX();
$ex->index();
Extend/Factory.php
<?php
namespace Extend;
class Factory
{
/**
* 工厂模式创建数据库对象，单例模式保证创建唯一 db 对象
* @return mixed
*/
static function CreateDatabaseObj()
{
$db = Database::getInstance();
return $db;
}
/**
* 工厂模式创建 user 对象，注册树模式保证创建唯一对象，避免资源浪费
* @param $id
* @return User|mixed
*/
static function getUserObj($id)
{
$key = ‘user’.$id;
$user = RegisterTree::getObject($key);
if (!$user) {
$user = new User($id);
RegisterTree::setObject($key,$user);
}
return $user;
}
}
Extend/Register.php
<?php
namespace Extend;
/**
* 注册树模式
* Class RegisterTree
* @package Extend
*/
class RegisterTree
{
static protected $objects;// 静态类属性，用于储存注册到注册树上的对象
/**
* 将对象注册到注册树上
* @param $alias 对象的别名
* @param $object 对象
*/
static function setObject($alias,$object)
{
self::$objects[$alias] = $object;
}
/**
* 从注册树上取出给定别名相应的对象
* @param $alias 将对象插入到注册树上时写的别名
* @return mixed 对象
*/
static function getObject($alias)
{
return self::$objects[$alias];
}
/**
* 将对象从注册树上删除
* @param $alias 将对象插入到注册树上时写的别名
*/
public function unsetObject($alias)
{
unset(self::$objects[$alias]);
}
}
Extend/User.php
<?php
namespace Extend;
class User
{
// 对应数据库中的 4 个字段
public $id;
public $name;
public $salary;
public $city;
// 存储数据库连接对象属性
protected $pdo;
public $data;
function __construct($id)
{
$this->id = $id;
$this->pdo = new \PDO(‘mysql:host=127.0.0.1;dbname=test’,’root’,’123456′);
}
function __destruct()
{
$this->pdo->query(“update user set name = ‘{$this->name}’,salary = ‘{$this->salary}’,city = ‘{$this->city}’ where id='{$this->id}'”);
}
}
这样，就实现了稍复杂的数据对象映射模式和工厂模式、注册树模式相结合的案例。
4、观察者模式
当一个对象状态发生改变时，依赖它的对象会全部收到通知，并自动更新。
场景：一个事件发生后，要执行一连串更新操作。传统的编程方式就是在事件的代码之后直接加入处理逻辑，当更新的逻辑增多之后，代码会变的难以维护。这种方式是耦合的，侵入式的，增加新的逻辑需要修改事件主体的代码。观察者模式实现了低耦合，非侵入式的通知与更新机制。
4.1、传统模式举例：
<?php
/**
* 一个事件的逻辑控制器
* Class Event
*/
class Event
{
/**
* 用户确认订单
*/
function firmOrder()
{
// 这里假设一个事件发生了，比如用户已经完成下单
echo “ 用户已下单 <br>”;
// 传统方式是在发生一个事件之后直接进行一系列的相关处理，耦合度比较高，比如写入日志，给用户发邮件等等
echo “ 在用户下单之后进行的一系列操作 <br>”;
}
}
$event = new Event();
$event->firmOrder();
4.2、观察者模式典型实现方式：
（1）定义 2 个接口：观察者（通知）接口、被观察者（主题）接口
（2）定义 2 个类，观察者类实现观察者接口、被观察者类实现被观察者接口
（3）被观察者注册自己需要通知的观察者
（4）被观察者类某个业务逻辑发生时，通知观察者对象，进而每个观察者执行自己的业务逻辑。
代码示例：
<?php
/**
* 观察者模式场景描述：
* 1、购票后记录文本日志
* 2、购票后记录数据库日志
* 3、购票后发送短信
* 4、购票送抵扣卷、兑换卷、积分
* 5、其他各类活动等
*/
/**
* 观察者接口
*/
interface TicketObserver
{
function buyTicketOver($sender, $args); // 得到通知后调用的方法
}
/**
* 被观察者接口（购票主题接口）
*/
interface TicketObserved
{
function addObserver($observer); // 提供注册观察者方法
}
/**
* 主体逻辑，继承被观察者接口
* Class BuyTicket
*/
class BuyTicket implements TicketObserved
{
/**
* 定义观察者数组属性，用于储存观察者
* @var array
*/
private $observers = array();
/**
* 实现被观察者接口定义的方法（添加观察者）
* @param $observer 实例化后的观察者对象
*/
public function addObserver($observer)
{
$this->observers[] = $observer;
}
/**
* 购票主体方法
* BuyTicket constructor.
* @param $ticket 购票排号
*/
public function buyTicket($ticket)
{
//1、根据需求写购票逻辑
//…………..
//2、购票成功之后，循环通知观察者，并调用其 buyTicketOver 实现不同业务逻辑
foreach ($this->observers as $observe) {
$observe->buyTicketOver($this, $ticket); //$this 可用来获取主题类句柄，在通知中使用
}
}
}
/**
* 购票成功后，发送短信通知
* Class buyTicketMSN
*/
class buyTicketMSN implements TicketObserver
{
public function buyTicketOver($sender, $ticket)
{
echo (date ( ‘Y-m-d H:i:s’) . ” 短信日志记录：购票成功:$ticket<br>”);
}
}
/**
* 购票成功后，记录日志
* Class buyTicketLog
*/
class buyTicketLog implements TicketObserver
{
public function buyTicketOver($sender, $ticket)
{
echo (date ( ‘Y-m-d H:i:s’) . ” 文本日志记录：购票成功:$ticket<br>”);
}
}
/**
* 购票成功后，赠送优惠券
* Class buyTicketCoupon
*/
class buyTicketCoupon implements TicketObserver
{
public function buyTicketOver($sender, $ticket)
{
echo (date ( ‘Y-m-d H:i:s’) . ” 赠送优惠券：购票成功:$ticket 赠送 10 元优惠券 1 张。<br>”);
}
}
// 实例化购票类
$buy = new BuyTicket();
// 添加多个观察者
$buy->addObserver(new buyTicketMSN());
$buy->addObserver(new buyTicketLog());
$buy->addObserver(new buyTicketCoupon());
// 开始购票
$buy->buyTicket (“7 排 8 号 ”);
5、原型模式
原型模式与工厂模式的作用类似，都是用来创建对象的。但是实现方式是不同的。原型模式是先创建好一个原型对象，然后通过 clone 原型对象来创建新的对象。这样，就免去了类创建时重复的初始化操作。
原型模式适用于大对象的创建，创建一个大对象需要很大的开销，如果每次 new 就会消耗很大，原型模式仅需内存拷贝即可。
代码实例：
<?php
/**
* 抽象原型角色
*/
interface Prototype
{
public function copy();
}
/**
* 具体原型角色
*/
class ConcretePrototype implements Prototype
{
private $_name;
public function __construct($name)
{
$this->_name = $name;
}
public function setName($name)
{
$this->_name = $name;
}
public function getName()
{
return $this->_name;
}
public function copy()
{
// 深拷贝实现
//$serialize_obj = serialize($this); // 序列化
//$clone_obj = unserialize($serialize_obj); // 反序列化
//return $clone_obj;
// 浅拷贝实现
return clone $this;
}
}
/**
* 测试深拷贝用的引用类
*/
class Demo
{
public $array;
}
// 测试
$demo = new Demo();
$demo->array = array(1, 2);
$object1 = new ConcretePrototype($demo);
$object2 = $object1->copy();
var_dump($object1->getName());
echo ‘<br />’;
var_dump($object2->getName());
echo ‘<br />’;
$demo->array = array(3, 4);
var_dump($object1->getName());
echo ‘<br />’;
var_dump($object2->getName());
echo ‘<br />’;
关于原型模式文章：https://www.imooc.com/article…
6、装饰器模式
可以动态的添加或修改类的功能
一个类实现一个功能，如果要再修改或添加额外的功能，传统的编程模式需要写一个子类继承它，并重新实现类的方法。
使用装饰器模式，仅需在运行时添加一个装饰器对象即可实现，可以实现最大的灵活性。
<?php
/**
* 装饰器流程
* 1、声明装饰器接口（装饰器接口）
* 2、具体类继承并实现装饰器接口（颜色装饰器实现，字体大小装饰器实现）
* 3、在被装饰者类中定义 ” 添加装饰器 ” 方法（EchoText 类中的 addDecorator 方法）
* 4、在被装饰者类中定义调用装饰器的方法（EchoText 类中的 beforeEcho 和 afterEcho 方法）
* 5、使用时，实例化被装饰者类，并传入装饰器对象（比如 new ColorDecorator(‘yellow’))
*/
/**
* 装饰器接口
* Class Decorator
*/
interface Decorator
{
public function beforeEcho();
public function afterEcho();
}
/**
* 颜色装饰器实现
* Class ColorDecorator
*/
class ColorDecorator implements Decorator
{
protected $color;
public function __construct($color)
{
$this->color = $color;
}
public function beforeEcho()
{
echo “<dis style=’color: {$this->color}’>”;
}
public function afterEcho()
{
echo “</div>”;
}
}
/**
* 字体大小装饰器实现
* Class SizeDecorator
*/
class SizeDecorator implements Decorator
{
protected $size;
public function __construct($size)
{
$this->size = $size;
}
public function beforeEcho()
{
echo “<dis style=’font-size: {$this->size}px’>”;
}
public function afterEcho()
{
echo “</div>”;
}
}
/**
* 被装饰者
* 输出一个字符串
* 装饰器动态添加功能
* Class EchoText
*/
class EchoText
{
protected $decorators = array();// 存放装饰器
// 装饰方法
public function Index()
{
// 调用装饰器前置操作
$this->beforeEcho();
echo “ 你好，我是装饰器。”;
// 调用装饰器后置操作
$this->afterEcho();
}
// 添加装饰器
public function addDecorator(Decorator $decorator)
{
$this->decorators[] = $decorator;
}
// 执行装饰器前置操作 先进先出原则
protected function beforeEcho()
{
foreach ($this->decorators as $decorator)
$decorator->beforeEcho();
}
// 执行装饰器后置操作 先进后出原则
protected function afterEcho()
{
$tmp = array_reverse($this->decorators);
foreach ($tmp as $decorator)
$decorator->afterEcho();
}
}
// 实例化输出类
$echo = new EchoText();
// 增加装饰器
$echo->addDecorator(new ColorDecorator(‘yellow’));
// 增加装饰器
$echo->addDecorator(new SizeDecorator(’22’));
// 输出
$echo->Index();
7、迭代器模式
在不需要了解内部实现的前提下，遍历一个聚合对象的内部元素而又不暴露该对象的内部表示，这就是 PHP 迭代器模式的定义。
相对于传统编程模式，迭代器模式可以隐藏遍历元素的所需的操作。
<?php
$users = new Extend\AllUser();
// 循环遍历出所有用户数据
foreach ($users as $user) {
var_dump($user);
}
Extend/AllUser.php
<?php
namespace Extend;
/**
* 迭代器模式，继承 php 内部自带的迭代器接口（\Iterator）
* Class AllUser
* @package Extend
*/
class AllUser implements \Iterator
{
protected $index = 0;// 表示索引
protected $ids = array();// 用于储存所有 user 的 id（实际应用中，可以采用注册树模式进行存储）
protected $pdo;// 用于存储数据库对象
function __construct()
{
// 获取 pdo 数据库对象
$this->pdo = new \PDO(‘mysql:host=127.0.0.1;dbname=test’,’root’,’123456′);
// 获取所有用户的 id
$this->ids = $this->pdo->query(“select id from user”)->fetchAll(2);
}
/**
* 实现接口方法，重置迭代器，回到集合开头
*/
public function rewind()
{
$this->index = 0;
}
/**
* 实现接口方法，获取当前元素
* @return mixed|void
*/
public function current()
{
$id = $this->ids[$this->index][‘id’];
// 获取当前用户的数据
$user_data = $this->pdo->query(“select * from user where id='{$id}'”)->fetch(2);
return $user_data;
}
/**
* 实现接口方法，获取当前元素键值
* @return mixed|void
*/
public function key()
{
return $this->index;
}
/**
* 实现接口方法，获取下一个元素
*/
public function next()
{
$this->index++;
}
/**
* 实现接口方法，验证是否还有下一个元素
* @return bool|void
*/
public function valid()
{
return $this->index < count($this->ids);
}
}
关于 php 迭代器文章 http://www.php.cn/php-weiziji…
8、代理模式
在客户端与实体之间建立一个代理对象（proxy），客户端对实体进行操作全部委派给代理对象，隐藏实体的具体实现细节。
典型的应用就是 mysql 的主从结构，读写分离。在 mysql 中，对所有读的操作请求从库，所有写的操作请求主库。
声明一个代理类，前台使用时只需创建一个代理类，调用对应方法即可。代码实例：
<?php
// 1、传统编程模式是手动选择
#查询操作使用从库
//$db_slave = Extend\Factory::getDatabase(‘slave’);
//$info = $db_slave->query(“select * from user where id = 1 limit 1”);
#增删改操作使用主库
//$db_master = Extend\Factory::getDatabase(‘master’);
//$db_master->query(“update user name = ‘xiaobudiu’ where id = 29 limit 1”);
// 2、使用代理模式
$db_proxy = new Extend\Proxy();
$db_proxy->getUserName(1);
$db_proxy->setUserName(29,’xiaobudiu’);
Extend/Proxy.php
<?php
namespace Extend;
class Proxy implements IUserProxy
{
function getUserName($id)
{
$db = Factory::getDatabase(‘slave’);
$db->query(“select name from user where id =$id limit 1”);
}
function setUserName($id, $name)
{
$db = Factory::getDatabase(‘master’);
$db->query(“update user set name = $name where id =$id limit 1″);
}
}
Extend/Factory.php
<?php
namespace Extend;
class Factory
{
static function getDatabase($id)
{
$key = ‘database_’.$id;
if ($id == ‘slave’)
{
$slaves = Application::getInstance()->config[‘database’][‘slave’];
$db_conf = $slaves[array_rand($slaves)];
} else {
$db_conf = Application::getInstance()->config[‘database’][$id];
}
// 注册树模式存储及获取对象
$db = Register::get($key);
if (!$db) {
$db = new Database\MySQLi();
$db->connect($db_conf[‘host’], $db_conf[‘user’], $db_conf[‘password’], $db_conf[‘dbname’]);
Register::set($key, $db);
}
return $db;
}
}
Extend/Application.php
<?php
namespace Extend;
class Application
{
public $base_dir;
protected static $instance;
public $config;
protected function __construct($base_dir)
{
$this->base_dir = $base_dir;
$this->config = new Config($base_dir.’/configs’);
}
static function getInstance($base_dir = ”)
{
if (empty(self::$instance))
{
self::$instance = new self($base_dir);
}
return self::$instance;
}
}
Extend/Config.php
<?php
namespace Extend;
/**
* 配置类，继承于 php 自带的 ArrayAccess 接口
* 允许一个对象以数组的方式访问
* Class Config
* @package Extend
*/
class Config implements \ArrayAccess
{
protected $path;
protected $configs = array();
function __construct($path)
{
$this->path = $path;
}
function offsetGet($key)
{
if (empty($this->configs[$key]))
{
$file_path = $this->path.’/’.$key.’.php’;
$config = require $file_path;
$this->configs[$key] = $config;
}
return $this->configs[$key];
}
function offsetSet($key, $value)
{
throw new \Exception(“cannot write config file.”);
}
function offsetExists($key)
{
return isset($this->configs[$key]);
}
function offsetUnset($key)
{
unset($this->configs[$key]);
}
}
configs/database.php
<?php
$config = array(
‘master’ => array(
‘type’ => ‘MySQL’,
‘host’ => ‘127.0.0.1’,
‘user’ => ‘root’,
‘password’ => ‘123456’,
‘dbname’ => ‘test’,
),
‘slave’ => array(
‘slave1’ => array(
‘type’ => ‘MySQL’,
‘host’ => ‘127.0.0.1’,
‘user’ => ‘root’,
‘password’ => ‘123456’,
‘dbname’ => ‘test’,
),
‘slave2’ => array(
‘type’ => ‘MySQL’,
‘host’ => ‘127.0.0.1’,
‘user’ => ‘root’,
‘password’ => ‘123456’,
‘dbname’ => ‘test’,
),
),
);
return $config;
关于 php 代理模式文章 https://segmentfault.com/a/11…
五、其余设计模式以及总结
文章接：
https://segmentfault.com/a/11…
https://segmentfault.com/a/11…
六、面向对象编程的基本原则
1、单一职责原则：一个类只需要做好一件事情。不要使用一个类完成很多功能，而应该拆分成更多更小的类。
2、开放封闭原则：一个类写好之后，应该是可扩展而不可修改的。
3、依赖倒置原则：一个类不应该强依赖另外一个类，每个类对于另外一个类都是可替换的。
4、配置化原则：尽量使用配置，而不是硬编码。
5、面向接口编程原则：只需要关心某个类提供了哪些接口，而不需要关心他的实现。
七、自动加载配置类文件
1、php 中使用 ArrayAccess 实现配置文件的加载（使得程序可以以数组的方式进行读取配置）
（1）定义 Config.php，继承 php 自带的 ArrayAccess 接口，并实现相应的方法，用于读取和设置配置
Extend/Config.php
<?php
namespace Extend;
/**
* 配置类，继承于 php 自带的 ArrayAccess 接口
* 允许一个对象以数组的方式访问
* Class Config
* @package Extend
*/
class Config implements \ArrayAccess
{
protected $path;
protected $configs = array();
function __construct($path)
{
$this->path = $path;
}
function offsetGet($key)
{
if (empty($this->configs[$key]))
{
$file_path = $this->path.’/’.$key.’.php’;
$config = require $file_path;
$this->configs[$key] = $config;
}
return $this->configs[$key];
}
function offsetSet($key, $value)
{
throw new \Exception(“cannot write config file.”);
}
function offsetExists($key)
{
return isset($this->configs[$key]);
}
function offsetUnset($key)
{
unset($this->configs[$key]);
}
}
（2）configs/database.php
<?php
$config = array(
‘master’ => array(
‘type’ => ‘MySQL’,
‘host’ => ‘127.0.0.1’,
‘user’ => ‘root’,
‘password’ => ‘123456’,
‘dbname’ => ‘test’,
),
‘slave’ => array(
‘slave1’ => array(
‘type’ => ‘MySQL’,
‘host’ => ‘127.0.0.1’,
‘user’ => ‘root’,
‘password’ => ‘123456’,
‘dbname’ => ‘test’,
),
‘slave2’ => array(
‘type’ => ‘MySQL’,
‘host’ => ‘127.0.0.1’,
‘user’ => ‘root’,
‘password’ => ‘123456’,
‘dbname’ => ‘test’,
),
),
);
return $config;
（3）读取配置
<?php
$config = new Extend\Config(__DIR__.’/configs’);
var_dump($config[‘database’]);
到此，就可以在程序中随心所欲的加载配置文件了。
2、在工厂方法中读取配置，生成可配置化的对象
Extend/Factory.php
<?php
namespace Extend;
class Factory
{
static function getDatabase($id)
{
$key = ‘database_’.$id;
if ($id == ‘slave’)
{
$slaves = Application::getInstance()->config[‘database’][‘slave’];
$db_conf = $slaves[array_rand($slaves)];
} else {
$db_conf = Application::getInstance()->config[‘database’][$id];
}
// 注册树模式存储及获取对象
$db = Register::get($key);
if (!$db) {
$db = new Database\MySQLi();
$db->connect($db_conf[‘host’], $db_conf[‘user’], $db_conf[‘password’], $db_conf[‘dbname’]);
Register::set($key, $db);
}
return $db;
}
}
Extend/Application.php
<?php
namespace Extend;
class Application
{
public $base_dir;
protected static $instance;
public $config;
protected function __construct($base_dir)
{
$this->base_dir = $base_dir;
$this->config = new Config($base_dir.’/configs’);
}
static function getInstance($base_dir = ”)
{
if (empty(self::$instance))
{
self::$instance = new self($base_dir);
}
return self::$instance;
}
}
Extend/Config.php
<?php
namespace Extend;
/**
* 配置类，继承于 php 自带的 ArrayAccess 接口
* 允许一个对象以数组的方式访问
* Class Config
* @package Extend
*/
class Config implements \ArrayAccess
{
protected $path;
protected $configs = array();
function __construct($path)
{
$this->path = $path;
}
function offsetGet($key)
{
if (empty($this->configs[$key]))
{
$file_path = $this->path.’/’.$key.’.php’;
$config = require $file_path;
$this->configs[$key] = $config;
}
return $this->configs[$key];
}
function offsetSet($key, $value)
{
throw new \Exception(“cannot write config file.”);
}
function offsetExists($key)
{
return isset($this->configs[$key]);
}
function offsetUnset($key)
{
unset($this->configs[$key]);
}
}
