PHP开发自己的框架，这些知识点不能错过

最新推荐文章于 2024-03-15 09:42:25 发布
最新推荐文章于 2024-03-15 09:42:25 发布
阅读量561 收藏 2
点赞数
分类专栏： 进阶PHP月薪30k 文章标签： php
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_49163826/article/details/107336492
版权

一、PHP常用的四种数据结构

简介：spl是php的一个标准库。

<?php
 
//spl（php标准库）数据结构
 
/**
 * 栈（先进后出）
 */
$stack = new SplStack();
$stack->push('data1');//入栈（先进后出）
$stack->push('data2');//入栈
$stack->push('data3');//入栈
 
echo $stack->pop();//出栈
echo $stack->pop();//出栈
echo $stack->pop();//出栈
 
 
/**
 *队列(先进先出）
 */
$queue = new SplQueue();
$queue->enqueue('data4');//入队列
$queue->enqueue('data5');//入队列
$queue->enqueue('data6');//入队列
 
echo $queue->dequeue();//出队列
echo $queue->dequeue();//出队列
echo $queue->dequeue();//出队列
echo $queue->dequeue();//出队列
 
 
/**
 * 堆
 */
$heap = new SplMinHeap();
$heap->insert('data8');//入堆
$heap->insert('data9');//入堆
$heap->insert('data10');//入堆
 
echo $heap->extract();//从堆中提取数据
echo $heap->extract();//从堆中提取数据
echo $heap->extract();//从堆中提取数据
 
 
/**
 * 固定数组（不论使不使用，都会分配相应的内存空间）
 */
$array = new SplFixedArray(15);
$array['0'] = 54;
$array['6'] = 69;
$array['10'] = 32;
var_dump($array);

二、PHP链式操作的实现（原理）

1、入口文件 index.php

<?php
/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载
 
 
$db = new \Extend\Database();
$db->where('uid < 100000')->->order('uid desc')->limit(100);

2、自动加载类 Loader.php

<?php
namespace Extend;
/**
 * 实现框架的自动加载
 */
class Loader
{
 /**
 * 实现文件的自动载入
 */
 static function autoload($class)
 {
 require BASEDIR.'/'.str_replace('\\','/',$class).'.php';
 }
 
 
}

3、数据库类Database.php

注：只是原理，并没有对方法进行具体的封装，具体的封装还是看个人喜好去定链式查询的风格。

<?php
namespace Extend;
 
class Database
{
 /**
 * 指定查询条件
 * @param $where
 */
 function where($where)
 {
 return $this;
 }
 
 /**
 * 指定排序条件
 */
 function order($order)
 {
 return $this;
 }
 
 /**
 * 指定查询的限制条数
 * @param $limit
 */
 function limit($limit)
 {
 return $this;
 }
 
 
}

其实就是对传过来的条件进行重新的底层封装，然后再把当前对象返回，使得可以不断的链式查询。

三、PHP魔术方法的使用

在php设计模式中，会涉及到很多魔术方法的使用，这里也对经常会用到的魔术方法进行简单总结。

1、框架入口文件 index.php

<?php
/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载
 
 
/**
 * 魔术方法的使用
 */
 
# 实例化Object类
$obj = new \Extend\Object();//当前文件不存在这个类，就会自动执行自动加载函数去包含相应的类文件(即 Extend/Object.php)
 
 
# __set 和 __get 对不存在的属性进行接管
$obj->title = 'xiaobudiu'; //当对一个不存在的类属性赋值时，会自动调用类中定义的__set()
echo $obj->title; //当调用一个不存在的类属性时，会自动调用类中定义的__get()
 
 
# __call 和 __callStatic 对不存在或者权限不够的类方法进行接管
$obj->getUserInfo('1000068'); //当调用一个不存在的类方法时，会调用__call(),并自动将当前方法名和参数传到__call方法中
\Extend\Object::getOpenId('1000068'); //当调用一个不存在的类静态方法时，会调用__callStatic(),并自动将当前方法名和参数传递到__callStatic方法中
 
 
# echo或print对象时，由__toString 接管
echo $obj; //当echo或print一个对象时，会自动调用类中定义的__toString方法
 
 
# 在php中，如果我们把一个对象当成函数用，则由__invoke()接管
$obj('xiaobudiu');//当我们将一个对象当成函数用的时候，会自动调用当前类中定义的__invoke()方法

2、 Extend/Object.php

<?php
namespace Extend;
/**
 * 要求类名必须和文件名保持一致，即类名是Object，则所在文件名为Object.php
 * Class Object
 * @package Extend
 */
class Object
{
 protected $array = array();
 
 /**
 * 在代码要给未定义的属性赋值时调用,或在类外部修改被private修饰的类属性时被调用
 */
 function __set($name, $value)
 {
 echo "this is __set func";
 }
 
 /**
 * 当在类外部访问被private或proteced修饰的属性或访问一个类中原本不存在的属性时被调用
 * @param $name
 */
 function __get($name)
 {
 echo "this is __get func";
 }
 
