事件监听

在 2015年4月17日2015年4月17日上张贴由 BestLove

<?php 
// 在JS中写事件很简单 
// <input type="button" value="test" onclick="test();">
// function test (){
//     alert('hello world');
// }
//onclick是一个事件。test()是一个响应，即：回调函数。

//那么php中，这种事件是怎么实现的呢？
//比如：set_error_handler(callback_error_handler [, int error_types])
//callback_error_handler是我们自定义的一个方法，同样我们在里面输出hello world。如果php程序执行出错，就会调用这个方法
//那么我们可以理解为：程序出错是一个事件，输出hello world 是一个响应。

//由此，我们可以推断，不管什么语言。它们的事件监听都是依靠回调函数来完成的。
//比如说，我们要煮一碗面，那么先要烧水、水开了放面、然后放辅料、调料、煮完撩起。
class Pan{
    protected $name = '锅子';
    public function __construct() {
        echo $this->name . '准备好了，开始煮面...<br>';
    }
    public function fill($obj) {
        echo '放入' . $obj->getName() . '...<br>';
    }
    public function warm($time) {
        echo '加热' . $time . '分钟...<br>';
    }
    public function __destruct() {
        echo '煮完了可以吃了...';
    }
}
class Water{
    private $name = '水';
    public function getName(){
        return $this->name;
    }
}
class Noodles{
    private $name = '面';
    public function getName(){
        return $this->name;
    }
}
class Food{
    private $name = '辅料';
    public function getName(){
        return $this->name;
    }
}
class Spices{
    private $name = '调料';
    public function getName(){
        return $this->name;
    }
}
$pan = new Pan();
$pan->fill(new Water());
$pan->warm(5);
$pan->fill(new Noodles());
$pan->warm(2);
$pan->fill(new Food());
$pan->warm(2);
$pan->fill(new Spices());
$pan->warm(1);
//通常，我们会像上面那样依次执行我们程序。

//然后，我们通过事件来实现下上面的程序。
class Event{
    private $time = -1;
    private $eventList = array();

    public function addListen($time, $callback, $params=array()){
        $this->eventList[$time][] = array($callback, $params);
    }

    public function listen(){
        while ($this->eventList) {
            ++$this->time;
            if (!isset($this->eventList[$this->time])) {
                continue;
            }
            $this->executeEvent();
        }
    }

    public function executeEvent(){
        foreach ($this->eventList[$this->time] as $v) {
            call_user_func_array($v[0], $v[1]);
        }
        unset($this->eventList[$this->time]);
    }
}
class AutoPan extends Pan{
    private $event;
    public function addEvent(Event $event) {
        $this->event = $event;
    }
    public function start() {
        $this->event->listen();
    }
}
unset($pan);
echo '<br><br><br>';
$event = new Event();
$pan = new AutoPan();
$pan->addEvent($event);
$event->addListen(0, array($pan, 'fill'), array(new Water));
$event->addListen(0, array($pan, 'warm'), array(5));
$event->addListen(5, array($pan, 'fill'), array(new Noodles));
$event->addListen(5, array($pan, 'warm'), array(2));
$event->addListen(7, array($pan, 'fill'), array(new Food));
$event->addListen(7, array($pan, 'warm'), array(2));
$event->addListen(9, array($pan, 'fill'), array(new Spices));
$event->addListen(9, array($pan, 'warm'), array(1));
$pan->start();

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

<?php

// 在JS中写事件很简单

// <input type="button" value="test" onclick="test();">

// function test (){

// alert('hello world');

// }

//onclick是一个事件。test()是一个响应，即：回调函数。

//那么php中，这种事件是怎么实现的呢？

//比如：set_error_handler(callback_error_handler [, int error_types])

//callback_error_handler是我们自定义的一个方法，同样我们在里面输出hello world。如果php程序执行出错，就会调用这个方法

//那么我们可以理解为：程序出错是一个事件，输出hello world 是一个响应。

//由此，我们可以推断，不管什么语言。它们的事件监听都是依靠回调函数来完成的。

//比如说，我们要煮一碗面，那么先要烧水、水开了放面、然后放辅料、调料、煮完撩起。

