TP框架的一些知识

1. 单例模式

1. 拥有一个构造函数, 并且为private
2. 拥有一个静态成员变量用来保持类的实例
3. 拥有一个访问这个实例的静态方法

/**
 * 创建一个唯一的对象实例
 * 在一个请求进程里, 多次调用类中的方法时, 都只实例化一次
 **/
namespace script;
 
class Test
{
    private static $instance = null;
	
    public static function getInstance(){
        if (is_null(self::$instance)){
            self::$instance = new self(); //实例化自己
        }

        return self::$instance;
    }

    private function __construct()
    {
        
    }

    private function __clone()
    {
        // TODO: Implement __clone() method.

    }
}

2. 注册树模式

1. 注册树模式通过将对象实例注册到一颗全局的对象树上
2. 需要的时候从对象树上采摘下来使用

// 简单理解
namespace script;

class TreeRegister
{
    /**
     * 注册树池子
     * @var null
     */
    protected static $objects = null;

    /**
     * 将对象挂到树上
     * @param $key
     * @param $object
     */
    public static function set($key, $object){
        self::$objects[$key] = $object;
    }

    /**
     * 从树上获取对象, 没有就注册
     * @param $key
     * @return mixed
     */
    public static function get($key){
        if (!isset(self::$objects[$key])){
            self::$objects[$key] = new $key;
        }

        return self::$objects[$key];
    }

    /**
     * 注销
     * @param $key
     */
    public static function _unset($key){
        unset(self::$objects[$key]);
    }

}

namespace script;

class A{
    public function abc(){
        return 'abc';
    }
}

// 使用
$a = new A();
TreeRegister::set('A', $a); // 挂载
TreeRegister::get('A')->abc(); // 直接使用

3. 依赖注入

1. 依赖注入主要用来减少代码间的耦合
2. 有效分离对象和它所需要的外部资源

/**
 * 初步认识
 * Class Person
 * @package app\common\lib
 */
namespace script;
 
class Person
{
    /**
     * 依赖: Person依赖于Car/House
     * 注入: Car/House注入到Person
     * @param $obj
     * @return mixed
     */
    public static function buy($obj){
        return $obj->pay();
    }
}

namespace script;

class Car{
    public function pay(){
        return 1;
    }
}

namespace script;

class House{
    public function pay(){
        return 2;
    }
}

// 当对象注入, 并调用对象的方法
$car = new Car();
$house = new House();
Person::buy($car);
Person::buy($house);

4. 反射机制

1. 利用反射机制可以实例化类以及使用和访问类方法, 属性, 参数和注释等

/**
 * 初步认识反射机制
 * Class A
 * @package script
 */
namespace script;
 
class A
{
    public $a = 1;
    private $b = 2;
    public static $instance = null;
    /**
     * A类的ab方法
     * @param $a
     * @param $b
     * @return string
     */
    public function ab($a, $b){
        return 'a: '.$a .'_b: ' . $b;
    }

    /**
     * type
     * @param int $type
     * @return string
     */
    public function cd($type = 1){
        return 'cd: '. $type;
    }
}

$a = new A();
$obj = new \ReflectionClass($a); //创建A的反射类
$instance = $obj->newInstance(); // 相当于实例化这个类
/**
 * array(2) {
    [0] =>
        class ReflectionMethod#3 (2) {
            public $name =>
                string(2) "ab"
            public $class =>
                string(1) "A"
    }
    [1] =>
        class ReflectionMethod#4 (2) {
            public $name =>
                string(2) "cd"
            public $class =>
                string(1) "A"
    }
}

 */
$methods = $obj->getMethods(); // 获取这个类的所有方法
foreach ($methods as $method){
    $method->getDocComment(); // 获取每个方法的注释
}
$obj->getProperties(); // 获取该类中的所有属性, 公共/私有/静态

// 调用该类中的方法
$instance->ab('123', '456');
// 或者
$method = $obj->getMethod('ab'); // 获取要调用的方法
$method->invokeArgs($instance, ['111', '222']); // 调用带参数的方法, 传入对象和参数
// 调用不带参数的方法
$method = $obj->getMethod('cd');
$method->invoke($instance);