 /**
 * 当试图调用不存在的方法或权限不足时会触发__call()
 * @param $name 调用不存在的类方法时那个不存在的类方法的方法名
 * @param $arguments 调用不存在的类方法时传递的参数
 */
 function __call($name, $arguments)
 {
 var_dump($name,$arguments);
 }
 
 
 /**
 * 当试图调用不存在的静态方法或权限不足时会触发__callStatic()
 * @param $name 调用不存在的静态方法时那个不存在的方法的方法名
 * @param $arguments 调用不存在的静态方法时传递的参数
 */
 function __callStatic($name,$arguments)
 {
 var_dump($name,$arguments);
 }
 
 /**
 * 当使用echo或print打印对象时会调用__toString()方法将对象转化为字符串
 */
 function __toString()
 {
 echo "this is __toString func";
 }
 
 
 /**
 * 对象本身不能直接当函数用，如果被当做函数用，会直接回调__invoke方法
 * @param $param
 */
 function __invoke($param)
 {
 echo $param."<br>this is __invoke func";
 }
 
 
}

四、三种基础设计模式

1、工厂模式

通过传入参数的不同，来实例化不同的类。

index.php

<?php
/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载
 
//构造实例化缓存类时传入的参数
$config = array(
 'host' => '127.0.0.1',
 'pass' => 'myRedis&&&'
);
//工厂模式创建cache对象
$cache = Extend\CacheFactory::getCacheObj('redis',$config);
var_dump($cache);

Extend/CacheFactory.php

<?php
namespace Extend;
 
class CacheFactory
{
 const FILE = 1;
 const MEMCACHE = 2;
 const REDIS = 3;
 
 static $instance;//定义静态属性，用于存储对象
 
 /**
 * 工厂类创建缓存对象
 * @param $type 指定缓存类型
 * @param array $options 传入缓存参数
 * @return FileCache|Memcache|RedisCache
 */
 static function getCacheObj($type, array $options)
 {
 switch ($type) {
 case 'file':
 case self::FILE:
 self::$instance = new FileCache($options);
 break;
 
 case 'memcache':
 case self::MEMCACHE:
 self::$instance = new Memcache($options);
 break;
 
 case 'redis':
 case self::REDIS:
 self::$instance = new RedisCache($options);
 break;
 
 default:
 self::$instance = new FileCache($options);
 break;
 
 }
 return self::$instance;
 }
}

2、单例模式

保证一个类只实例化一个类对象，进而减少系统开销和资源的浪费

index.php

<?php
/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载
 
//单例模式创建对象
$obj = Extend\SingleObject::getInstance();
$obj2 = Extend\SingleObject::getInstance();
var_dump($obj,$obj2);//从结果可以看出，两个实例化的对象其实是一个对象

Extend/SingleObject.php

<?php
namespace Extend;
 
/**
 * 单例模式创建唯一类对象
 * Class SingleObject
 * @package Extend
 */
class SingleObject
{
 //私有的静态属性，用于存储类对象
 private static $instance = null;
 
 //私有的构造方法,保证不允许在类外 new
 private function __construct(){}
 
 //私有的克隆方法, 确保不允许通过在类外 clone 来创建新对象
 private function __clone(){}
 
 //公有的静态方法，用来实例化唯一当前类对象
 public static function getInstance()
 {
 if(is_null(self::$instance)){
 self::$instance = new self;
 }
 return self::$instance;
 }
 
}

3、注册树模式

将我们用到的对象注册到注册树上，然后在之后要用到这个对象的时候，直接从注册树上取下来就好。（就和我们用全局变量一样方便）

Extend/RegisterTree,php

<?php
namespace Extend;
 
/**
 * 注册树模式
 * Class RegisterTree
 * @package Extend
 */
class RegisterTree
{
 
 static protected $objects;//静态类属性，用于储存注册到注册树上的对象
 
 /**
 * 将对象注册到注册树上
 * @param $alias 对象的别名
 * @param $object 对象
 */
 static function setObject($alias,$object)
 {
 self::$objects[$alias] = $object;
 }
 
 
 /**
 * 从注册树上取出给定别名相应的对象
 * @param $alias 将对象插入到注册树上时写的别名
 * @return mixed 对象
 */
 static protected function getObject($alias)
 {
 return self::$objects[$alias];
 }
 
 /**
 * 将对象从注册树上删除
 * @param $alias 将对象插入到注册树上时写的别名
 */
 public function unsetObject($alias)
 {
 unset(self::$objects[$alias]);
 }
 
}

五、其他常见的8种PHP设计模式

1、适配器模式

将一个类的接口转换成客户希望的另一个接口,适配器模式使得原本的由于接口不兼容而不能一起工作的那些类可以一起工作。
应用场景：老代码接口不适应新的接口需求，或者代码很多很乱不便于继续修改，或者使用第三方类库。

常见的有两种适配器，分别是类适配器和对象适配器，这里拿更看好的对象适配器举例：

<?php
namespace Extend;
 
/**
 * 对象适配器模式具体流程
 * 1、根据需求定义接口，进而满足新需求功能
 * 2、定义新类，继承并实现定义的接口
 * 3、在实现接口时，原有的功能，只通过原有类对象调用原有类功能（委托）
 * 4、再根据需求，在新类中实现新需求功能
 * 【适用性】
 * （1）你想使用一个已经存在的类，而它的接口不符合你的需求
 * （2）你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类协同工作
 * （3）你想使用一个已经存在的子类，但是不可能对每一个都进行子类化以匹配它们的接口。对象适配器可以适配它的父类接口（仅限于对
 */
 
 
