PHP 常见设计模式

DesignPattern_PHP

PHP 基础设计模式学习，默认自动加载类

单例模式

一个类只允许实例化一次：如数据库类

---

工厂模式

对一个类实现统一实例化
一个类如果在多个地方实例化
可以实现统一修改

---

注册器模式

单例模式保证了一个类中只有一个实例被全局访问，当你有一组全局对象被全局访问时可能就需要用到**注册模式 **

---

Ico 容器

binds[$abstract] = $concrete;
        } else {
            $this->instances[$abstract] = $concrete;
        }
    }

    // 运行注册脚本
    public function make($abstract, $parameters = [])
    {
        if (isset($this->instances[$abstract])) {
            return $this->instances[$abstract];
        }

        $parameters = (array) $parameters;
        array_unshift($parameters, $this);

        return call_user_func_array($this->binds[$abstract], $parameters);
    }
}

$container = new Container();

$container->bind('databases', function ($container) {
    return new PDO();
});

$db = $container->make('databases');

---

适配器模式

可以将不同的接口封装成统一的API,如:mysql,mysqli,pdo

conn = mysqli_connect($host, $user, $passwd, $dbname);
    }
    public function query($sql)
    {
        // ...
    }
    public function close()
    {
        // ...
    }
}
class PDO implements PDO
{
    public function construct($config)
    {
        extract($config);
        $this->conn = new \PDO("mysql:host=$host;dbname=$dbname", $user, $passwd);
    }
    public function query($sql)
    {
        // ...
    }
    public function close()
    {
        // ...
    }
}

---

策略模式

将一组特定的行为或算法封装成类，以适应某些上下文环境

strategy->title();
        $this->strategy->content();
    }
    public function setStrategy(Strategy $strategy)
    {
        $this->strategy = $strategy;
    }
}
$post = new Post();
$post->setStrategy(new PostTwo);
$post->show();

---

数据映射

db = new PDO("mysql:host=192.168.10.10;dbname=zhihu", 'homestead', 'secret');
        $res = $this->db->query("select * from users limit 1");

        $this->attributes = $res->fetch(PDO::FETCH_ASSOC);
    }

    function __destruct()
    {
        // TODO: Implement __destruct() method.
    }

    function __get($key)
    {
        return $this->attributes[$key];
    }

    function __set($key, $value)
    {
        $this->attributes[$key] = $value;
    }

    function save()
    {
        $sql = "update {$this->table} set ";
        foreach ($this->attributes as $key => $attribute) {
            $sql .= "`{$key}`='{$attribute}',";
        }
        $sql = trim($sql, ',');
        $sql .= ' where id=1';
        $this->db->query($sql);
    }

---

观察者模式

当一个对象状态发生改变时，依赖他的对象全部会收到通知，并自动更新

observers[] = $observer;
    }
    public function detach(SplObserver $observer)
    {
        if($index = array_search($observer, $this->observers)) {
            unset($this->observers[$index]);
        }
    }
    // 通知
    public function notify()
    {
        // 遍历观察者对象，逐一执行 观察者 update
        foreach($this->observers as $observer) {
            $observer->update($this);
        }
    }
}
class EventTrigger extends Event
{
    // 事件发生
    public function trigger()
    {
        echo 'event trigger';
        // 通知
        $this->notify();
    }
}

---

装饰器

扩展一个类一般可以使用继承或者组合的形式。使用继承的方式扩展时，随着基类子类的增多，以及子类的子类出现，继而出现了代码的无限制膨胀，增加了系统的复杂性。而使用装饰者模式既继承又引用，能动态扩展类的一些功能，减少了继承数量。

component = $component;
    }

    public function operation()
    {
        $this->component->operation();
    }
}

/**
 * 具体装饰类A
 */
class ConcreteDecoratorA extends Decorator
{
    public function __construct(Component $component)
    {
        parent::__construct($component);
    }

    public function operation()
    {
        parent::operation();
        $this->addedOperationA();//新添加的操作
    }

    public function addedOperationA()
    {
        echo 'Add Operation A 
';
    }
}

/**
 * 具体装饰类B
 */
class ConcreteDecoratorB extends Decorator
{
    public function __construct(Component $component)
    {
        parent::__construct($component);
    }

    public function operation()
    {
        parent::operation();
        $this->addedOperationB();//新添加的操作
    }

    public function addedOperationB()
    {
        echo 'Add Operation B 
';
    }
}

/**
 * 具体构件
 */
class ConcreteComponent implements Component
{
    public function operation()
    {
        echo 'Concrete Component operation 
';
    }
}

/**
 * 客户端
 */
class Client
{
    public static function main()
    {
        $component = new ConcreteComponent();
        $decoratorA = new ConcreteDecoratorA($component);
        $decoratorB = new ConcreteDecoratorB($decoratorA);

        $decoratorA->operation();
        $decoratorB->operation();
    }
}

Client::main();

// 输出
// Concrete Component operation 

// Add Operation A 

//
// Concrete Component operation 

// Add Operation A 

// Add Operation B 

---

迭代器

迭代器模式提供一种访问一个容器对象中的各个元素，而又不暴露其内部细节的方法。

data = $data;
        $this->index = 0;
        $this->count = count($this->data);
    }

    public function rewind()
    {
        echo __METHOD__;
        $this->index = 0;
    }

    public function valid()
    {
        echo __METHOD__;
        return $this->index < $this->count;
    }

    public function key()
    {
        echo __METHOD__;
        return $this->index;
    }

    public function current()
    {
        echo __METHOD__;
        $row = $this->data[$this->index];
        $row['ip'] = gethostbyname($row['url']);
        return $row;
    }

    public function next() {
        echo __METHOD__;
        $this->index ++;
    }
}

$array = array(
    array('url' => 'www.zeroplace.cn'),
    array('url' => 'www.baidu.com'),
);

$d = new TestIterator($array);
foreach($d as $k => $v) {
    echo '---------------';
    echo $v['url'] . '===' . $v['ip'];
    echo '###############';
}
// TestIterator::rewind
// TestIterator::valid
// TestIterator::current
// TestIterator::key
// ---------------
// www.zeroplace.cn
// ###############
// TestIterator::next
// TestIterator::valid
// TestIterator::current
// TestIterator::key
// ---------------
// www.baidu.com
// ###############
// TestIterator::next
// TestIterator::valid

原文：https://github.com/wwhu668/DesignPattern_PHP