常见的设计模式

单例模式

核心思想：禁止外部实例化，统一有类内部实例化对象有且只有一个实例返回给外部调用。
实现思路：
1.私有化clone,__construct函数避免外部直接实例化
2.声明静态属性obj存储类内部实例化对象，并且通过公开方法get_db把对象返回给外部调用。

以下是一个使用单例模式实现mysqli的一个类

class MysqlClass
{
    private static $obj = NULL; //mysqlclass对象
    public $host;
    public $database;
    public $user;
    public $pwd;
    public $port;
    public $mysqli = NULL;

    //禁止对象被克隆
    private function __clone(){}

    //禁止外部实例化
    private function __construct($host="localhost",$database="test",$user="root",$pwd="root",$port="3306")
    {

        $this->host = $host;
        $this->database = $database;
        $this->user = $user;
        $this->pwd = $pwd;
        $this->port = $port;
        $this->mysqli = $this->db_connect();

    }

    //获取mysqli连接
    private function db_connect()
    {
       
        $mysqli = new mysqli($this->host,$this->user,$this->pwd,$this->database,$this->port);
        if($mysqli->connect_errno)
        {
            printf("Connect failed: %s\n", $mysqli->connect_errno);
            exit();
        }
        
        $mysqli->query("set names utf8 ");
        return $mysqli;
        

    }
    //获取db实例
    public static function get_db()
    {
        if(self::$obj === NULL)
        {
            self::$obj = new self();
        }
        return self::$obj;
    }

    public function db_query($sql)
    {
        $result = $this->mysqli->query($sql);
        $arr = [];
        while ($row = $result->fetch_assoc()) {
            $arr[] = $row;
        }
        $result->close();
        return $arr;
    }

    public function db_insert()
    {

    }
    public function db_update()
    {

    }
    public function __destruct() {

       $this->mysqli->close();
    }
}
$db = MysqlClass::get_db();
$db2 = MysqlClass::get_db();
if($db === $db2)
{
    echo "ok";
}

工厂模式

概述：一般情况下调用者需要调用其他类的方法时，需要实例化被调用者然后在调用它的方法，工厂模式即是调用者不在实例化被调用者，而是把需要实例化的需求交给工厂类，由工厂类进行实例化。
代码描述如下

class User
{

}
class Order
{
    
}
class Factory{
    public static function creater($className)
    {
        return new $className;
    }
}
// $a = Factory::creater("User");
// var_dump($a);

观察者模式

概述：在类内部进行某个操作的时候允许注入外部对象并实现其方法或者某个操作。
代码描述：用户登陆需要记录登陆日志、短信通知

/**
 *  观察者模式
 *  声明观察都需要实现的接口
 */
interface Obverse{
    // 声明用户登陆监听
    public function login($name);
}

//日志类
class Log implements Obverse{
    public function login($name)
    {
        echo "Log: $name is login ";
    }
}
//邮件
class Email implements Obverse{

    public function login($name)
    {
        echo "Email: $name is login ";
    }
}

class User{
    //存储观察者对象
    private $obverse = [];

    //添加观察者
    public function addObverse(Obverse $obj)
    {
        $index = array_search($obj,$this->obverse);
        if($index === false)
        {
            $this->obverse[] = $obj;
        }
    }

    //用户登陆
    public function login($name)
    {
        if(!empty($this->obverse))
        {
            //实现登陆行为观察
            foreach ($this->obverse as $obv) {
                $obv->login($name);
            }
        }
    }
}
$u = new User;
$u->addObverse(new Log());
$u->addObverse(new Email());
$u->login("feng");

适配器模式

概述：适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。
这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡
以下以在线支付场景适配wxpay,alipay的一个例子，通过PayAder适配器适配wxpay,alipay这两种支付方式，如果以后加入更多的支付方式也只需修改适配器即可，无论第三方的支付类如何升级我们只需修改适配。

interface Payinterface{
    public function pay($payname,$params=[]);
}
class Alipay
{
    public function sendPay()
    {
        echo "Alipay";
    }
}

class Wxpay
{

    public function doPay()
    {
        echo "wxpay";
    }
}
class PayAder implements Payinterface{

    public function pay($name,$params=[])
    {
        switch ($name) {
            case 'Alipay':
                $pay = new Alipay();
                $pay->sendPay();
                break;
            case 'Wxpay':
                $pay = new Wxpay();
                $pay->doPay();
                break;
            default:
                
                break;
        }
    }
}
$pay = new PayAder();
$pay->pay("Alipay",[]);

勾子

概述：一般是使用程序执行到某个地方需要响应某些事件

class Log{
    public function write($msg="")
    {
        echo $msg;
    }
}
class hooks{
    public function hooks_call(array $params)
    {
        foreach ($params as $key => $param) {
            if(empty($param['class']))
            {
                exit('hooks class is empty');
            }
            if(!class_exists($param['class']))
            {
                exit('class not found');
            }

            $obj = new $param['class'];
            call_user_func(array($obj,$param['method']['name']),'hooks event');
        }
    }
}