/**
 * 目标角色（根据需求定义含有旧功能加上新功能的接口）
 * Interface Target 我们期望得到的功能类
 * @package Extend
 */
interface Target
{
 public function simpleMethod1();
 public function simpleMethod2();
}
 
/**
 * 源角色（在新功能提出之前的旧功能类和方法）
 * Class Adaptee
 * @package Extend
 */
class Adaptee
{
 
 public function simpleMethod1()
 {
 echo 'Adapter simpleMethod1'."<br>";
 }
 
}
 
/**
 * 类适配器角色（新定义接口的具体实现）
 * Class Adapter
 * @package Extend
 */
class Adapter implements Target
{
 
 private $adaptee;
 
 function __construct()
 {
 //适配器初始化直接new 原功能类，以方便之后委派
 $adaptee = new Adaptee();
 $this->adaptee = $adaptee;
 }
 
 //委派调用Adaptee的sampleMethod1方法
 public function simpleMethod1()
 {
 echo $this->adaptee->simpleMethod1();
 }
 
 public function simpleMethod2()
 {
 echo 'Adapter simpleMethod2'."<br>";
 }
 
}
 
/**
 * 客户端调用
 */
$adapter = new Adapter();
$adapter->simpleMethod1();
$adapter->simpleMethod2();

2、策略模式

将一组特定的行为和算法封装成类，以适应某些特定的上下文环境，这种模式就是策略模式，策略模式可以实现依赖倒置以及控制反转。

实例举例：假如一个电商网站系统，针对男性女性用户要各自跳转到不同的商品类目，并且所有的广告位展示展示不同的广告。

index.php

<?php
 
/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载
 
/**
 * 首页数据控制器
 * Class Index
 */
class Home
{
 /**
 * 最好写上这个注释，告诉phpstorm是对应的哪个接口类，否则虽然程序执行正确，但phpstorm识别不了
 * @var \Extend\UserType
 */
 protected $userType;
 
 /**
 * 首页展示数据
 * 使用策略模式
 * Index constructor.
 */
 function index()
 {
 echo "AD：";
 $this->userType->showAd();
 echo "Category：";
 $this->userType->showCategory();
 }
 
 /**
 * 策略模式
 * 根据传递的用户性别展示不同类别数据
 * @param \Extend\UserType $userType
 */
 function setUserType(\Extend\UserType $userType)
 {
 $this->userType = $userType;
 }
 
}
 
$obj = new Home();
if ($_GET['userType'] == 'female'){
 $userType = new \Extend\FemaleUserType();
} else {
 $userType = new \Extend\MaleUserType();
}
$obj->setUserType($userType);
$obj->index();

Extend/userType.php（定义的接口）

<?php
 
namespace Extend;
 
/**
 * 策略模式
 * 定义根据性别不同展示不同商品类目和广告接口
 * Interface UserType
 * @package Extend
 */
interface UserType
{
 //显示广告
 function showAd();
 //展示类目
 function showCategory();
 
}
MaleUserType.php、FemaleUserType.php（具体实现的类 ）

<?php
 
namespace Extend;
 
/**
 * 定义男性商品类目和广告位数据接口
 * Class MaleUserType
 * @package Extend
 */
class MaleUserType implements UserType
{
 /**
 * 广告栏数据展示
 */
 function showAd()
 {
 echo "this is 男性’s 广告条目数据";
 }
 
 /**
 * 商品类目数据展示
 */
 function showCategory()
 {
 echo "this is 男性’s 商品类目数据";
 }
 
}

<?php
 
namespace Extend;
 
/**
 * 定义女性商品类目和广告位数据接口
 * Class FemaleUserType
 * @package Extend
 */
class FemaleUserType implements UserType
{
 
 /**
 * 广告栏数据展示
 */
 function showAd()
 {
 echo "this is 女性’s 广告条目数据";
 }
 
 /**
 * 商品类目数据展示
 */
 function showCategory()
 {
 echo "this is 女性’s 商品类目数据";
 }
 
 
}

显示效果：
在这里插入图片描述
在这里插入图片描述
3、数据对象映射模式

将对象和数据存储映射起来，对一个对象的操作会映射为对数据存储的操作。

下面在代码中实现数据对象映射模式，我们将实现一个ORM类，将复杂的sql语句映射成对象属性的操作。并结合使用数据对象映射模式、工厂模式、注册模式。

（1）数据库映射模式简单实例实现

index.php

<?php
/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载
 
//使用数据对象映射模式代替写sql
$user = new Extend\User(25);
$user->name = '小卜丢饭团子';
$user->salary = '20000';
$user->city = '浙江省';

Extend/User.php

<?php
 
namespace Extend;
 
class User
{
 //对应数据库中的4个字段
 public $id;
 public $name;
 public $salary;
 public $city;
 //存储数据库连接对象属性
 protected $pdo;
 
 public $data;
 
 function __construct($id)
 {
 $this->id = $id;
 $this->pdo = new \PDO('mysql:host=127.0.0.1;dbname=test','root','123456');
 }
 
 function __destruct()
 {
 $this->pdo->query("update user set name = '{$this->name}',salary = '{$this->salary}',city = '{$this->city}' where id='{$this->id}'");
 }
}

这样，执行index.php文件，数据库就会发生相应的操作，也就实现了基本的数据对象映射。

（2）数据库映射模式复杂案例实现

index.php

<?php
 
