PHP 设计模式

 1<?php
 2 
 3class Singleton
 4{
 5  /**
 6   * 自身实例
 7   * 
 8   * @var object
 9   */
10  private static $_instance;
11 
12  /**
13   * 魔法方法
14   * 禁止clone对象
15   * 
16   * @return string
17   */
18  public function __clone()
19  {
20    echo 'clone is forbidden';
21  }
22 
23  /**
24   * 获取实例
25   * 
26   * @return object
27   */
28  public static function getInstance()
29  {
30    if (!self::$_instance instanceof self) {
31      self::$_instance = new self;
32    }
33    return self::$_instance;
34  }
35 
36  /**
37   * 测试方法
38   * 
39   * @return string
40   */
41  public function test()
42  {
43    echo "这是个测试 \n";
44  }
45}
46 
47// 获取单例
48$instance = Singleton::getInstance();
49$instance->test();
50 
51// clone对象试试
52$instanceClone = clone $instance;

 1<?php
 2/**
 3 * 创建型模式
 4 * 工厂方法模式和抽象工厂模式的核心区别
 5 * 工厂方法模式利用继承，抽象工厂模式利用组合
 6 * 工厂方法模式产生一个对象，抽象工厂模式产生一族对象
 7 * 工厂方法模式利用子类创造对象，抽象工厂模式利用接口的实现创造对象
 8 * 工厂方法模式可以退化为简单工厂模式(非23中GOF)
 9 *
10 * php工厂模式
11 * @author  TIGERB <https://github.com/TIGERB>
12 * @author  jealone <https://github.com/jealone>
13 * @example 运行 php test.php
14 */
15 
16 
17// 注册自加载
18spl_autoload_register('autoload');
19 
20function autoload($class)
21{
22    require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
23}
24 
25/************************************* test *************************************/
26 
27use factory\Farm;
28use factory\Zoo;
29use factory\SampleFactory;
30 
31// 初始化一个工厂
32$farm = new Farm();
33 
34// 生产一只鸡
35$farm->produce('chicken');
36// 生产一只猪
37$farm->produce('pig');
38 
39// 初始化一个动物园工厂
40$zoo = new Zoo();
41$zoo->produce("chicken");
42$zoo->produce("pig");
43 
44// 工厂方法模式退化为简单工厂模式
45SampleFactory::produce("chicken");
46SampleFactory::produce("pig");

 1<?php
 2/**
 3 * 创建型模式
 4 *
 5 * php抽象工厂模式
 6 *
 7 * 说说我理解的工厂模式和抽象工厂模式的区别：
 8 * 工厂就是一个独立公司，负责生产对象；
 9 * 抽象工厂就是集团，负责生产子公司（工厂）；
10 
11 * @author  TIGERB <https://github.com/TIGERB>
12 * @example 运行 php test.php
13 */
14 
15 
16// 注册自加载
17spl_autoload_register('autoload');
18 
19function autoload($class)
20{
21    require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
22}
23 
24/************************************* test *************************************/
25 
26use factoryAbstract\AnimalFactory;
27use factoryAbstract\PlantFactory;
28 
29// 初始化一个动物生产线, 包含了一族产品
30$animal = new AnimalFactory();
31 
32// 初始化一个植物生产线, 包含了一族产品
33$plant = new PlantFactory();
34 
35// 模拟调用， 抽象工厂模式核心是面向接口编程
36function call(factoryAbstract\Factory $factory) {
37    $earn = function(factoryAbstract\Income $income) {
38        $income->money();
39    };
40    $earn($factory->createFarm());
41    $earn($factory->createZoo());
42}
43 
44call($animal);
45call($plant);

 1<?php
 2/**
 3 * 创建型模式
 4 *
 5 * php原型模式
 6 * 用于创建对象成本过高时
 7 *
 8 * @author  TIGERB <https://github.com/TIGERB>
 9 * @example 运行 php test.php
10 */
11 
12 
13// 注册自加载
14spl_autoload_register('autoload');
15 
16function autoload($class)
17{
18  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
19}
20 
21/************************************* test *************************************/
22 
23use prototype\Prototype;
24 
25// 创建一个原型对象
26$prototype = new Prototype();
27 
28// 获取一个原型的clone
29$prototypeCloneOne = $prototype->getPrototype();
30$prototypeCloneOne->_name = 'one';
31$prototypeCloneOne->getName();
32 
33// 获取一个原型的clone
34$prototypeCloneTwo = $prototype->getPrototype();
35$prototypeCloneTwo->_name = 'two';
36$prototypeCloneTwo->getName();
37 
38// 再次获取$prototypeCloneOne的名称
39$prototypeCloneOne->getName();

 1<?php
 2/**
 3 * 创建型模式
 4 *
 5 * php建造者模式
 6 * 简单对象构建复杂对象
 7 * 基本组件不变，但是组件之间的组合方式善变
 8 *
 9 * 下面我们来构建手机和mp3
10 *
11 * // 手机简单由以下构成
12 * 手机 => 名称，硬件， 软件
13 * // 硬件又由以下硬件构成
14 * 硬件 => 屏幕，cpu, 内存， 储存， 摄像头
15 * // 软件又由以下构成
16 * 软件 => android, ubuntu
17 *
18 * * // mp3简单由以下构成
19 * 手机 => 名称，硬件， 软件
20 * // 硬件又由以下硬件构成
21 * 硬件 => cpu, 内存， 储存
22 * // 软件又由以下构成
23 * 软件 => mp3 os
24 * 
25 * builder 导演类
26 *
27 * @author  TIGERB <https://github.com/TIGERB>
28 * @example 运行 php test.php
29 */
30 
31 
32// 注册自加载
33spl_autoload_register('autoload');
34 
35function autoload($class)
36{
37  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
38}
39 
40/************************************* test *************************************/
41 
42use builder\ProductBuilder;
43 
44$builder = new ProductBuilder();
45 
46// 生产一款mp3
47$builder->getMp3([
48  'name' => '某族MP3',
49  'hardware' => [
50    'cpu'     => 1,
51    'ram'     => 1,
52    'storage' => 128,
53  ],
54  'software' => ['os' => 'mp3 os']
55]);
56 
57echo "\n";
58echo "----------------\n";
59echo "\n";
60 
61// 生产一款手机
62$builder->getPhone([
63  'name' => '某米8s',
64  'hardware' => [
65    'screen'  => '5.8',
66    'camera'  => '2600w',
67    'cpu'     => 4,
68    'ram'     => 8,
69    'storage' => 128,
70  ],
71  'software' => ['os' => 'android 6.0']
72]);

 1<?php
 2/**
 3 * 结构型模式
 4 *
 5 * php桥接模式
 6 * 基础的结构型设计模式：将抽象和实现解耦,对抽象的实现是实体行为对接口的实现
 7 * 例如：人 => 抽象为属性：性别 动作：吃 => 人吃的动作抽象为interface => 实现不同的吃法
 8 *
 9 * @author  TIGERB <https://github.com/TIGERB>
10 * @example 运行 php test.php
11 */
12 
13 
14// 注册自加载
15spl_autoload_register('autoload');
16 
17function autoload($class)
18{
19  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
20}
21 
22/************************************* test *************************************/
23 
24use bridge\PersonMale;
25use bridge\EatByChopsticks;
26use bridge\EatByFork;
27 
28try {
29  // 初始化一个用筷子吃饭的男人的实例
30  $male = new PersonMale('male', new EatByChopsticks());
31  // 吃饭
32  $male->eat('大盘鸡');
33 
34} catch (\Exception $e) {
35  echo $e->getMessage();
36}

 1<?php
 2/**
 3 * 结构型模式
 4 *
 5 * php享元（轻量级）模式
 6 * 就是缓存了创建型模式创建的对象，不知道为什么会归在结构型模式中，个人觉得创建型模式更合适，哈哈～
 7 * 其次，享元强调的缓存对象，外观模式强调的对外保持简单易用，是不是就大体构成了目前牛逼哄哄且满大
 8 * 的街【依赖注入容器】
 9 *
10 * 下面我们借助最简单的’工厂模式‘来实现享元模式，就是给工厂加了个缓存池
11 *
12 * @author  TIGERB <https://github.com/TIGERB>
13 * @example 运行 php test.php
14 */
15 
16 
17// 注册自加载
18spl_autoload_register('autoload');
19 
20function autoload($class)
21{
22  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
23}
24 
25/************************************* test *************************************/
26 
27use flyweight\Farm;
28 
29// 初始化一个工厂
30$farm = new Farm();
31 
32// 成产一只鸡
33$farm->produce('chicken')->getType();
34// 再生产一只鸡
35$farm->produce('chicken')->getType();

 1<?php
 2/**
 3 * 结构型模式
 4 *
 5 * php外观模式
 6 * 把系统中类的调用委托给一个单独的类，对外隐藏了内部的复杂性，很有依赖注入容器的感觉哦
 7 *
 8 * @author  TIGERB <https://github.com/TIGERB>
 9 * @example 运行 php test.php
10 */
11 
12 
13// 注册自加载
14spl_autoload_register('autoload');
15 
16function autoload($class)
17{
18  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
19}
20 
21/************************************* test *************************************/
22 
23use facade\AnimalMaker;
24 
25// 初始化外观类
26$animalMaker = new AnimalMaker();
27 
28// 生产一只猪
29$animalMaker->producePig();
30 
31// 生产一只鸡
32$animalMaker->produceChicken();

 1<?php
 2/**
 3 * 结构型模式
 4 *
 5 * php适配器模式
 6 * 把实现了不同接口的对象通过适配器的方式组合起来放在一个新的环境
 7 *
 8 * @author  TIGERB <https://github.com/TIGERB>
 9 * @example 运行 php test.php
10 */
11 
12 
13// 注册自加载
14spl_autoload_register('autoload');
15 
16function autoload($class)
17{
18  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
19}
20 
21/************************************* test *************************************/
22 
23use adapter\AudioPlayer;
24 
25try {
26  //生产一台设备
27  $mp4 = new AudioPlayer();
28  // 播放一个mp3
29  $mp4->play('忍者', 'mp3');
30  // 播放一个wma
31  $mp4->play('彩虹', 'wma');
32  // 播放一个mp4
33  $mp4->play('龙卷风mv', 'mp4');
34} catch (\Exception $e) {
35  echo $e->getMessage();
36}

 1<?php
 2/**
 3 * 结构型模式
 4 *
 5 * php装饰器模式
 6 * 对现有的对象增加功能
 7 * 和适配器的区别：适配器是连接两个接口，装饰器是对现有的对象包装
 8 *
 9 * @author  TIGERB <https://github.com/TIGERB>
10 * @example 运行 php test.php
11 */
12 
13 
14// 注册自加载
15spl_autoload_register('autoload');
16 
17function autoload($class)
18{
19  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
20}
21 
22/************************************* test *************************************/
23 
24use decorator\DecoratorBrand;
25use decorator\ShoesSport;
26use decorator\ShoesSkateboard;
27 
28try {
29  echo "未加装饰器之前：\n";
30  // 生产运动鞋
31  $shoesSport = new ShoesSport();
32  $shoesSport->product();
33 
34  echo "\n--------------------\n";
35  //-----------------------------------
36 
37  echo "加贴标装饰器：\n";
38  // 初始化一个贴商标适配器
39  $DecoratorBrand = new DecoratorBrand(new ShoesSport());
40  $DecoratorBrand->_brand = 'nike';
41  // 生产nike牌运动鞋
42  $DecoratorBrand->product();
43} catch (\Exception $e) {
44  echo $e->getMessage();
45}

 1<?php
 2/**
 3 * 结构型模式
 4 *
 5 * php组合（部分整体）模式
 6 * 定义：将对象以树形结构组织起来，以达成“部分－整体”的层次结构，使得客户端对单个对象和组合对象的使用具有一致性
 7 * 我的理解：把对象构建成树形结构
 8 *
 9 *
10 * @author  TIGERB <https://github.com/TIGERB>
11 * @example 运行 php test.php
12 */
13 
14 
15// 注册自加载
16spl_autoload_register('autoload');
17 
18function autoload($class)
19{
20  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
21}
22 
23/************************************* test 实现一个文件夹*************************************/
24 
25use composite\Folder;
26use composite\File;
27 
28try {
29  // 构建一个根目录
30  $root = new Folder('根目录');
31 
32  // 根目录下添加一个test.php的文件和usr,mnt的文件夹
33  $testFile = new File('test.php');
34  $usr = new Folder('usr');
35  $mnt = new Folder('mnt');
36  $root->add($testFile);
37  $root->add($usr);
38  $root->add($mnt);
39  $usr->add($testFile);// usr目录下加一个test.php的文件
40 
41  // 打印根目录文件夹节点
42  $root->printComposite();
43 
44} catch (\Exception $e) {
45  echo $e->getMessage();
46}

 1<?php
 2/**
 3 * 结构型模式
 4 *
 5 * php代理器模式
 6 * 对对象加以【控制】
 7 * 和适配器的区别：适配器是连接两个接口（【改变】了接口）
 8 * 和装饰器的区别：装饰器是对现有的对象包装（【功能扩展】）
 9 *
10 * @author  TIGERB <https://github.com/TIGERB>
11 * @example 运行 php test.php
12 */
13 
14 
15// 注册自加载
16spl_autoload_register('autoload');
17 
18function autoload($class)
19{
20  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
21}
22 
23/************************************* test *************************************/
24 
25use proxy\Proxy;
26use proxy\ShoesSport;
27 
28try {
29  echo "未加代理之前：\n";
30  // 生产运动鞋
31  $shoesSport = new ShoesSport();
32  $shoesSport->product();
33 
34  echo "\n--------------------\n";
35  //-----------------------------------
36 
37  echo "加代理：\n";
38  // 把运动鞋产品线外包给代工厂
39  $proxy = new Proxy('sport');
40  // 代工厂生产运动鞋
41  $proxy->product();
42} catch (\Exception $e) {
43  echo $e->getMessage();
44}

 1<?php
 2/**
 3 * 结构型模式
 4 *
 5 * php过滤器模式
 6 * 使用不同的标准来过滤一组对象，说实话没明白该模式的意义，忘你留言补充讲解
 7 *
 8 *
 9 * @author  TIGERB <https://github.com/TIGERB>
10 * @example 运行 php test.php
11 */
12 
13 
14// 注册自加载
15spl_autoload_register('autoload');
16 
17function autoload($class)
18{
19  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
20}
21 
22/************************************* test *************************************/
23 
24use filter\SportsPerson;
25use filter\FilterSportType;
26use filter\FilterGender;
27 
28try {
29  // 定义一组运动员
30  $persons = [];
31  $persons[] = new SportsPerson('male', 'basketball');
32  $persons[] = new SportsPerson('female', 'basketball');
33  $persons[] = new SportsPerson('male', 'football');
34  $persons[] = new SportsPerson('female', 'football');
35  $persons[] = new SportsPerson('male', 'swim');
36  $persons[] = new SportsPerson('female', 'swim');
37 
38  // 按过滤男性
39  $filterGender = new FilterGender('male');
40  var_dump($filterGender->filter($persons));
41  // 过滤运动项目篮球
42  $filterSportType = new FilterSportType('basketball');
43  var_dump($filterSportType->filter($persons));
44 
45} catch (\Exception $e) {
46  echo $e->getMessage();
47}

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php模板模式
 6 * 理解：典型的控制反转，子类复写算法，但是最终的调用都是抽象类中定义的方式，也就是说抽象类中
 7 * 定义了算法的执行顺序
 8 * 使用场景：例如短信系统，选择不同的短信商，但是发送短信的动作都是一样的,未来要增加不同的厂商
 9 * 只需添加子类即可
