php常见设计模式

常见设计模式

1.策略模式（使用场景：多种渠道发短信）
2.工厂模式（使用场景：多种支付方式）
3.单列模式（使用场景：日志，db查询类）
4.注册模式（使用场景: laravel 容器）
5.适配器模式 （使用场景：mysql类，兼容mysqli和pdo）
6.观察者模式

各种模式详细说明

1.策略模式

策略模式是对象的行为模式，用意是对一组算法的封装。动态的选择需要的算法并使用。
策略模式指的是程序中涉及决策控制的一种模式。策略模式功能非常强大，因为这个设计模式本身的核心思想就是面
向对象编程的多态性思想。
策略模式的三个角色：
1．抽象策略角色
2．具体策略角色
3．环境角色（对抽象策略角色的引用）
实现步骤：
1．定义抽象角色类（定义好各个实现的共同抽象方法）
2．定义具体策略类（具体实现父类的共同方法）
3．定义环境角色类（私有化申明抽象角色变量，重载构造方法，执行抽象方法）
就在编程领域之外，有许多例子是关于策略模式的。例如：
如果我需要在早晨从家里出发去上班，我可以有几个策略考虑：我可以乘坐地铁，乘坐公交车，走路或其它的途径。
每个策略可以得到相同的结果，但是使用了不同的资源。

代码 demo（多种短信渠道发送短信） ：

abstract class baseAgent
{
	abstract function SendInfo($message);
}


//===2.定义具体策略类（具体实现父类的共同的方法）============================
//阿里大鱼发送短信- 具体策略类
class Alidy extends baseAgent
{
	function SendInfo($message)
	{
		return "阿里大鱼发送:".$message."
";
	}
}

//网易云发送短信- 具体策略类
class Wangyi extends baseAgent
{
	function SendInfo($message)
	{
		return "网易云发送短信:".$message."
";
	}
}

//腾讯发送短信- 具体策略类
class Tengxun extends baseAgent
{
	function SendInfo($message)
	{
		return "腾讯发送短信:".$message."
";
	}
}



//===3.定义环境角色类============================
//定义环境角色 - 环境角色
class SendTool
{
	public function call($object,$message)
	{
		return $object->SendInfo($message);
	}
}


$sendTool=new SendTool();
echo $sendTool->call(new Alidy(),"11111");

echo $sendTool->call(new Wangyi(),"22222");

echo $sendTool->call(new Tengxun(),"3333");

2.工厂模式

建立一个工厂（一个函数或一个类方法）来制造新的对象
工厂模式 是一种类，它具有为您创建对象的某些方法。您可以使用工厂类创建对象，而不直接使用 new。这样，如
果您想要更改所创建的对象类型，只需更改该工厂即可。使用该工厂的所有代码会自动更改。

代码 demo（多种支付方式） ：

/**
 * 简单工厂模式
 * 支付方式
 */
interface payway
{
    #统一下单操作
    public function payorder();
}

/**
 * 支付宝支付 实现 payway支付类
 */
class Alipay implements payway
{
    //具体实现统一下单操作
    public function payorder()
    {
        echo "阿里支付
";
    }
}


/**
 * 微信支付 实现 payway类
 */
class Wechat implements payway
{
    //具体实现统一下单操作
    public function payorder()
    {
        echo "微信支付
";
    }
}


/**
 * 招行支付 实现支付类
 */
class Cmb implements payway
{
    //具体实现统一下单操作
    public function payorder()
    {
        echo "招行支付
";
    }
}


/**
 * 支付工厂类
 */
class PaywayFactory
{
    //简单工厂里面的静态方法用于创建支付宝对象
    static function createAlipay()
    {
        return new Alipay();
    }

    //简单工厂里面的静态方法用于创建微信支付对象
    static function createWechat()
    {
        return new Wechat();
    }

    //简单工厂里面的静态方法用于创建招行支付
    static function createCmd()
    {
        return new Cmb();
    }
}


//具体条用
$alipay=PaywayFactory::createAlipay();
$alipay->payorder();

$wechat=PaywayFactory::createWechat();
$alipay->payorder();

$cmb=PaywayFactory::createCmd();
$cmb->payorder();

3.单列模式

单例模式确保某个类只有一个实例，而且自行实例化并向整个系统提供整个实例
单例模式是一种常见的设计模式，在计算机系统中,线程池、缓存、日志对象、对话框、打印机、数据库操作、显卡的驱动程序常被设计成单列

单例模式分3种：懒汉式单例、饿汉式单例、登记式单例

单例模式有以下3个特点：
1.只能有一个实例
2.必须自行创建这个实例
3.必须给其它对象提供这个实例

为什么使用单例模式？
php一个主要应用场合就是应用程序与数据库打交道的场景，在一个应用中会存在大量的数据操作，针对数据库句柄链接数据库的行为，使用单例模式可以避免大量的new操作。因为每一次操作都会消耗系统和内存资源