/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载
 
 
class EX
{
 function index()
 {
 //使用数据对象映射模式代替写sql
 $user = Extend\Factory::getUserObj(25);
 $user->name = '小卜丢饭团子';
 $user->salary = '20000';
 $user->city = '浙江省';
 }
 
 function test()
 {
 $user = Extend\Factory::getUserObj(25);
 $user->city = '广东省';
 }
 
}
 
$ex = new EX();
$ex->index();

Extend/Factory.php

<?php
 
namespace Extend;
 
class Factory
{
 /**
 * 工厂模式创建数据库对象，单例模式保证创建唯一db对象
 * @return mixed
 */
 static function CreateDatabaseObj()
 {
 $db = Database::getInstance();
 return $db;
 }
 
 /**
 * 工厂模式创建user对象，注册树模式保证创建唯一对象，避免资源浪费
 * @param $id
 * @return User|mixed
 */
 static function getUserObj($id)
 {
 $key = 'user'.$id;
 $user = RegisterTree::getObject($key);
 if (!$user) {
 $user = new User($id);
 RegisterTree::setObject($key,$user);
 }
 return $user;
 }
}

Extend/Register.php

<?php
 
namespace Extend;
 
/**
 * 注册树模式
 * Class RegisterTree
 * @package Extend
 */
class RegisterTree
{
 static protected $objects;//静态类属性，用于储存注册到注册树上的对象
 
 /**
 * 将对象注册到注册树上
 * @param $alias 对象的别名
 * @param $object 对象
 */
 static function setObject($alias,$object)
 {
 self::$objects[$alias] = $object;
 }
 
 
 /**
 * 从注册树上取出给定别名相应的对象
 * @param $alias 将对象插入到注册树上时写的别名
 * @return mixed 对象
 */
 static function getObject($alias)
 {
 return self::$objects[$alias];
 }
 
 /**
 * 将对象从注册树上删除
 * @param $alias 将对象插入到注册树上时写的别名
 */
 public function unsetObject($alias)
 {
 unset(self::$objects[$alias]);
 }
 
}

Extend/User.php

<?php
 
namespace Extend;
 
class User
{
 //对应数据库中的4个字段
 public $id;
 public $name;
 public $salary;
 public $city;
 //存储数据库连接对象属性
 protected $pdo;
 
 public $data;
 
 function __construct($id)
 {
 $this->id = $id;
 $this->pdo = new \PDO('mysql:host=127.0.0.1;dbname=test','root','123456');
 }
 
 function __destruct()
 {
 $this->pdo->query("update user set name = '{$this->name}',salary = '{$this->salary}',city = '{$this->city}' where id='{$this->id}'");
 }
}

这样，就实现了稍复杂的数据对象映射模式和工厂模式、注册树模式相结合的案例。

4、观察者模式

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

场景：一个事件发生后，要执行一连串更新操作。传统的编程方式就是在事件的代码之后直接加入处理逻辑，当更新的逻辑增多之后，代码会变的难以维护。这种方式是耦合的，侵入式的，增加新的逻辑需要修改事件主体的代码。观察者模式实现了低耦合，非侵入式的通知与更新机制。

4.1、传统模式举例：

<?php

/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载


/**
 * 一个事件的逻辑控制器
 * Class Event
 */
class Event
{
    /**
     * 用户确认订单
     */
    function firmOrder()
    {
        //这里假设一个事件发生了，比如用户已经完成下单
        echo "用户已下单<br>";
        //传统方式是在发生一个事件之后直接进行一系列的相关处理，耦合度比较高，比如写入日志，给用户发邮件等等
        echo "在用户下单之后进行的一系列操作<br>";
    }

}

$event = new Event();
$event->firmOrder();

4.2、观察者模式典型实现方式：

（1）定义2个接口：观察者（通知）接口、被观察者（主题）接口

（2）定义2个类，观察者类实现观察者接口、被观察者类实现被观察者接口

（3）被观察者注册自己需要通知的观察者

（4）被观察者类某个业务逻辑发生时，通知观察者对象，进而每个观察者执行自己的业务逻辑。

代码示例：

test.php

<?php
/**
 * 观察者模式场景描述：
 * 1、购票后记录文本日志
 * 2、购票后记录数据库日志
 * 3、购票后发送短信
 * 4、购票送抵扣卷、兑换卷、积分
 * 5、其他各类活动等
 */
 
 
/**
 * 观察者接口
 */
interface TicketObserver
{
 function buyTicketOver($sender, $args); //得到通知后调用的方法
}
 
/**
 * 被观察者接口（购票主题接口）
 */
interface TicketObserved
{
 function addObserver($observer); //提供注册观察者方法
}
 
 
/**
 * 主体逻辑，继承被观察者接口
 * Class BuyTicket
 */
class BuyTicket implements TicketObserved
{
 
 /**
 * 定义观察者数组属性，用于储存观察者
 * @var array
 */
 private $observers = array();
 
 
 /**
 * 实现被观察者接口定义的方法（添加观察者）
 * @param $observer 实例化后的观察者对象
 */
 public function addObserver($observer)
 {
 $this->observers[] = $observer;
 }
 
 
 /**
 * 购票主体方法
 * BuyTicket constructor.
 * @param $ticket 购票排号
 */
 public function buyTicket($ticket)
 {
 //1、根据需求写购票逻辑
 //..............
 
 //2、购票成功之后，循环通知观察者，并调用其buyTicketOver实现不同业务逻辑
 foreach ($this->observers as $observe) {
 $observe->buyTicketOver($this, $ticket); //$this 可用来获取主题类句柄，在通知中使用
 }
 
 }
 
}
 
 
 