10 *
11 * 下面实现一个短信发送系统
12 *
13 * @author  TIGERB <https://github.com/TIGERB>
14 * @example 运行 php test.php
15 */
16 
17 
18// 注册自加载
19spl_autoload_register('autoload');
20 
21function autoload($class)
22{
23  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
24}
25 
26/************************************* test *************************************/
27 
28use template\SmsCompanyOne;
29use template\SmsCompanyTwo;
30 
31try {
32  // 用厂商one发短信
33  $one = new SmsCompanyOne([
34    'appkey' => 'akjlooolllnn',
35  ]);
36  $one->send('13666666666');
37 
38  // 用厂商two发短息
39  $one = new SmsCompanyTwo([
40    'pwd' => 'adadeooonn',
41  ]);
42  $one->send('13666666666');
43 
44} catch (\Exception $e) {
45  echo 'error:' . $e->getMessage();
46}

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php策略模式
 6 * 策略依照使用而定
 7 *
 8 * @author  TIGERB <https://github.com/TIGERB>
 9 * @example 运行 php test.php
10 */
11 
12 
13// 注册自加载
14spl_autoload_register('autoload');
15 
16function autoload($class)
17{
18  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
19}
20 
21/************************************* test *************************************/
22 
23use strategy\Substance;
24use strategy\StrategyExampleOne;
25use strategy\StrategyExampleTwo;
26 
27// 使用策略1
28$substanceOne = new Substance(new StrategyExampleOne);
29$substanceOne->someOperation();
30 
31// 使用策略2
32$substanceTwo = new Substance(new StrategyExampleTwo);
33$substanceTwo->someOperation();

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php状态模式
 6 * 理解：行为随着状态变化
 7 * 区别：
 8 * - 策略的改变由client完成，client持有context的引用；而状态的改变是由context或状态自己,
 9 * 就是自身持有context