代码 demo ：

class Single
{
    #声明一个静态变量，保存类中唯一的一个实例
    static private $instance;

    #私有化构造函数,放置外部代码使用new来创建对象
    private function __construct()
    {
    }

    #私有化克隆方法，防止克隆
    private function __clone()
    {
    }

    #声明一个静态方法，用于检测是否有实例对象
    static public function getinstance()
    {
        if (!self::$instance instanceof self) {
            self::$instance = new self();
        }
        return self::$instance;
    }

    private $name;//声明一个私有的实例变量

    public function setname($n)
    {
        $this->name = $n;
    }

    public function getname()
    {
        return $this->name;
    }
}

$oa = Single::getinstance();
$ob = Single::getinstance();

$oa->setname('hello world');
$ob->setname('good morning');
echo $oa->getname();//good morning
echo "
";
echo $ob->getname();//good morning

4.注册模式

注册模式，解决全局共享和交换对象，已经穿件好的对象，挂在狗哥全局可以使用的数组上，在需要的时候，直接从该数组上获取即可。
将对象注册到全局树上，任何地方直接去访问、

主要使用场景：laravel的 容器，就是将需要使用的对象注册到容器中，容器对对象进行管理

代码 demo （容器）：

class Register
{
    //存放所有管理的对象
    protected static $objects;

    //将对象注册到全局树上
    public function setObject($alias,$object)
    {
        //将对象放到树上
        self::$objects[$alias]=$object;
    }

    //通过指定的key获取对象
    static public function getObject($alias)
    {
        return self::$objects[$alias];
    }
    
    //移除某个注册到树上的对象
    public function _unset($alias)
    {
        unset(self::$objects[$alias]);
    }

    //获取容器管理的所有对象
    static public function getAllObjects()
    {
        return self::$objects;
    }
}

class A
{
    public function ceshi()
    {
        echo "cesha
";
    }
}

class B
{
    public function ceshi()
    {
        echo "ceshb
";
    }
}

//将对象注册到全局树
$Register=new Register();
$Register->setObject('a',new A());
$Register->setObject('b',new B());

//获取容器管理的所有对象
print_r(Register::getAllObjects());

//获取对象调用方法
Register::getObject('a')->ceshi();
Register::getObject('b')->ceshi();

//移除对象
$Register->_unset('a');

//获取容器管理的所有对象
print_r(Register::getAllObjects());

5.适配器模式

将各种截然不容的函数接口封装成统一的api.
php中的数据库操作有mysql,mysqli,pdo三种，可以用适配器模式统一成一致，使用的数据库操作，统一成一样api，

类似场景还有cache适配器，可以将memcache,redis，file,apc等不同的缓存函数，统一成一致。
首先定义一个接口（有几个方法，以及响应的参数）.然后有几种不同的情况，就写几个类实现该接口。
将完成相似功能的函数，统一成一致的方法

代码 demo （容器）：

#接口interface
interface IDatabase
{
    function connect($host,$user,$passwd,$dbname);
    function query($sql);
    function close();
}


#mysql
class Mysql implements IDatabase
{
    protected $conn;
    public function connect($host,$user,$passwd,$dbname)
    {
        $conn = mysql_connect($host, $user, $passwd);
        mysql_select_db($dbname, $conn);
        $this->conn = $conn;
    }

    public function query($sql)
    {
        $res = mysql_query($sql, $this->conn);
        return $res;
    }

    public function close()
    {
        mysql_close($this->conn);
    }
}

#mysqli
class Mysqli implements IDatabase
{
    protected $conn;
    public function connect($host,$user,$passwd,$dbname)
    {
        $conn = mysql_connect($host, $user, $passwd);
        $this->conn = $conn;
    }

    public function query($sql)
    {
        $res = mysql_query($sql, $this->conn);
        return $res;
    }

    public function close()
    {
        mysql_close($this->conn);
    }
}

6.观察者模式

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

代码 demo ：

abstract class EventGenerator
{
    private $observers=array();

    #添加观察者
    function addObserver(Observer $observer)
    {
        $this->observers[]=$observer;
    }

    #执行操作
    function notify()
    {
        foreach ($this->observers as $observer){
            $observer->update();
        }
    }
}


##定义一个观察者接口
interface Observer
{
    function update();//这里就是在事件发生后要执行的逻辑
}

#一个实现了EventGenerator抽象类的类，用于具体定义某个发生的事件
class Event extends EventGenerator
{
    function triget()
    {
        echo "Event
";
    }
}

#实现接口
class Observer1 implements Observer
{
    function update()
    {
        echo "逻辑1
";
    }
}

class Observer2 implements Observer
{
    function update()
    {
       echo "逻辑2
";
    }
}

$event=new Event();
$event->addObserver(new Observer1());
$event->addObserver(new Observer2());
$event->triget();
$event->notify();