/**
 * 购票成功后，发送短信通知
 * Class buyTicketMSN
 */
class buyTicketMSN implements TicketObserver
{
 public function buyTicketOver($sender, $ticket)
 {
 echo (date ( 'Y-m-d H:i:s' ) . " 短信日志记录：购票成功:$ticket<br>");
 }
}
 
/**
 * 购票成功后，记录日志
 * Class buyTicketLog
 */
class buyTicketLog implements TicketObserver
{
 public function buyTicketOver($sender, $ticket) 
 {
 echo (date ( 'Y-m-d H:i:s' ) . " 文本日志记录：购票成功:$ticket<br>");
 }
}
 
 
/**
 * 购票成功后，赠送优惠券
 * Class buyTicketCoupon
 */
class buyTicketCoupon implements TicketObserver
{
 public function buyTicketOver($sender, $ticket) 
 {
 echo (date ( 'Y-m-d H:i:s' ) . " 赠送优惠券：购票成功:$ticket 赠送10元优惠券1张。<br>");
 }
}
 
 
//实例化购票类
$buy = new BuyTicket();
//添加多个观察者
$buy->addObserver(new buyTicketMSN());
$buy->addObserver(new buyTicketLog());
$buy->addObserver(new buyTicketCoupon());
//开始购票
$buy->buyTicket ("7排8号");

浏览器显示结果：
在这里插入图片描述
5、原型模式

原型模式与工厂模式的作用类似，都是用来创建对象的。但是实现方式是不同的。原型模式是先创建好一个原型对象，然后通过clone原型对象来创建新的对象。这样，就免去了类创建时重复的初始化操作。

原型模式适用于大对象的创建，创建一个大对象需要很大的开销，如果每次new就会消耗很大，原型模式仅需内存拷贝即可。

代码实例：

<?php
/**
 * 抽象原型角色
 */
interface Prototype
{
 public function copy();
}
 
/**
 * 具体原型角色
 */
class ConcretePrototype implements Prototype
{
 
 private $_name;
 
 public function __construct($name)
 {
 $this->_name = $name;
 }
 
 public function setName($name)
 {
 $this->_name = $name;
 }
 
 public function getName()
 {
 return $this->_name;
 }
 
 public function copy()
 {
 //深拷贝实现
 //$serialize_obj = serialize($this); // 序列化
 //$clone_obj = unserialize($serialize_obj); // 反序列化
 //return $clone_obj;
 
 // 浅拷贝实现
 return clone $this;
 }
 
}
 
/**
 * 测试深拷贝用的引用类
 */
class Demo
{
 public $array;
}
 
 
//测试
$demo = new Demo();
$demo->array = array(1, 2);
$object1 = new ConcretePrototype($demo);
$object2 = $object1->copy();
 
var_dump($object1->getName());
echo '<br />';
var_dump($object2->getName());
echo '<br />';
 
$demo->array = array(3, 4);
var_dump($object1->getName());
echo '<br />';
var_dump($object2->getName());
echo '<br />';

浏览器显示结果：
在这里插入图片描述
6、装饰器模式

可以动态的添加或修改类的功能

一个类实现一个功能，如果要再修改或添加额外的功能，传统的编程模式需要写一个子类继承它，并重新实现类的方法。

使用装饰器模式，仅需在运行时添加一个装饰器对象即可实现，可以实现最大的灵活性。

<?php
/**
 * 装饰器流程
 * 1、声明装饰器接口（装饰器接口）
 * 2、具体类继承并实现装饰器接口（颜色装饰器实现，字体大小装饰器实现）
 * 3、在被装饰者类中定义"添加装饰器"方法（EchoText类中的addDecorator方法）
 * 4、在被装饰者类中定义调用装饰器的方法（EchoText类中的beforeEcho和afterEcho方法）
 * 5、使用时，实例化被装饰者类，并传入装饰器对象（比如new ColorDecorator('yellow'))
 */
 
/**
 * 装饰器接口
 * Class Decorator
 */
interface Decorator
{
 public function beforeEcho();
 public function afterEcho();
}
 
/**
 * 颜色装饰器实现
 * Class ColorDecorator
 */
class ColorDecorator implements Decorator
{
 protected $color;
 
 public function __construct($color)
 {
 $this->color = $color;
 }
 
 public function beforeEcho()
 {
 echo "<dis style='color: {$this->color}'>";
 }
 
 public function afterEcho()
 {
 echo "</p>";
 }
}
 
/**
 * 字体大小装饰器实现
 * Class SizeDecorator
 */
class SizeDecorator implements Decorator
{
 protected $size;
 
 public function __construct($size)
 {
 $this->size = $size;
 }
 
 public function beforeEcho()
 {
 echo "<dis style='font-size: {$this->size}px'>";
 }
 
 public function afterEcho()
 {
 echo "</p>";
 }
}
 
/**
 * 被装饰者
 * 输出一个字符串
 * 装饰器动态添加功能
 * Class EchoText
 */
class EchoText
{
 protected $decorators = array();//存放装饰器
 