10 * - 简单说就是策略是client持有context，而状态是本身持有context
11 * 使用场景：大量和对象状态相关的条件语句
12 *
13 * 下面我们来实现一个农民四季种菜
14 * 春季：玉米
15 * 夏季：黄瓜
16 * 秋季：白菜
17 * 冬季：菠菜
18 *
19 *
20 * @author  TIGERB <https://github.com/TIGERB>
21 * @example 运行 php test.php
22 */
23 
24 
25// 注册自加载
26spl_autoload_register('autoload');
27 
28function autoload($class)
29{
30  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
31}
32 
33/************************************* test *************************************/
34 
35use state\Farmer;
36 
37try {
38  // 初始化一个农民
39  $farmer = new Farmer();
40 
41  // 春季
42  $farmer->grow();
43  $farmer->harvest();
44  // 夏季
45  $farmer->grow();
46  $farmer->harvest();
47  // 秋季
48  $farmer->grow();
49  $farmer->harvest();
50  // 冬季
51  $farmer->grow();
52  $farmer->harvest();
53 
54} catch (\Exception $e) {
55  echo 'error:' . $e->getMessage();
56}

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php观察者模式
 6 * 观察者观察被观察者，被观察者通知观察者
 7 *
 8 * @author  TIGERB <https://github.com/TIGERB>
 9 * @example 运行 php test.php
