单例模式
所谓单例模式，就是确保某个类只有一个实例，而且自行实例化并向整个系统提供这个实例，即在应用程序中只会有这个类的一个实例存在。
通常单例模式用在仅允许数据库访问对象的实例中，从而防止打开多个数据库连接，单例模式是一种常见的设计模式，在计算机系统中，线程池、缓存、日志对象、对话框、打印机、数据库操作、显卡的驱动程序常被设计成单例。
一个单例类应包括以下几点：
和普通类不同，单例类不能被直接实例化，只能是由自身实例化。因此，要获得这样的限制效果，构造函数必须标记为private。
要让单例类不被直接实例化而能起到作用，就必须为其提供这样的一个实例。因此，就必须要让单例类拥有一个能保存类的实例的私有静态成员变量和对应的一个能访问到实例的公共静态方法。
在PHP中，为防止对单例类对象的克隆来打破单例类的上述实现形式，通常还为基提供一个空的私有__clone()方法。好吧，废话不多说，概括如下
单例模式有以下3个特点：
1．只能有一个实例,必须拥有一个构造函数，并且必须被标记为private
2．必须自行创建这个实例，拥有一个保存类的实例的静态成员变量
3．必须给其他对象提供这一实例，拥有一个访问这个实例的公共的静态方法
单例类不能再其它类中直接实例化，只能被其自身实例化。它不会创建实例副本，而是会向单例类内部存储的实例返回一个引用
那么为什么要使用PHP单例模式？
PHP一个主要应用场合就是应用程序与数据库打交道的场景，在一个应用中会存在大量的数据库操作，针对数据库句柄连接数据库的行为，使用单例模式可以避免大量的new操作。因为每一次new操作都会消耗系统和内存的资源。
单例模式恰恰是对全局变量的一种改进，避免那些存储唯一实例的全局变量污染命名空间。你无法用错误类型的数据覆写一个单例。这种保护在不支持命名空间的PHP版本里尤其重要。因为在PHP中命名冲突会在编译时被捕获，并使脚本停止运行。
下面是单例模式的代码：
<?php
class Single {
private $name; // 声明一个私有的实例变量
private function __construct(){
// 声明私有构造方法为了防止外部代码使用new来创建对象。
}
static public $instance; // 声明一个静态变量（保存在类中唯一的一个实例）
static public function instance(){
// 声明一个getinstance()静态方法，用于检测是否有实例对象
if(!self::$instance) self::$instance = new self();
return self::$instance;
}
public function setname($n){
$this->name = $n;
}
public function getname(){
return $this->name;
}
}
$oa = Single::instance();
$ob = Single::instance();
$oa->setname('hello world');
$ob->setname('good morning');
echo $oa->getname(); //good morning
echo $ob->getname(); //good morning
单例模式的优缺点：
优点：
- 改进系统的设计
- 是对全局变量的一种改进
缺点：
- 难于调试
- 隐藏的依赖关系
- 无法用错误类型的数据覆写一个单例
工厂模式
工厂模式就是一种类，是指包含一个专门用来创建其他对象的方法的类，工厂类在多态性编程实践中是至关重要的，它允许动态的替换类，修改配置，通常会使应用程序更加灵活，熟练掌握工厂模式高级PHP开发人员是很重要的。
工厂模式通常用来返回符合类似接口的不同的类，工厂的一种常见用法就是创建多态的提供者，从而允许我们基于应用程序逻辑或者配置设置来决定应实例化哪一个类，例如，可以使用这样的提供者来扩展一个类，而不需要重构应用程序的其他部分，从而使用新的扩展后的名称 。
通常，工厂模式有一个关键的构造，根据一般原则命名为Factory的静态方法，然而这只是一种原则，工厂方法可以任意命名，这个静态还可以接受任意数据的参数，必须返回一个对象。
具有为您创建对象的某些方法，这样就可以使用工厂类创建对象，工厂模式在于可以根据输入参数或者应用程序配置的不同来创建一种专门用来实现化并返回其它类的实例的类，而不直接使用new，这样如果想更改创建的对象类型，只需更改该工厂即可，
先举个示例吧：
<?php
class Factory { // 创建一个基本的工厂类
static public function fac($id){ // 创建一个返回对象实例的静态方法
if(1 == $id) return new A();
elseif(2==$id) return new B();
elseif(3==$id) return new C();
return new D();
}
}
interface FetchName { // 创建一个接口
public function getname();
}
class A implements FetchName{
private $name = "AAAAA";
public function getname(){ return $this->name; }
}
class C implements FetchName{
private $name = "CCCCC";
public function getname(){ return $this->name; }
}
class B implements FetchName{
private $name = "BBBBB";
public function getname(){ return $this->name; }
}
class D implements FetchName{
private $name = "DDDDD";
public function getname(){ return $this->name; }
}
$o = Factory::fac(6); // 调用工厂类中的方法
if($o instanceof FetchName){
echo $o->getname(); // DDDDD
}
$p=Factory::fac(3);
echo $p->getname(); // CCCCC
策略模式
策略模式是对象的行为模式，用意是对一组算法的封装。动态的选择需要的算法并使用。
策略模式指的是程序中涉及决策控制的一种模式。策略模式功能非常强大，因为这个设计模式本身的核心思想就是面向对象编程的多形性思想。
策略模式的三个角色：
1．抽象策略角色
2．具体策略角色
3．环境角色（对抽象策略角色的引用）
实现步骤：
1．定义抽象角色类（定义好各个实现的共同抽象方法）
2．定义具体策略类（具体实现父类的共同方法）
3．定义环境角色类（私有化申明抽象角色变量，重载构造方法，执行抽象方法）
就在编程领域之外，有许多例子是关于策略模式的。例如：
如果我需要在早晨从家里出发去上班，我可以有几个策略考虑：我可以乘坐地铁，乘坐公交车，走路或其它的途径。每个策略可以得到相同的结果，但是使用了不同的资源。
策略模式的代码实例：
<?php
abstract class baseAgent { //抽象策略类
abstract function PrintPage();
}
//用于客户端是IE时调用的类（环境角色）
class ieAgent extends baseAgent {
function PrintPage() {
return 'IE';
}
}
//用于客户端不是IE时调用的类（环境角色）
class otherAgent extends baseAgent {
function PrintPage() {
return 'not IE';
}
}
class Browser { //具体策略角色
public function call($object) {
return $object->PrintPage ();
}
}
$bro = new Browser ();
echo $bro->call ( new ieAgent () );
注册模式
注册模式，解决全局共享和交换对象。已经创建好的对象，挂在到某个全局可以使用的数组上，在需要使用的时候，直接从该数组上获取即可。将对象注册到全局的树上。任何地方直接去访问。
<?php
class Register
{
protected static $objects;
function set($alias, $object) // 将对象注册到全局的树上
{
self::$objects[$alias]=$object;//将对象放到树上
}
static function get($name){
return self::$objects[$name];//获取某个注册到树上的对象
}
function _unset($alias)
{
unset(self::$objects[$alias]);//移除某个注册到树上的对象。
}
}
适配器模式
将各种截然不同的函数接口封装成统一的API。
PHP中的数据库操作有MySQL,MySQLi,PDO三种，可以用适配器模式统一成一致，使不同的数据库操作，统一成一样的API。类似的场景还有cache适配器，可以将memcache,redis,file,apc等不同的缓存函数，统一成一致。
首先定义一个接口(有几个方法，以及相应的参数)。然后，有几种不同的情况，就写几个类实现该接口。将完成相似功能的函数，统一成一致的方法。
<?php
namespace IMooc;
interface IDatabase
{
function connect($host, $user, $passwd, $dbname);
function query($sql);
function close();
}
MYSQL
<?php
namespace IMooc\Database;
use IMooc\IDatabase;
class MySQL implements IDatabase
{
protected $conn;
function connect($host, $user, $passwd, $dbname)
{
$conn = mysql_connect($host, $user, $passwd);
mysql_select_db($dbname, $conn);
$this->conn = $conn;
}
function query($sql)
{
$res = mysql_query($sql, $this->conn);
return $res;
}
function close()
{
mysql_close($this->conn);
}
}
MYSQLI
<?php
namespace IMooc\Database;
use IMooc\IDatabase;
class MySQLi implements IDatabase
{
protected $conn;
function connect($host, $user, $passwd, $dbname)
{
$conn = mysqli_connect($host, $user, $passwd, $dbname);
$this->conn = $conn;
}
function query($sql)
{
return mysqli_query($this->conn, $sql);
}
function close()
{
mysqli_close($this->conn);
}
}
观察者模式
1：观察者模式(Observer)，当一个对象状态发生变化时，依赖它的对象全部会收到通知，并自动更新。
2：场景:一个事件发生后，要执行一连串更新操作。传统的编程方式，就是在事件的代码之后直接加入处理的逻辑。当更新的逻辑增多之后，代码会变得难以维护。这种方式是耦合的，侵入式的，增加新的逻辑需要修改事件的主体代码。
3：观察者模式实现了低耦合，非侵入式的通知与更新机制。
定义一个事件触发抽象类。
EventGenerator.php
<?php
require_once 'Loader.php';
abstract class EventGenerator{
private $observers = array();
function addObserver(Observer $observer){
$this->observers[]=$observer;
}
function notify(){
foreach ($this->observers as $observer){
$observer->update();
}
}
}
定义一个观察者接口 Observer.php
<?php
require_once 'Loader.php';
interface Observer{
function update();//这里就是在事件发生后要执行的逻辑
}
//一个实现了EventGenerator抽象类的类，用于具体定义某个发生的事件
实现：
require 'Loader.php';
class Event extends EventGenerator{
function triger(){
echo "Event<br>";
}
}
class Observer1 implements Observer{
function update(){
echo "逻辑1<br>";
}
}
class Observer2 implements Observer{
function update(){
echo "逻辑2<br>";
}
}
$event = new Event();
$event->addObserver(new Observer1());
$event->addObserver(new Observer2());
$event->triger();
$event->notify();