 //装饰方法
 public function Index()
 {
 //调用装饰器前置操作
 $this->beforeEcho();
 echo "你好，我是装饰器。";
 //调用装饰器后置操作
 $this->afterEcho();
 }
 
 //添加装饰器
 public function addDecorator(Decorator $decorator)
 {
 $this->decorators[] = $decorator;
 }
 
 //执行装饰器前置操作 先进先出原则
 protected function beforeEcho()
 {
 foreach ($this->decorators as $decorator)
 $decorator->beforeEcho();
 }
 
 //执行装饰器后置操作 先进后出原则
 protected function afterEcho()
 {
 $tmp = array_reverse($this->decorators);
 foreach ($tmp as $decorator)
 $decorator->afterEcho();
 }
}
 
//实例化输出类
$echo = new EchoText();
//增加装饰器
$echo->addDecorator(new ColorDecorator('yellow'));
//增加装饰器
$echo->addDecorator(new SizeDecorator('22'));
//输出
$echo->Index();

7、迭代器模式

在不需要了解内部实现的前提下，遍历一个聚合对象的内部元素而又不暴露该对象的内部表示，这就是PHP迭代器模式的定义。

相对于传统编程模式，迭代器模式可以隐藏遍历元素的所需的操作。

index.php

<?php
/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载
 
$users = new Extend\AllUser();
//循环遍历出所有用户数据
foreach ($users as $user) {
 var_dump($user);
}

Extend/AllUser.php

<?php
namespace Extend;
 
/**
 * 迭代器模式，继承php内部自带的迭代器接口（\Iterator）
 * Class AllUser
 * @package Extend
 */
class AllUser implements \Iterator
{
 protected $index = 0;//表示索引
 protected $ids = array();//用于储存所有user的id（实际应用中，可以采用注册树模式进行存储）
 protected $pdo;//用于存储数据库对象
 
 function __construct()
 {
 //获取pdo数据库对象
 $this->pdo = new \PDO('mysql:host=127.0.0.1;dbname=test','root','123456');
 //获取所有用户的id
 $this->ids = $this->pdo->query("select id from user")->fetchAll(2);
 }
 
 /**
 * 实现接口方法，重置迭代器，回到集合开头
 */
 public function rewind()
 {
 $this->index = 0;
 }
 
 /**
 * 实现接口方法，获取当前元素
 * @return mixed|void
 */
 public function current()
 {
 $id = $this->ids[$this->index]['id'];
 //获取当前用户的数据
 $user_data = $this->pdo->query("select * from user where id='{$id}'")->fetch(2);
 return $user_data;
 }
 
 /**
 * 实现接口方法，获取当前元素键值
 * @return mixed|void
 */
 public function key()
 {
 return $this->index;
 }
 
 /**
 * 实现接口方法，获取下一个元素
 */
 public function next()
 {
 $this->index++;
 }
 
 /**
 * 实现接口方法，验证是否还有下一个元素
 * @return bool|void
 */
 public function valid()
 {
 return $this->index < count($this->ids);
 }
 
}

8、代理模式

在客户端与实体之间建立一个代理对象（proxy），客户端对实体进行操作全部委派给代理对象，隐藏实体的具体实现细节。

典型的应用就是mysql的主从结构，读写分离。在mysql中，对所有读的操作请求从库，所有写的操作请求主库。

声明一个代理类，前台使用时只需创建一个代理类，调用对应方法即可。代码实例：

index.php

<?php
/**
 * 框架入口文件
 */
define('BASEDIR',__DIR__);//项目根目录
include BASEDIR.'/Extend/Loader.php';//引入项目自动加载类文件
spl_autoload_register('\\Extend\\Loader::autoload');//执行自动加载函数，完成类的自动加载
 
// 1、传统编程模式是手动选择
#查询操作使用从库
//$db_slave = Extend\Factory::getDatabase('slave');
//$info = $db_slave->query("select * from user where id = 1 limit 1");
#增删改操作使用主库
//$db_master = Extend\Factory::getDatabase('master');
//$db_master->query("update user name = 'xiaobudiu' where id = 29 limit 1");
 
 
// 2、使用代理模式
$db_proxy = new Extend\Proxy();
$db_proxy->getUserName(1);
$db_proxy->setUserName(29,'xiaobudiu');

Extend/Proxy.php

<?php
namespace Extend;
 
class Proxy implements IUserProxy
{
 function getUserName($id)
 {
 $db = Factory::getDatabase('slave');
 $db->query("select name from user where id =$id limit 1");
 }
 
 function setUserName($id, $name)
 {
 $db = Factory::getDatabase('master');
 $db->query("update user set name = $name where id =$id limit 1");
 }
}

Extend/Factory.php

<?php
namespace Extend;
 
class Factory
{
 static function getDatabase($id)
 {
 $key = 'database_'.$id;
 if ($id == 'slave')
 {
 $slaves = Application::getInstance()->config['database']['slave'];
 $db_conf = $slaves[array_rand($slaves)];
 } else {
 $db_conf = Application::getInstance()->config['database'][$id];
 }
 //注册树模式存储及获取对象
 $db = Register::get($key);
 if (!$db) {
 $db = new Database\MySQLi();
 $db->connect($db_conf['host'], $db_conf['user'], $db_conf['password'], $db_conf['dbname']);
 Register::set($key, $db);
 }
 return $db;
 }
 
}