10 */
11 
12 
13// 注册自加载
14spl_autoload_register('autoload');
15 
16function autoload($class)
17{
18  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
19}
20 
21/************************************* test *************************************/
22 
23use observer\Observable;
24use observer\ObserverExampleOne;
25use observer\ObserverExampleTwo;
26 
27// 注册一个被观察者对象
28$observable = new Observable();
29// 注册观察者们
30$observerExampleOne = new ObserverExampleOne();
31$observerExampleTwo = new ObserverExampleTwo();
32 
33// 附加观察者
34$observable->attach($observerExampleOne);
35$observable->attach($observerExampleTwo);
36 
37// 被观察者通知观察者们
38$observable->notify();

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php责任链模式
 6 * 理解：把一个对象传递到一个对象链上，直到有对象处理这个对象
 7 * 可以干什么：我们可以做一个filter,或者gateway
 8 *
 9 *
10 * @author  TIGERB <https://github.com/TIGERB>
11 * @example 运行 php test.php
12 */
13 
14 
15// 注册自加载
16spl_autoload_register('autoload');
17 
18function autoload($class)
19{
20  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
21}
22 
23/************************************* test *************************************/
24 
25use chainOfResponsibility\HandlerAccessToken;
26use chainOfResponsibility\HandlerFrequent;
27use chainOfResponsibility\HandlerArguments;
28use chainOfResponsibility\HandlerSign;
29use chainOfResponsibility\HandlerAuthority;
30use chainOfResponsibility\Request;
31 
32try {
33  // 下面我们用责任链模式实现一个api-gateway即接口网关
34 
35  // 初始化一个请求对象
36  $request            =  new Request();
37  // 设置一个请求身份id
38  $request->requestId = uniqid();
39 
40  // 初始化一个：令牌校验的handler
41  $handlerAccessToken =  new HandlerAccessToken();
42  // 初始化一个：访问频次校验的handler
43  $handlerFrequent    =  new HandlerFrequent();
44  // 初始化一个：必传参数校验的handler
45  $handlerArguments   =  new HandlerArguments();
46  // 初始化一个：签名校验的handler
47  $handlerSign        =  new HandlerSign();
48  // 初始化一个：访问权限校验的handler
49  $handlerAuthority   =  new HandlerAuthority();
50 
51  // 构成对象链
52  $handlerAccessToken->setNext($handlerFrequent)
53                     ->setNext($handlerArguments)
54                     ->setNext($handlerSign)
55                     ->setNext($handlerAuthority);
56  // 启动网关
57  $handlerAccessToken->start($request);
58 
59} catch (\Exception $e) {
60  echo $e->getMessage();
61}

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php访问者模式
 6 *
 7 * 说说我对的策略模式和访问者模式的区分：
 8 * 乍一看，其实两者都挺像的，都是实体类依赖了外部实体的算法，但是：
 9 * 对于策略模式：首先你是有一堆算法，然后在不同的逻辑中去使用；