$h = new hooks();
//这些一般写在配置文件中
$parm[] = ['class'=>"Log","method"=>["name"=>"write",'param'=>'aaaa']];
$h->hooks_call($parm);

依赖注入

概述：当一个类的实例需要另一个类的实例协助时，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。而采用依赖注入的方式，创建被调用者的工作不再由调用者来完成，因此叫控制反转，创建被调用者的实例的工作由IOC容器来完成，然后注入调用者，因此也称为依赖注入
以下是一个缓存系统使用依赖注入的一个简单案例，我们有三种缓存方式，redis,memcache,file,缓存类的实例需要redis/memcache/file的协助，只需把要用到的类对象注入容器中，并且在cache类型调用即可。

/**
 * 容器依赖注入
 */

ini_set('display_errors', 1);
error_reporting(-1);


interface DB{

    public function set($k,$v);
    public function get($k);
    public function del($k);
}

class RedisDB implements DB {
    private $redis = NULL;
    public function __construct($host='127.0.0.1',$port=6379)
    {
        $redis = new Redis();
        $redis->connect($host,$port);
        $this->redis = $redis;
    }

    public function set($k,$v){
        return $this->redis->set($k,$v);
    }
    public function get($k){
        return $this->redis->get($k);
    }
    public function del($k){
        return $this->redis->del($k);
    }
}

class memchacheDB implements DB{
    public function set($k,$v){

    }
    public function get($k){

    }
    public function del($k){

    }
}

class FileDB implements DB{

    public function set($k,$v){

    }
    public function get($k){

    }
    public function del($k){

    }
}
//缓存类
class Cache{
    private $di;
    private $object_service;
    public function __construct($object_service)
    {
        $this->object_service = $object_service;
    }
    public function setDi($di)
    {
        $this->di = $di;
    }

    public function set($k,$v){
        //依赖注入
        return $this->di->get($this->object_service)->set($k,$v);
    }
    public function get($k){
        //依赖注入
        return $this->di->get($this->object_service)->get($k);
    }
    public function del($k){
        //依赖注入
        return $this->di->get($this->object_service)->del($k);
    }
}  
//容器类  
class Container
{
    public $object = array();

    public function set($k)
    {
        if(empty($this->object[$k]))
        {
            $this->object[$k] = $this->build($k);
        }
    }

    public function get($k)
    {
        //被动创建对象，并且注入容器,控制反转
        if(!isset($this->object[$k]))
        {
            $this->object[$k] = $this->build($k);
        }

        return $this->object[$k];
    }

    /**
     * 自动绑定（Autowiring）自动解析（Automatic Resolution）
     *
     * @param string $className
     * @return object
     * @throws Exception
     */
    public function build($className)
    {
        // 如果是匿名函数（Anonymous functions），也叫闭包函数（closures）
        if ($className instanceof Closure) {
            // 执行闭包函数，并将结果
            return $className($this);
        }

        /** @var ReflectionClass $reflector */
        $reflector = new ReflectionClass($className);

        // 检查类是否可实例化, 排除抽象类abstract和对象接口interface
        if (!$reflector->isInstantiable()) {
            throw new Exception("Can't instantiate this.");
        }

        /** @var ReflectionMethod $constructor 获取类的构造函数 */
        $constructor = $reflector->getConstructor();

        // 若无构造函数，直接实例化并返回
        if (is_null($constructor)) {
            return new $className;
        }

        // 取构造函数参数,通过 ReflectionParameter 数组返回参数列表
        $parameters = $constructor->getParameters();

        // 递归解析构造函数的参数
        $dependencies = $this->getDependencies($parameters);

        // 创建一个类的新实例，给出的参数将传递到类的构造函数。
        return $reflector->newInstanceArgs($dependencies);
    }

    /**
     * @param array $parameters
     * @return array
     * @throws Exception
     */
    public function getDependencies($parameters)
    {
        $dependencies = [];

        /** @var ReflectionParameter $parameter */
        foreach ($parameters as $parameter) {
            /** @var ReflectionClass $dependency */
            $dependency = $parameter->getClass();

            if (is_null($dependency)) {
                // 是变量,有默认值则设置默认值
                $dependencies[] = $this->resolveNonClass($parameter);
            } else {
                // 是一个类，递归解析
                $dependencies[] = $this->build($dependency->name);
            }
        }

        return $dependencies;
    }

    /**
     * @param ReflectionParameter $parameter
     * @return mixed
     * @throws Exception
     */
    public function resolveNonClass($parameter)
    {
        // 有默认值则返回默认值
        if ($parameter->isDefaultValueAvailable()) {
            return $parameter->getDefaultValue();
        }

        throw new Exception('I have no idea what to do here.');
    }
}
$container = new Container();//创建容器
$cache = new Cache("RedisDB");//缓存类，声明当前使用redis做缓存
$cache->setDi($container);//把容器传入缓存类中
$cache->set("name","2222");
echo $cache->get("name")."\n";