Extend/Application.php

<?php
namespace Extend;
 
class Application
{
 public $base_dir;
 protected static $instance;
 
 public $config;
 
 protected function __construct($base_dir)
 {
 $this->base_dir = $base_dir;
 $this->config = new Config($base_dir.'/configs');
 }
 
 static function getInstance($base_dir = '')
 {
 if (empty(self::$instance))
 {
 self::$instance = new self($base_dir);
 }
 return self::$instance;
 }
  
}

Extend/Config.php

<?php
namespace Extend;
 
/**
 * 配置类，继承于php自带的ArrayAccess接口
 * 允许一个对象以数组的方式访问
 * Class Config
 * @package Extend
 */
class Config implements \ArrayAccess
{
 protected $path;
 protected $configs = array();
 
 function __construct($path)
 {
 $this->path = $path;
 }
 
 function offsetGet($key)
 {
 if (empty($this->configs[$key]))
 {
 $file_path = $this->path.'/'.$key.'.php';
 $config = require $file_path;
 $this->configs[$key] = $config;
 }
 return $this->configs[$key];
 }
 
 function offsetSet($key, $value)
 {
 throw new \Exception("cannot write config file.");
 }
 
 function offsetExists($key)
 {
 return isset($this->configs[$key]);
 }
 
 function offsetUnset($key)
 {
 unset($this->configs[$key]);
 }
}

configs/database.php

<?php
$config = array(
    'master' => array(
        'type' => 'MySQL',
        'host' => '127.0.0.1',
        'user' => 'root',
        'password' => '123456',
        'dbname' => 'test',
    ),
    'slave' => array(
        'slave1' => array(
            'type' => 'MySQL',
            'host' => '127.0.0.1',
            'user' => 'root',
            'password' => '123456',
            'dbname' => 'test',
        ),
        'slave2' => array(
            'type' => 'MySQL',
            'host' => '127.0.0.1',
            'user' => 'root',
            'password' => '123456',
            'dbname' => 'test',
        ),
    ),
);
return $config;

以上内容希望有帮助到大家，很多PHPer在进阶的时候总会遇到一些问题和瓶颈，业务代码写多了没有方向感，不知道该从那里入手去提升，对此我整理了一些资料，包括但不限于：分布式架构、高可扩展、高性能、高并发、服务器性能调优、TP6，laravel，YII2，Redis，Swoole、Swoft、Kafka、Mysql优化、shell脚本、Docker、微服务、Nginx等多个知识点高级进阶干货需要的可以免费分享给大家，需要的可以加入我的官方群领取哦，资料详情戳此处进阶PHP月薪30k>>>架构师成长路线【视频、面试文档免费获取】