10 * 对于访问者模式：实体的【结构是稳定的】，但是结构中元素的算法却是多变的，比如就像人吃饭这个动作
11 * 是稳定不变的，但是具体吃的行为却又是多变的；
12 *
13 * @author  TIGERB <https://github.com/TIGERB>
14 * @example 运行 php test.php
15 */
16 
17 
18// 注册自加载
19spl_autoload_register('autoload');
20 
21function autoload($class)
22{
23  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
24}
25 
26/************************************* test *************************************/
27 
28use visitor\Person;
29use visitor\VisitorAsia;
30use visitor\VisitorAmerica;
31 
32// 生产一个人的实例
33$person = new Person();
34 
35// 来到了亚洲
36$person->eat(new VisitorAsia());
37 
38// 来到了美洲
39$person->eat(new VisitorAmerica());

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php解析器模式
 6 * 理解：就是一个上下文的连接器
 7 * 使用场景：构建一个编译器，SQL解析器
 8 * 下面我们来实现一个简单增删改查的sql解析器
 9 *
10 * @author  TIGERB <https://github.com/TIGERB>
11 * @example 运行 php test.php
12 */
13 
14 
15// 注册自加载
16spl_autoload_register('autoload');
17 
18function autoload($class)
19{
20  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
21}
22 
23/************************************* test *************************************/
24 
25use interpreter\SqlInterpreter;
26 
27try {
28  //增加数据
29  SqlInterpreter::db('user')->insert([
30    'nickname' => 'tigerb',
31    'mobile'   => '1366666666',
32    'password' => '123456'
33  ]);
34  //删除数据
35  SqlInterpreter::db('user')->delete([
36    'nickname' => 'tigerb',
37    'mobile'   => '1366666666',
38  ]);
39  //修改数据
40  SqlInterpreter::db('member')->update([
41    'id'       => '1',
42    'nickname' => 'tigerbcode'
43  ]);
44  //查询数据
45  SqlInterpreter::db('member')->find([
46    'mobile'   => '1366666666',
47  ]);
48} catch (\Exception $e) {
49  echo 'error:' . $e->getMessage();
50}

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php备忘录模式
 6 * 理解：就是外部存储对象的状态，以提供后退/恢复/复原
 7 * 使用场景：编辑器后退操作/数据库事物/存档
 8 *
 9 * 下面我们来实现编辑器的undo(撤销)/redo（重置）功能
