常用的设计模式：单例模式，工厂模式，观察者模式，适配器模式，依赖注入等

单例模式

//单例设计模式
class Singleton
{
    //单例对象
    private static $instance;

    private function __construct()
    {
    }

    public static function getInstance(){
        if(!self::$instance){
            self::$instance = new self();
        }
        return self::$instance;
    }
}

//单例模式
$singleton = Singleton::getInstance();

简单工厂模式

<?php

//mysql 数据库类
class mysql{
    public function conn() {
        echo ‘连接上了Mysql‘;
    }
}

//sqlite 数据库类
class sqlite{
    public function conn() {
        echo ‘连接上了sqlite‘;
    }
}

// 简单工厂，工厂方法
class Factory{
    public static function  createDb($type = ‘‘) {
        if($type == ‘mysql‘) {
            return new mysql();
        }elseif($type == ‘sqlite‘) {
            return new sqlite();
        }else{
            //报错
            throw new Exception("Error db type", 1);
        }
    }
}

//创建mysql类的对象
$mysql = Factory::createDb(‘mysql‘);
$mysql->conn();
//创建sqlite类的对象
$sqlite = Factory::createDb(‘sqlite‘);
$sqlite->conn();

复杂工厂模式

<?php

//共同接口
interface db{
    public function conn();
}

//mysql数据库类
class mysql implements db{
    public function conn() {
        echo ‘连接上了Mysql‘;
    }
}

//sqlite数据库类
class sqlite implements db{
    public function conn() {
        echo ‘连接上了sqlite‘;
    }
}

//工厂接口
interface Factory{
    public function createDB();
}

//mysql工厂接口实现
class mysqlFactory implements Factory{
    public function createDB() {
        return new mysql();
    }
}

//sqlite工厂接口实现
class sqliteFactory implements Factory{
    public function createDB() {
        return new sqlite();
    }
}

//新增一个oracle
class oracleFactory implements Factory{
    public function createDB() {
        return new oracle();
    }
}

//新增oracle
class oracle implements db{
    public function conn() {
        echo ‘连接上了oracle‘;
    }
}

//客户端调用
$fact = new mysqlFactory();
//使用一个mysql工厂造一个mysql连接
$db = $fact->createDB();
$db->conn();
$fact = new sqliteFactory();
$db = $fact->createDB();
$db->conn();
$fact = new oracleFactory();
$db = $fact->createDB();
$db->conn();

观察者模式

<?php

/**
 * 观察者接口类
 * Interface ObServer
 */
interface ObServer
{
    public function update($event_info = null);
}

/**
 * 观察者1
 */
class ObServer1 implements ObServer
{
    public function update($event_info = null)
    {
        echo "观察者1 收到执行通知 执行完毕！\n";
    }
}

/**
 * 观察者1
 */
class ObServer2 implements ObServer
{
    public function update($event_info = null)
    {
        echo "观察者2 收到执行通知 执行完毕！\n";
    }
}

/**
 * 事件产生类
 * Class EventGenerator
 */
abstract class EventGenerator
{
    private $ObServers = [];

    //增加观察者
    public function add(ObServer $ObServer)
    {
        $this->ObServers[] = $ObServer;
    }

    //事件通知
    public function notify()
    {
        foreach ($this->ObServers as $ObServer) {
            $ObServer->update();
        }
    }

}

/**
 * 事件
 * Class Event
 */
class Event extends EventGenerator
{
    /**
     * 触发事件
     */
    public function trigger()
    {
        //通知观察者
        $this->notify();
    }
}

//创建一个事件
$event = new Event();
//为事件增加旁观者
$event->add(new ObServer1());
$event->add(new ObServer2());
//执行事件 通知旁观者
$event->trigger();

适配器模式

<?php

/**
 * Target.php（目标接口）
 * Interface Target
 */
interface Target
{
    //方法1
    public function method1();
    //方法2
    public function method2();
}


/**
 * Adapter.php（源接口）
 * Class Adapter
 */
class Adapt
{
    public function method1()
    {
        echo "Adapt Method1<br/>\n";
    }
}


/**
 * Adapter.php（适配器）
 * Class Adapter
 */
class Adapter implements Target
{
    //源接口对象参数
    private $adapt;

    //构造源接口对象
    public function __construct(Adapt $adapt)
    {
        $this->adapt = $adapt;
    }

    //adapt类的method1方法
    public function method1()
    {
        $this->adapt->method1();
    }

    //adapter类的method2方法
    public function method2()
    {
        echo "Adapter Method2<br/>\n";
    }
}


// 客户端调用
$adapter = new Adapter(new Adapt());
$adapter->method1();
$adapter->method2();

依赖注入

<?php

//声明一个容器类，用来注入对象
class Container
{
    //声明一个数组，用来存放对象
    private $s = array();

    //声明一个方法，用来实现对象的存放
    function set($k, $c)
    {
        //将对象存放进数组
        $this->s[$k] = $c;
    }

    //声明一个方法，用来获取对象
    function get($k)
    {
        //返回对应的对象
        return $this->s[$k];
    }
}

//声明一个Db类
class Db
{
    //声明一个方法
    public function doSomething()
    {
        //返回话术
        return ‘这是一个依赖注入的测试‘;
    }
}

//声明一个Cache类
class Cache
{
    //声明一个容器变量
    private $container;

    //使用构造函数给container赋值
    public function __construct(Container $container)
    {
        //将容器对象赋值给变量
        $this->container = $container;
    }    //声明一个方法

    public function doSomething($str)
    {
        //执行Db类中对应的方法
        var_dump($this->container->get($str)->doSomething());
    }
}

//创建一个Container对象
$container = new Container();
//在容器中注入两个类
$container->set(‘db‘, new Db());
$container->set(‘cache‘, new Cache($container));
//执行对应的方法
$container->get(‘cache‘)->doSomething(‘db‘);
//执行db自己的方法
echo $container->get(‘db‘)->doSomething();

php 设计模式