it阿布
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
php重要知识点总结PHP网络开发必背.doc
12-02
php重要知识点总结PHP网络开发必背.doc
从此不求人:自主研发一套PHP前端开发框架
06-08
本课程把我们公司团队的自主研发一套PHP开发框架进行简化和适应性修改后，奉献给大家。并从思路、设计、编码和部署测试每个过程给大家详细讲解。框架纯实战级，实用、简单、暴力。并支持插件化开发，功能还支持微信...
PHP - 从零开始编写自己的PHP框架 - 学习/实践
william_n的博客
03-29 5468
自己动手编写一个框架, 帮助学习思考目前常用框架的架构，更加熟悉PHP脚本语言, 学习理解设计思想, 设计原则, 设计模式.
php从零开发框架,从零开始打造自己的PHP框架——第0章
weixin_39619481的博客
03-17 87
前言使用过thinkphp和yii，涉猎过shopnc。市场上已经有了这么多好的框架，为什么还要开发自己的框架？答：假装大神。为了在装神的道路上走的更远，小编决定开发一个自己的php框架，命名为vkphp。框架运行流程1、入口文件2、定义常量3、引入函数库4、自动加载类5、启动框架6、路由解析7、加载控制器8、返回结果helloworld集成环境集成开发环境使用laragon，在www目录下新建v...
ThinkPHP：快速、稳定的 PHP 开发框架
gitblog_00053的博客
03-15 243
ThinkPHP：快速、稳定的 PHP 开发框架 ThinkPHP 是一个基于 MVC（Model-View-Controller）模式的轻量级 PHP 开发框架，旨在简化开发过程并提高代码复用性。它提供了一系列强大和实用的功能，适用于 Web 应用程序和 API 的开发。 项目介绍 ThinkPHP 提供了简单易用的接口和灵活的配置，使得开发者可以专注于业务逻辑和实现细节，而无需关注底层实现。...
一个极简的php框架
新安浅滩的博客
06-11 1819
文章目录php极简框架单一入口路由控制自动加载具体实现后期扩展 php极简框架 使用框架进行更加高效的开发，功能完善的框架能够较大的减少开发的业务量，增强代码的可维护性。近期工作使用到php，实现了一个极简的php框架，在这里总结如下。 Common：常用函数的封装 Tool.php Ctrl：控制器 BaseCtrl.php 基础控制器，包含基本方法 Lib：核心方法 Lo...
做一个php 框架 书,开发自己的php框架
weixin_35117321的博客
03-09 256
[toc]出发点：我个人理解 自己开发框架也是锻炼原生的一种手段。写完之后看别的框架也方便多了。如果你遇到一个没有文档或文档极少的框架，可以跟着这个思路摸索着补充。或干脆拿着原生上来就是干，我刚接触yii2的时候就是这样，都没来的及看文档就开工了，基本纯原生写的，就用了个yii2的csrf和双语言...>[info]源码下载地址：https://github.com/yxgg/-frame#...
PHP 变量注释/**@var*/
Gan_1314的博客
08-09 1201
PHP中定义数组类型变量时，可以定义数组内元素的类型
php重要知识点总结(PHP网络开发必背).doc
06-20
php重要知识点总结(PHP网络开发必背).doc
基于ThinkPHP5的PHP开发框架设计源码
最新发布
04-06
本项目是一个基于ThinkPHP5的PHP开发框架设计，包含150个文件，主要文件类型包括PHP源代码、图片、字体文件、Git忽略文件、模板文件、文本文件、YAML配置文件、Markdown文档、JSON配置文件和打包文件。ThinkPHP5是一...
浅谈php常用的7大框架的优缺点
12-17
一直以来，phper讨论最多的就是php各种框架的优缺点，网上的资料也是比较零散，现把几款主流的框架收集汇总一下，其中本人只是用过Yii2、Laravel、Yaf、Thinkphp这四种框架，因此大部分对各种框架的评价皆来自与网上资料，如果问题，请在评论中指出，共同进步 一、ThinkPHP ThinkPHP(FCS)是一个轻量级的中型框架，是从Java的Struts结构移植过来的中文PHP开发框架。它使用面向对象的开发结构和MVC模式，并且模拟实现了Struts的标签库，各方面都比较人性化，熟悉J2EE的开发人员相对比较容易上手，适合php框架初学者。 ThinkPHP的宗旨是简化开发、提高
自己编写php框架（uniphp），实现了cms希望大家支持
09-02
自己编写php框架（uniphp），实现了cms希望大家支持，大家也可以去github：https://github.com/lizhilicctv/uniphp_cms2 ，或者，码云仓库：https://gitee.com/lizhiliwo/uniphp_cms2，下载了解如果有不明白的也可以和我联系，[email protected]。给我点赞支持，谢谢大家。
PHP最主流的10个框架，其发展历史及主要特点
黑夜开发者的博客
06-07 6958
PHP快速入门与实战在这篇博客中，我们将介绍PHP十大主流框架，同时在本专栏的后续内容里面，会对这些框架的设计思想及底层源码进行深度的分析，欢迎大家先点个关注。
laravel框架脚本后台执行_php常用的7大框架
weixin_39989875的博客
12-21 507
一直以来，phper讨论最多的就是php各种框架的优缺点，网上的资料也是比较零散，现把几款主流的框架收集汇总一下，其中本人只是用过Yii2、Laravel、Yaf、Thinkphp这四种框架，因此大部分对各种框架的评价皆来自与网上资料，如果问题，请在评论中指出，共同进步一、ThinkPHPThinkPHP(FCS)是一个轻量级的中型框架，是从Java的Struts结构移植过来的中文PHP...
分享13款PHP开发框架
东垂小夫
04-09 661
创建应用程序是一个复杂且耗时的过程，如果开发者能利用好框架，那么就可以在一个统一的结构基础上通过重用通用组件和模块来快速地做好项目。省掉创建通用组件的时间和人力，软件开发者可以把更多的时间投入到具体的项目上去，这样开发者就能专注于开发高质量的代码。 现在，我们就来介绍13个最佳PHP框架来帮助开发者建立互操作或灵活的应用。 1. Laravel 这是一款简洁、“优雅”的PHP开发框架
基于PHP和laravel开发框架的CMS系统（内容管理系统）
毕业作品网站
11-30 1081
该系统在性能功能上应达到如下需求：操作简单、界面友好，使得新闻的录入工作更简便，许多选项包括文章分类、文章列表、文章出处等只需要点击鼠标就可以完成；任何人可以浏览新闻，浏览者可以注册成为系统会员，注册后可对新闻进行评论。管理员在后台可以对新闻、评论、注册会员进行管理，如修改、删除等。CMS具有许多基于模板的优秀设计，可以加快网站开发的速度和减少开发的成本。CMS其实是一个很广泛的称呼，从一般的博客程序，新闻发布程序，到综合性的网站管理程序都可以被称为内容管理系统。5.1.2登录界面元素 32。
10个流行的PHP框架
xiaoyi9812的博客
04-04 3301
PHP框架是一种Web开发工具，它为开发人员提供了一些常用的功能和工具，例如路由、模板引擎、ORM等等，使得开发人员可以更快速地构建Web应用程序。Slim的文档也非常详细，易于学习和使用。Zend Framework是一个成熟的PHP框架，它提供了许多强大的功能和工具，例如路由、ORM、缓存等等。CakePHP是一个非常流行的PHP框架，它提供了许多强大的功能和工具，例如路由、ORM、缓存等等。Yii是一个高性能的PHP框架，它采用了MVC模式，提供了许多常用的功能和工具，例如路由、缓存、安全等等。
php微信公众号开发框架
01-14
PHP微信公众号开发框架是一种基于PHP语言开发的工具，用于快速、高效地开发微信公众号应用程序。它提供了丰富的功能和组件，简化了开发流程，帮助开发者快速构建出专业、稳定的微信公众号应用。 这个框架通常包括了...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值