10 *
11 * @author  TIGERB <https://github.com/TIGERB>
12 * @example 运行 php test.php
13 */
14 
15 
16// 注册自加载
17spl_autoload_register('autoload');
18 
19function autoload($class)
20{
21  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
22}
23 
24/************************************* test *************************************/
25 
26use memento\Editor;
27 
28try {
29  // 初始化一个编辑器并新建一个空文件
30  $editor = new Editor('');
31 
32  // 写入一段文本
33  $editor->write('hello php !');
34  // 保存
35  $editor->save();
36  // 修改刚才的文本
37  $editor->write(' no code no life !');
38  // 撤销
39  $editor->undo();
40  $editor->read();
41  // 再次修改并保存文本
42  $editor->write(' life is a struggle !');
43  $editor->save();
44  // 重置
45  $editor->redo();
46  $editor->read();
47 
48} catch (\Exception $e) {
49  echo 'error:' . $e->getMessage();
50}

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php命令模式
 6 * 命令模式:就是在依赖的类中间加一个命令类，本来可以直接调用的类方法现在通过命令来调用，已达到
 7 * 解耦的的目的，其次可以实现undo，redo等操作，因为你知道调了哪些命令
 8 *
 9 * 下面我们来用命令模式实现一个记事本，涉及的命令：
