php常用的设计模式：
1、单例模式（构造方法私有化，对外提供实例化对象的静态调用方法）
class Site
{
public $siteName;
public static $instance = null;
private function __construct($siteName)
{
$this->siteName = $siteName;
}
// 实例化本类
public static function getInstance($siteName='gongxulei.cn')
{
// 判断当前的静态属性是不是当前类的实例，如果不是则创建它
if(!self::$instance instanceof self){
self::$instance = new self($siteName);
}
return self::$instance;
}
}
2、工厂模式（创建单例模式的实例）
class Factory
{
public static function create()
{
return Site::getInstance('gongxulei.cn');
}
}
3、注册树模式（用于存储对象的对象池。get、set、destroy对象）
/**
* Class Register
* 1. 注册：set()，将对象添加到对象池中
* 2. 获取：get()，从对象池中获取对象
* 3. 注销：_unset()，从对象池中释放对象
*/
class Register
{
// 创建对象池：数组
protected static $objects = [];
public static function set($alias,$object){
self::$objects[$alias] = $object;
}
public static function get($alias){
return self::$objects[$alias];
}
public static function _unset($alias){
unset(self::$objects[$alias]);
}
}
在PHP框架laravel、thinkphp中使用的container容器技术就是使用了以上三种模式，通过以上三种模式可以实现对已实例化的对象的复用，并防止重复的实例化。
4、适配器模式：将各种截然不同的函数接口封装成统一的API。
如：对于不同类型的数据库，框架一般都会封装成统一调用的api。
<?php
interface Cache
{
function connect($host, $user, $passwd, $dbname);
function set($key, $value);
function get($key);
}
class redisCache implements Cache
{
public function connect($host, $user, $passwd, $dbname)
{
}
public function set()
{
}
public function get()
{
}
}
class memCache implements Cache
{
public function connect($host, $user, $passwd, $dbname)
{
}
public function set()
{
}
public function get()
{
}
}
?>
5、策略模式：将一组特定的行为和算法封装成类，以适应某些特定的上下文环境。
例如：对于传统编程中，如果apple跟pear都有相同的价格列表、价格详情两个页面，那么会在控制器中进行类型判断，然后获取价格apple的列表，pear的价格列表，随着类型增多价格列表方法中增加的逻辑代码就会越来越多，代码的耦合度也会越高。
如果使用策略模式进行编程，控制器中只需要判断是那种类型然后实例化不同的策略类，如果新增一个类型，那只需要新增一个策略即可，大大降低代码的耦合度，方便后期维护
<?php
namespace app\test\strategy;
interface PriceStrategy
{
public function priceList();
public function priceDetail();
}
<?php
namespace app\test\classfiy;
use app\test\strategy\PriceStrategy;
class Apple implements PriceStrategy
{
public function priceList($param = [])
{
return "这是apple的价格列表";
}
public function priceDetail()
{
return "这是apple的价格详情";
}
}
<?php
namespace app\test\classfiy;
use app\test\strategy\PriceStrategy;
class Pear implements PriceStrategy
{
public function priceList($param = [])
{
return "这是Pear的价格列表";
}
public function priceDetail()
{
return "这是Pear的价格详情";
}
}
<?php
namespace app\test\controller;
use app\test\classfiy\Apple;
use app\test\classfiy\Pear;
use think\Request;
class PriceController
{
public function priceListAction(Request $request)
{
$param = $request->param();
$type = $param['type'] ?: 'apple';
switch ($type) {
case 'apple':
$strategy = new Apple();
break;
case 'pear':
$strategy = new Pear();
break;
default:
$strategy = new Apple();
break;
}
$info = $strategy->priceList($param);
echo $info;
}
public function priceDetailAction(Request $request)
{
$param = $request->param();
$type = $param['type'] ?: 'apple';
switch ($type) {
case 'apple':
$strategy = new Apple();
break;
case 'pear':
$strategy = new Pear();
break;
default:
$strategy = new Apple();
break;
}
$info = $strategy->priceDetail($param);
echo $info;
}
}
6、观察者模式：定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。
class Event
{
private $observerList = [];
public function addObserver( $alias = "", Observer $observer)
{
if (empty($alias)) {
$alias = get_class($observer);
}
$this->observerList[$alias] = $observer;
}
private function notify($alias, $param = [])
{
foreach ($this->observerList as $event => $observer)
{
if ($event == $alias) {
$res = $observer->handle($param);
}
}
return $res;
}
public function trigger($alias, $param = [])
{
return $this->notify($alias, $param);
}
}
interface Observer
{
public function handle($param);
}
class abserverOne implements Observer
{
public function handle($param)
{
return "abserverOne收到通知，去更新了价格\r\n";
}
}
class abserverTwo implements Observer
{
public function handle($param)
{
return "abserverTwo收到通知，去新增了redis队列数据";
}
}
$event = new Event();
$event->addObserver('', (new abserverOne()));
$event->addObserver('', (new abserverTwo()));
echo $event->trigger('abserverOne');
echo $event->trigger('abserverTwo');
7、装饰器模式：装饰器模式可以动态的添加修改类的功能，抽象类提供了一项功能，如果要在修改并添加额外的功能，传统的编程是写一个子类去继承它，并重新实现类的方法，使用装饰器模式，仅需在运行时添加一个装饰器对象即可实现，可以实现最大的灵活性
<?php
abstract class Beverage
{
public $_name;
abstract public function Cost();
}
class Coffee extends Beverage
{
public function __construct()
{
$this->_name = 'Coffee';
}
public function Cost()
{
return 1.00;
}
}
class CondimentDecorator extends Beverage
{
public function __construct()
{
$this->_name = 'Condiment';
}
public function Cost()
{
return 0.1;
}
}
class Milk extends CondimentDecorator
{
public $_beverage;
public function __construct($beverage)
{
if ($beverage instanceof Beverage) {
$this->_name = $beverage->_name . '+Milk';
$this->_beverage = $beverage;
} else {
exit('Failure');
}
}
public function Cost()
{
return $this->_beverage->Cost() + 0.5;
}
}
class Sugar extends CondimentDecorator
{
public $_beverage;
public function __construct($beverage)
{
if ($beverage instanceof Beverage) {
$this->_name = $beverage->_name . '+Sugar';
$this->_beverage = $beverage;
} else {
exit('Failure');
}
}
public function Cost()
{
return $this->_beverage->Cost() + 0.2;
}
}
$coffee = new Coffee();
$milk = new Milk($coffee);
echo $milk->_name;
echo $milk->Cost();
echo "\r\n";
$sugar = new Sugar($coffee);
echo $sugar->_name;
echo $sugar->Cost();
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)