class Pan{

protected $name = '锅子';

public function __construct() {

echo $this->name . '准备好了，开始煮面... ';

}

public function fill($obj) {

echo '放入' . $obj->getName() . '... ';

}

public function warm($time) {

echo '加热' . $time . '分钟... ';

}

public function __destruct() {

echo '煮完了可以吃了...';

}

class Water{

private $name = '水';

public function getName(){

return $this->name;

}

class Noodles{

private $name = '面';

public function getName(){

return $this->name;

}

class Food{

private $name = '辅料';

public function getName(){

return $this->name;

}

class Spices{

private $name = '调料';

public function getName(){

return $this->name;

}

$pan = new Pan();

$pan->fill(new Water());

$pan->warm(5);

$pan->fill(new Noodles());

$pan->warm(2);

$pan->fill(new Food());

$pan->warm(2);

$pan->fill(new Spices());

$pan->warm(1);

//通常，我们会像上面那样依次执行我们程序。

//然后，我们通过事件来实现下上面的程序。

class Event{

private $time = -1;

private $eventList = array();

public function addListen($time, $callback, $params=array()){

$this->eventList[$time][] = array($callback, $params);

}

public function listen(){

while ($this->eventList) {

++$this->time;

if (!isset($this->eventList[$this->time])) {

continue;

}

$this->executeEvent();

}

public function executeEvent(){

foreach ($this->eventList[$this->time] as $v) {

call_user_func_array($v[0], $v[1]);

}

unset($this->eventList[$this->time]);

}

class AutoPan extends Pan{

private $event;

public function addEvent(Event $event) {

$this->event = $event;

}

public function start() {

$this->event->listen();

}

unset($pan);

echo ' ';

$event = new Event();

$pan = new AutoPan();

$pan->addEvent($event);

$event->addListen(0, array($pan, 'fill'), array(new Water));

$event->addListen(0, array($pan, 'warm'), array(5));

$event->addListen(5, array($pan, 'fill'), array(new Noodles));

$event->addListen(5, array($pan, 'warm'), array(2));

$event->addListen(7, array($pan, 'fill'), array(new Food));

$event->addListen(7, array($pan, 'warm'), array(2));

$event->addListen(9, array($pan, 'fill'), array(new Spices));

$event->addListen(9, array($pan, 'warm'), array(1));

$pan->start();

DI依赖注入

在 2015年4月16日2015年7月9日上张贴由 BestLove

<?php
//依赖注入(Dependency Injection)，简称DI。也可称为控制反转。

//感觉依赖注入有点像建造者模式，但是比建造者模式更灵活，所有的依赖都是注入进去的。

//假设有一个动物园，动物园有很多动物，大象、猴子、老虎、老鼠、兔子等等。

class Zoo{
    private $tiger;
    public function __construct() {
        $this->tiger = new Tiger();
    }
}

//如果按照上面的写法，则动物园必须要有老虎，没有就不能运营了。
//这样动物园对老虎，就产生了依赖关系。

class Zoo{
    private $tiger;
    public function addTiger($tiger) {
        $this->tiger = $tiger;    
    }
}

//这样写的话，其实动物园对老虎的依赖关系已经解除了。
//但是这样写又会存在一个问题，动物园中要添加一个动物就需要添加一个方法。
//addMonkey() addMouse() addRabbit() addElephant() ...

//此时，就需要一个DI容器，来统一添加各种动物

class Zoo{
    private $di;
    public function setDi($di) {
        $this->di = $di;
    }

    public function open() {
        echo '动物园开张了<br>';
        $classList = $this->di->getDiList(); 
        foreach ($classList as $key => $value) {
            $anmial = $this->di->get($key);
            $anmial->say();
        }
    }
}

class Di{
    private $classList;
    public function set($key, $class) {
        $this->classList[$key] = $class;
    }
    public function get($key) {
        return new $this->classList[$key];
    }
    public function getDiList(){
        return $this->classList;
    }
}

class Tiger{
    public function say() {
        echo '我是老虎<br>';
    }
}

class Elephant{
    public function say() {
        echo '我是大象，我为php代言<br>';
    }
}
class Mouse{
    public function say() {
        echo '我是老鼠<br>';
    }
}

$zoo = new Zoo();
$di = new Di();
$di->set('tiger', 'Tiger');
$di->set('elephant', 'Elephant');
$di->set('mouse', 'Mouse');
$zoo->setDi($di);
$zoo->open();

<?php

//依赖注入(Dependency Injection)，简称DI。也可称为控制反转。

//感觉依赖注入有点像建造者模式，但是比建造者模式更灵活，所有的依赖都是注入进去的。

//假设有一个动物园，动物园有很多动物，大象、猴子、老虎、老鼠、兔子等等。

class Zoo{

private $tiger;

public function __construct() {

$this->tiger = new Tiger();

}

//如果按照上面的写法，则动物园必须要有老虎，没有就不能运营了。

//这样动物园对老虎，就产生了依赖关系。

class Zoo{

private $tiger;

public function addTiger($tiger) {

$this->tiger = $tiger;

}

//这样写的话，其实动物园对老虎的依赖关系已经解除了。

//但是这样写又会存在一个问题，动物园中要添加一个动物就需要添加一个方法。

//addMonkey() addMouse() addRabbit() addElephant() ...

//此时，就需要一个DI容器，来统一添加各种动物

class Zoo{

private $di;

public function setDi($di) {

$this->di = $di;

}

public function open() {

echo '动物园开张了 ';

$classList = $this->di->getDiList();

foreach ($classList as $key => $value) {

$anmial = $this->di->get($key);

$anmial->say();

}

class Di{

private $classList;

public function set($key, $class) {

$this->classList[$key] = $class;

}

public function get($key) {

return new $this->classList[$key];

}

public function getDiList(){

return $this->classList;

}

class Tiger{

public function say() {

echo '我是老虎 ';

}

class Elephant{

public function say() {

echo '我是大象，我为php代言 ';

}

class Mouse{

public function say() {

echo '我是老鼠 ';

}

$zoo = new Zoo();

$di = new Di();

$di->set('tiger', 'Tiger');

$di->set('elephant', 'Elephant');

$di->set('mouse', 'Mouse');

$zoo->setDi($di);

$zoo->open();

委托模式

在 2015年4月3日2015年7月9日上张贴由 BestLove

<?php 
//状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式
class Cd{

    protected  $song = '单曲轮播';

    public function QQPlay(){
        echo '使用QQ播放器播放：' . $this->song . '...<br>';
    }

    public function BaiDuPlay(){
        echo '使用百度播放器播放' . $this->song . '...<br>';
    }
}

$cd = new Cd();
$type = 'qq';
if ( $type == 'qq') {
    $cd->QQPlay();
} else if ($type == 'baidu') {
    $cd->BaiDuPlay();
}
//那么如果还要添加新浪、搜狐、其他播放器，就要去修改Cd类内部，而且if...else...会越来越多
//此时使用委托模式是一个不错的选择
class Cd1{

    protected  $song = '单曲轮播';

    protected $player = null;

    public function setPlayer(Player $player){
        $this->player = $player;
    }
    public function play(){
        $this->player->play($this->song);
    }
}

interface Player {
    public function play($song);
}

class QQPlayer implements Player {
    public function play($song){
        echo '使用QQ播放器播放：' . $song . '...<br>';
    }
}

class BaiDuPlayer implements Player {
    public function play($song){
        echo '使用百度播放器播放：' . $song . '...<br>';
    }
}
//此时需要使用指定播放器来播放，则委托不同的播放器即可
$qqPlayer = new QQPlayer();
$cd = new Cd1();
$cd->setPlayer($qqPlayer);
$cd->play();
$cd->setPlayer(new BaiDuPlayer());
$cd->play();
//当然以上demo也可以使用继承来实现，但是用一个播放器来继承一个CD，从语义上来讲不太合理
//如果说是一个人类，中国人继承他说中国话，英国人继承他说英国话...从语义上更为合理
//而且继承会破坏封装性，或者父类较为臃肿，有很多方法子类使用不到时，也不建议使用
//现在很多MVC框架中的Controller、Model、View都使用继承，可能是要定义一种规范，也不能说继承一无是处
//具体使用继承还是委托需要看不同的应用场景
//附：http://www.cnblogs.com/nuaalfm/archive/2010/04/23/1718453.html

<?php

//状态模式、策略模式、访问者模式本质上是在更特殊的场合采用了委托模式

class Cd{

protected $song = '单曲轮播';

public function QQPlay(){

echo '使用QQ播放器播放：' . $this->song . '... ';

}

public function BaiDuPlay(){

echo '使用百度播放器播放' . $this->song . '... ';

}

$cd = new Cd();

$type = 'qq';

if ( $type == 'qq') {

$cd->QQPlay();

} else if ($type == 'baidu') {

$cd->BaiDuPlay();

}

//那么如果还要添加新浪、搜狐、其他播放器，就要去修改Cd类内部，而且if...else...会越来越多

//此时使用委托模式是一个不错的选择

class Cd1{

protected $song = '单曲轮播';

protected $player = null;

public function setPlayer(Player $player){

$this->player = $player;

}

public function play(){

$this->player->play($this->song);

}

interface Player {

public function play($song);

}

class QQPlayer implements Player {

public function play($song){

echo '使用QQ播放器播放：' . $song . '... ';

}

class BaiDuPlayer implements Player {

public function play($song){

echo '使用百度播放器播放：' . $song . '... ';

}

//此时需要使用指定播放器来播放，则委托不同的播放器即可

$qqPlayer = new QQPlayer();

$cd = new Cd1();

$cd->setPlayer($qqPlayer);

$cd->play();

$cd->setPlayer(new BaiDuPlayer());

$cd->play();

//当然以上demo也可以使用继承来实现，但是用一个播放器来继承一个CD，从语义上来讲不太合理

//如果说是一个人类，中国人继承他说中国话，英国人继承他说英国话...从语义上更为合理

//而且继承会破坏封装性，或者父类较为臃肿，有很多方法子类使用不到时，也不建议使用

//现在很多MVC框架中的Controller、Model、View都使用继承，可能是要定义一种规范，也不能说继承一无是处

//具体使用继承还是委托需要看不同的应用场景

//附：http://www.cnblogs.com/nuaalfm/archive/2010/04/23/1718453.html

观察者模式

在 2015年4月3日2015年4月3日上张贴由 BestLove

<?php 
//观察者模式，通俗的讲就是在希望被观察的类中定义一个容器存放允许观察它的类，
//并约定一些方法来注册(attach)、注销(detach)、通知(notify)观察者类。
//观察者类型定义一个update方法，当接受到通知后做相应的修改
//demo如下，实际应用中type是需要约定的，如果通知的对象是一类，则不需要type

interface IObject{
    public function attach($type, IObserver $observer);
    public function detach($type, IObserver $observer);
    public function notify($type);
}

class Jay implements IObject{
    protected $oblist = array();

    protected $name = '周杰伦';

    public function attach($type, IObserver $observer){
        $this->oblist[$type][] = $observer;
    }

    public function detach($type, IObserver $observer){
        if (isset($this->oblist[$type])) {
            $key = array_search($observer, $this->oblist[$type]);
            if ($key !== false) {
                unset($this->oblist[$type][$key]);
            }
        }
    }
    public function notify($type){
        if (isset($this->oblist[$type])) {
            foreach ($this->oblist[$type] as $observer) {
                $observer->update($this);
            }
        }
    }

    public function album(){
        echo '我要发专辑了...<br>';
        $this->notify('album');
    }

    public function marry(){
        echo '我要结婚了...<br>';
        $this->notify('marry');
    }

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

interface IObserver{
    public function update(IObject $object);
}

class Fans implements IObserver{
    public function update(IObject $object) {
        echo $object->getName() . '发专辑了，我要去购买<br>';
    }
}

class Friend implements IObserver{
    public function update(IObject $object) {
        echo $object->getName() . '要结婚了，我要去参加<br>';
    }
}

class Company implements IObserver{
    public function update(IObject $object) {
        echo $object->getName() . '发专辑了，赶紧做宣传<br>';
    }
}
$jay = new Jay();
$company = new Company();
$jay->attach('album', new Fans());
$jay->attach('album', $company);
$jay->attach('marry', new Friend());
$jay->album();
$jay->marry();
$jay->detach('album', $company);
$jay->album();

<?php

//观察者模式，通俗的讲就是在希望被观察的类中定义一个容器存放允许观察它的类，

//并约定一些方法来注册(attach)、注销(detach)、通知(notify)观察者类。

//观察者类型定义一个update方法，当接受到通知后做相应的修改

//demo如下，实际应用中type是需要约定的，如果通知的对象是一类，则不需要type

interface IObject{

public function attach($type, IObserver $observer);

public function detach($type, IObserver $observer);

public function notify($type);

}

class Jay implements IObject{

protected $oblist = array();

protected $name = '周杰伦';

public function attach($type, IObserver $observer){

$this->oblist[$type][] = $observer;

}

public function detach($type, IObserver $observer){

if (isset($this->oblist[$type])) {

$key = array_search($observer, $this->oblist[$type]);

if ($key !== false) {

unset($this->oblist[$type][$key]);

}

public function notify($type){

if (isset($this->oblist[$type])) {

foreach ($this->oblist[$type] as $observer) {

$observer->update($this);

}

public function album(){

echo '我要发专辑了... ';

$this->notify('album');

}

public function marry(){

echo '我要结婚了... ';

$this->notify('marry');

}

public function getName(){

return $this->name;

}

interface IObserver{

public function update(IObject $object);

}

class Fans implements IObserver{

public function update(IObject $object) {

echo $object->getName() . '发专辑了，我要去购买 ';

}

class Friend implements IObserver{

public function update(IObject $object) {

echo $object->getName() . '要结婚了，我要去参加 ';

}

class Company implements IObserver{

public function update(IObject $object) {

echo $object->getName() . '发专辑了，赶紧做宣传 ';

}

$jay = new Jay();

$company = new Company();

$jay->attach('album', new Fans());

$jay->attach('album', $company);

$jay->attach('marry', new Friend());

$jay->album();

$jay->marry();

$jay->detach('album', $company);

$jay->album();

适配器模式

在 2015年4月1日2015年4月1日上张贴由 BestLove

<?php
/*
一般公司都会有一些稳定的类库，服务当前的系统
此时，有一个新的需求跟类库中的功能大部分都是相同的，只有小部分不同
这个时候可能有3种解决方案
1.复制相关类，然后修改其中的一些方法，服务这个新功能
这么做，缺点显而易见，代码变的不易于管理，通用性差，代码量增多，不便于维护
2.修改相关类，用if else 做相应判断
这么做，会使代码变得丑陋，而且修改现有类之后还会波及原来的被服务对象一起改动，这样的话，上一个新功能可能还得回归测试现有功能，可能还会改错，导致现有功能出现故障，同样不便于管理
3.适配器模式
通过适配器类去适配新需求，老代码不用做修改，是较好的一种处理方法

现实生活中，也会存在类似于适配器模式的情况
比如：小明去国内旅游，住进了某宾馆，晚上要给手机充电，只要插上手机充电器即可
然后小明又去了香港旅游，住进了某宾馆，晚上要给手机充电，当小明要插手机充电的时候，发现香港的插座不能插他的充电器，还好在香港去之前，他做了攻略，问朋友借了插口转换器，此时小明将充电器插在插口转换器上，再插入插座充电
这里的插口转换器，就类似于程序中的适配器
*/

class Iphone{
	protected $_charger;

	public function __construct() {
		$this->_charger = '充电器';
	}

	public function getCharger(){
		return $this->_charger;
	}
}

class HotelCn{
	private $_phone;
	public function __construct($iphone) {
		$this->_phone = $iphone;
	}

	public function setCharger(){
		echo '国内旅馆使用：' . $this->_phone->getCharger() . '充电';
	}
}

class HotelHkAdapter extends Iphone{
	public function getCharger(){
		return $this->_charger . $this->setAdapter();
	} 

	public function setAdapter(){
		return '插入转换器';
	}
}

class HotelHk{
	private $_phone;
	public function __construct($iphone) {
		$this->_phone = $iphone;
	}

	public function setCharger(){
		echo '香港旅馆使用：' . $this->_phone->getCharger() . '充电';
	}
}

$phone = new Iphone();
$hotelCn = new HotelCn($phone);
$hotelCn->setCharger();
echo '<br>';
$hotelHkAdapter = new HotelHkAdapter();
$hotelHk = new HotelHk($hotelHkAdapter);
$hotelHk->setCharger();

//输出：
//国内旅馆使用：充电器充电
//香港旅馆使用：充电器插入转换器充电
//当然这个例子有些牵强，因为香港宾馆中一般备有插口转换器

<?php

一般公司都会有一些稳定的类库，服务当前的系统

此时，有一个新的需求跟类库中的功能大部分都是相同的，只有小部分不同

这个时候可能有3种解决方案

1.复制相关类，然后修改其中的一些方法，服务这个新功能

这么做，缺点显而易见，代码变的不易于管理，通用性差，代码量增多，不便于维护

2.修改相关类，用if else 做相应判断

这么做，会使代码变得丑陋，而且修改现有类之后还会波及原来的被服务对象一起改动，这样的话，上一个新功能可能还得回归测试现有功能，可能还会改错，导致现有功能出现故障，同样不便于管理

3.适配器模式

通过适配器类去适配新需求，老代码不用做修改，是较好的一种处理方法

现实生活中，也会存在类似于适配器模式的情况

比如：小明去国内旅游，住进了某宾馆，晚上要给手机充电，只要插上手机充电器即可

然后小明又去了香港旅游，住进了某宾馆，晚上要给手机充电，当小明要插手机充电的时候，发现香港的插座不能插他的充电器，还好在香港去之前，他做了攻略，问朋友借了插口转换器，此时小明将充电器插在插口转换器上，再插入插座充电

这里的插口转换器，就类似于程序中的适配器

class Iphone{

protected $_charger;

public function __construct() {

$this->_charger = '充电器';

}

public function getCharger(){

return $this->_charger;

}

class HotelCn{

private $_phone;

public function __construct($iphone) {

$this->_phone = $iphone;

}

public function setCharger(){

echo '国内旅馆使用：' . $this->_phone->getCharger() . '充电';

}

class HotelHkAdapter extends Iphone{

public function getCharger(){

return $this->_charger . $this->setAdapter();

}

public function setAdapter(){

return '插入转换器';

}

class HotelHk{

private $_phone;

public function __construct($iphone) {

$this->_phone = $iphone;

}

public function setCharger(){

echo '香港旅馆使用：' . $this->_phone->getCharger() . '充电';

}

$phone = new Iphone();

$hotelCn = new HotelCn($phone);

$hotelCn->setCharger();

echo ' ';

$hotelHkAdapter = new HotelHkAdapter();

$hotelHk = new HotelHk($hotelHkAdapter);

$hotelHk->setCharger();

//输出：

//国内旅馆使用：充电器充电

//香港旅馆使用：充电器插入转换器充电

//当然这个例子有些牵强，因为香港宾馆中一般备有插口转换器

简单工厂模式

在 2015年2月15日2015年4月1日上张贴由 BestLove

<?php 
interface Animal{ 
	public function say();
}

class Dog implements Animal{
	function say(){
		echo 'wangwang';
	}
}

class Person implements Animal{
	public function say(){
		echo 'hello world';
	}
}

class EasyFactory{ //简单工厂类
	public static function getAmimal($type) {
		$arr = array('Dog', 'Person');
		if (!in_array($type, $arr)) {
			echo 'no way';exit;
		}
		$animal = new $type;
		return $animal;
	}
}
$obj = EasyFactory::getAmimal('Dog1');
$obj = EasyFactory::getAmimal('Dog');
$obj->say();
$obj = EasyFactory::getAmimal('Person');
$obj->say();

<?php

interface Animal{

public function say();

}

class Dog implements Animal{

function say(){

echo 'wangwang';

}

class Person implements Animal{

public function say(){

echo 'hello world';

}

class EasyFactory{ //简单工厂类

public static function getAmimal($type) {

$arr = array('Dog', 'Person');

if (!in_array($type, $arr)) {

echo 'no way';exit;

}

$animal = new $type;

return $animal;

}

$obj = EasyFactory::getAmimal('Dog1');

$obj = EasyFactory::getAmimal('Dog');

$obj->say();

$obj = EasyFactory::getAmimal('Person');

$obj->say();

唐晓锋–BLOG

This is just a personal note.

分类：设计模式

事件监听

DI依赖注入

委托模式

观察者模式

适配器模式

简单工厂模式