10 * - 新建
11 * - 写入
12 * - 保存
13 *
14 * @author  TIGERB <https://github.com/TIGERB>
15 * @example 运行 php test.php
16 */
17 
18 
19// 注册自加载
20spl_autoload_register('autoload');
21 
22function autoload($class)
23{
24  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
25}
26 
27/************************************* test *************************************/
28 
29use command\Text;
30use command\OrderCreate;
31use command\OrderWrite;
32use command\OrderSave;
33use command\Console;
34 
35try {
36  // 创建一个记事本实例
37  $text   = new Text();
38 
39  // 创建命令
40  $create = new OrderCreate($text, [
41    'filename' => 'test.txt'
42  ]);
43  // 写入命令
44  $write  = new OrderWrite($text, [
45    'filename' => 'test.txt',
46    'content'  => 'life is a struggle'
47  ]);
48  // 保存命令
49  $save   = new OrderSave($text, [
50    'filename' => 'text.txt'
51  ]);
52 
53  // 创建一个控制台
54  $console = new Console();
55  // 添加命令
56  $console->add($create);
57  $console->add($write);
58  $console->add($save);
59  // 运行命令
60  $console->run();
61 
62} catch (\Exception $e) {
63  echo $e->getMessage();
64}

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php迭代器模式
 6 * 理解：遍历对象内部的属性，无需对外暴露内部的构成
 7 * 下面我们来实现一个迭代器访问学校所有的老师
 8 *
 9 * @author  TIGERB <https://github.com/TIGERB>
10 * @example 运行 php test.php
11 */
12 
13 
14// 注册自加载
15spl_autoload_register('autoload');
16 
17function autoload($class)
18{
19  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
20}
21 
22/************************************* test *************************************/
23 
24use iterator\SchoolExperimental;
25 
26try {
27  // 初始化一个实验小学
28  $experimental = new SchoolExperimental();
29  // 添加老师
30  $experimental->addTeacher('Griffin');
31  $experimental->addTeacher('Curry');
32  $experimental->addTeacher('Mc');
33  $experimental->addTeacher('Kobe');
34  $experimental->addTeacher('Rose');
35  $experimental->addTeacher('Kd');
36  // 获取教师迭代器
37  $iterator = $experimental->getIterator();
38  // 打印所有老师
39  do {
40    $iterator->current();
41  } while ($iterator->hasNext());
42 
43} catch (\Exception $e) {
44  echo 'error:' . $e->getMessage();
45}

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php中介者模式
 6 * 理解：就是不同的对象之间通信，互相之间不直接调用，而是通过一个中间对象（中介者）
 7 * 使用场景：对象之间大量的互相依赖
 8 * 下面实现一个房屋中介
 9 *
10 *
11 * @author  TIGERB <https://github.com/TIGERB>
12 * @example 运行 php test.php
13 */
14 
15 
16// 注册自加载
17spl_autoload_register('autoload');
18 
19function autoload($class)
20{
21  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
22}
23 
24/************************************* test *************************************/
25 
26use mediator\Tenant;
27use mediator\Landlord;
28use mediator\HouseMediator;
29 
30try {
31  // 初始化一个租客
32  $tenant = new Tenant('小明');
33 
34  // 小明直接找小梅租房
35  $landlord = new Landlord('小梅');
36  echo $landlord->doSomthing($tenant);
37 
38  // 小明通过房屋中介租房
39  // 初始化一个房屋中介
40  $mediator = new HouseMediator();
41  // 租房
42  $mediator->rentHouse($tenant);
43 
44} catch (\Exception $e) {
45  echo 'error:' . $e->getMessage();
46}

 1<?php
 2/**
 3 * 行为型模式
 4 *
 5 * php空对象模式
 6 * 理解：当程序运行过程中出现操作空对象时，程序依然能够通过操作提供的空对象继续执行
 7 * 使用场景：谨慎使用吧
 8 *
 9 * 下面实现老师课堂叫学生回答问题
10 *
11 *
12 * @author  TIGERB <https://github.com/TIGERB>
13 * @example 运行 php test.php
14 */
15 
16 
17// 注册自加载
18spl_autoload_register('autoload');
19 
20function autoload($class)
21{
22  require dirname($_SERVER['SCRIPT_FILENAME']) . '//..//' . str_replace('\\', '/', $class) . '.php';
23}
24 
25/************************************* test *************************************/
26 
27use nullObject\Teacher;
28use nullObject\Student;
29 
30try {
31  //创建一个老师：路飞
32  $teacher = new Teacher('路飞');
33 
34  // 创建学生
35  $mc      = new Student('麦迪');
36  $kobe    = new Student('科比');
37  $paul    = new Student('保罗');
38 
39  // 老师提问
40  $teacher->doSomthing($mc);
41  $teacher->doSomthing($kobe);
42  $teacher->doSomthing($paul);
43  $teacher->doSomthing('小李');// 提问了一个班级里不存在人名
44 
45 
46} catch (\Exception $e) {
47  echo 'error:' . $e->getMessage();
48}