// 创建A的反射类, 并使用A类中的方法
$objMethod = new \ReflectionMethod($a, 'ab');
$objMethod->isPublic(); // 判断某个方法是不是公共的
$objMethod->isStatic(); //判断是否静态方法
$objMethod->getParameters(); // 获取该方法的参数
$objMethod->getNumberOfParameters(); //获取该方法的参数个数

5. 工厂模式

namespace script;
/**
 * 定义一个接口
 * 发送短信接口, 固定方法和参数
 * Interface Sms
 * @package script\sms
 */
interface Sms
{
    public static function send($phone, $code);
}

namespace script;
/**
 * 去实现Sms的方法
 * 阿里短信服务
 * Class Ali
 * @package script\sms
 */
class Ali implements Sms
{
    public static function send($phone, $code){
        //
        return 'Ali-Sms';
    }
}

namespace script;

/**
 * 去实现Sms的方法
 * 七牛短信服务
 * Class Qiniu
 * @package script\sms
 */
class Qiniu implements Sms
{
    public static function send($phone, $code)
    {
        // TODO: Implement send() method.
        return 'Qiniu-Sms';
    }
}

namespace script;

/**
 * 去实现Sms的方法
 * 百度短信服务
 * Class Baidu
 * @package script\sms
 */
class Baidu implements Sms
{
    public static function send($phone, $code)
    {
        // TODO: Implement send() method.
        return 'Baidu-Sms';
    }
}

include 'Sms.php';
$type = 'Ali';
include $type.'.php';
$class = "script\\".$type;
echo $class::send($phone,$code);

6. 容器

namespace script;
/**
 * 容器理解
 * Class Container
 * @package script
 */
class Container
{
    /**
     * 容器中的对象实例
     * @var null
     */
    protected static $instance = null;
    /**
     * 存放容器的数据 (注册树)
     * @var array
     */
    public $objects = [];

    private function __construct()
    {

    }

    /**
     * 获取当前容器的实例
     * 单例模式
     * @return null|Container
     */
    public static function getInstance(){
        if (is_null(self::$instance)){
            self::$instance = new self();
        }

        return self::$instance;
    }

    /**
     * 设置当前容器的数据
     * 挂载到注册树
     * @param $key
     * @param $value
     */
    public function set($key, $value){
        $this->objects[$key] = $value;
    }

    /**
     * 获取当前容器的数据
     * 从注册树中直接获取
     * 反射机制
     * @param $key
     * @return mixed
     */
    public function get($key){

        if ($this->objects[$key]) $key = $this->objects[$key];

        $reflect = new \ReflectionClass($key); // 创建该类的反射类
        // 获取类的构造函数
        $construct = $reflect->getConstructor();
        if (!$construct){
            // 不存在构造函数
            return new $key;
        }

        // 获取构造函数的参数
        $params = $construct->getParameters();
        if (!$params) return new $key;

        $args = [];
        foreach ($params as $param){
            $class = $param->getClass();
            if ($class) {
                $args[] = $this->get($class->name);
            }
        }

        return $reflect->newInstanceArgs($args);

    }
}

// 注入容器
Container::getInstance()->set('person', 'script\Person');
Container::getInstance()->set('car', 'script\Car');
// 获取

$obj = Container::getInstance()->get('person');
var_dump($obj->buy());

namespace script;

/**
 * 初步认识
 * Class Person
 * @package app\common\lib
 */
class Person
{
    public $obj;
    public $name;

    /**
     * 默认Car类
     * Person constructor.
     * @param Car $object
     * @param string $name
     */
    public function __construct(Car $object, $name = 'nobody')
    {
        $this->obj = $object;
        $this->name = $name;
    }

    /**
     * @return string
     */
    public function buy(){
        return $this->name . '|' . $this->obj->pay();
    }
}

namespace script;
class Car{
    public function pay(){
        return 1;
    }
}