PHP开发自己的框架必备知识点

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

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

官方文档：

4. //spl（php标准库）数据结构
6. /**
7. * 栈（先进后出）
8. */
9. $stack = new SplStack();
10. $stack->push(‘data1’);//入栈（先进后出）
11. $stack->push(‘data2’);//入栈
12. $stack->push(‘data3’);//入栈
14. echo $stack->pop();//出栈
15. echo $stack->pop();//出栈
16. echo $stack->pop();//出栈
19. /**
20. *队列(先进先出）
21. */
22. $queue = new SplQueue();
23. $queue->enqueue(‘data4’);//入队列
24. $queue->enqueue(‘data5’);//入队列
25. $queue->enqueue(‘data6’);//入队列
27. echo $queue->dequeue();//出队列
28. echo $queue->dequeue();//出队列
29. echo $queue->dequeue();//出队列
30. echo $queue->dequeue();//出队列
33. /**
34. * 堆
35. */
36. $heap = new SplMinHeap();
37. $heap->insert(‘data8’);//入堆
38. $heap->insert(‘data9’);//入堆
39. $heap->insert(‘data10’);//入堆
41. echo $heap-> extract ();//从堆中提取数据
42. echo $heap->extract();//从堆中提取数据
43. echo $heap->extract();//从堆中提取数据
46. /**
47. * 固定数组（不论使不使用，都会分配相应的内存空间）
48. */
49. $array = new SplFixedArray(15);
50. $array[‘0’] = 54;
51. $array[‘6’] = 69;
52. $array[’10’] = 32;
53. var_dump($array);

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

1、入口文件 index.php

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

2、自动加载类 Loader.php

3. namespace Extend;
4. /**
5. * 实现框架的自动加载
6. */
7. class Loader
8. {
9. /**
10. * 实现文件的自动载入
11. */
12. static function autoload($class)
13. {
14. require BASEDIR.’/’.str_replace(‘\\’,’/’,$class).’.php’;
15. }
18. }

3、数据库类Database.php

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

3. namespace Extend;
5. class Database
6. {
7. /**
8. * 指定查询条件
9. * @param $where
10. */
11. function where($where)
12. {
13. return $this;
14. }
16. /**
17. * 指定排序条件
18. */
19. function order($order)
20. {
21. return $this;
22. }
24. /**
25. * 指定查询的限制条数
26. * @param $limit
27. */
28. function limit($limit)
29. {
30. return $this;
31. }
34. }

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

三、PHP魔术方法的使用

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

1、框架入口文件 index.php

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

2、 Extend/Object.php

3. namespace Extend;
4. /**
5. * 要求类名必须和文件名保持一致，即类名是Object，则所在文件名为Object.php
6. * Class Object
7. * @package Extend
8. */
9. class Object
10. {
11. protected $array = array();
13. /**
14. * 在代码要给未定义的属性赋值时调用,或在类外部修改被private修饰的类属性时被调用
15. */
16. function __set($name, $value)
17. {
18. echo “this is __set func”;
19. }
21. /**
22. * 当在类外部访问被private或proteced修饰的属性或访问一个类中原本不存在的属性时被调用
23. * @param $name
24. */
25. function __get($name)
26. {
27. echo “this is __get func”;
28. }
30. /**
31. * 当试图调用不存在的方法或权限不足时会触发__call()
32. * @param $name 调用不存在的类方法时那个不存在的类方法的方法名
33. * @param $arguments 调用不存在的类方法时传递的参数
34. */
35. function __call($name, $arguments)
36. {
37. var_dump($name,$arguments);
38. }
41. /**
42. * 当试图调用不存在的静态方法或权限不足时会触发__callStatic()
43. * @param $name 调用不存在的静态方法时那个不存在的方法的方法名
44. * @param $arguments 调用不存在的静态方法时传递的参数
45. */
46. function __callStatic($name,$arguments)
47. {
48. var_dump($name,$arguments);
49. }
51. /**
52. * 当使用echo或print打印对象时会调用__toString()方法将对象转化为字符串
53. */
54. function __toString()
55. {
56. echo “this is __toString func”;
57. }
60. /**
61. * 对象本身不能直接当函数用，如果被当做函数用，会直接回调__invoke方法
62. * @param $param
63. */
64. function __invoke($param)
65. {
66. echo $param.”
    this is __invoke func”;
67. }
70. }

四、三种基础设计模式

1、工厂模式

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

index.php

3. /**
4. * 框架入口文件
5. */
6. define(‘BASEDIR’,__DIR__);//项目根目录
7. include BASEDIR.’/Extend/Loader.php’;//引入项目自动加载类文件
8. spl_autoload_register(‘\\Extend\\Loader::autoload’);//执行自动加载函数，完成类的自动加载
10. //构造实例化缓存类时传入的参数
11. $config = array(
12. ‘host’ => ‘127.0.0.1’,
13. ‘pass’ => ‘myRedis&&&’
14. );
15. //工厂模式创建cache对象
16. $cache = Extend\CacheFactory::getCacheObj(‘redis’,$config);
17. var_dump($cache);

Extend/CacheFactory.php

3. namespace Extend;
5. class CacheFactory
6. {
7. const FILE = 1;
8. const MEMCACHE = 2;
9. const REDIS = 3;
11. static $instance;//定义静态属性，用于存储对象
13. /**
14. * 工厂类创建缓存对象
15. * @param $type 指定缓存类型
16. * @param array $options 传入缓存参数
17. * @return FileCache|Memcache|RedisCache
18. */
19. static function getCacheObj($type, array $options)
20. {
21. switch ($type) {
22. case ‘file’:
23. case self::FILE:
24. self::$instance = new FileCache($options);
25. break ;
27. case ‘memcache’:
28. case self::MEMCACHE:
29. self::$instance = new Memcache($options);
30. break;
32. case ‘redis’:
33. case self::REDIS:
34. self::$instance = new RedisCache($options);
35. break;
37. default:
38. self::$instance = new FileCache($options);
39. break;
41. }
42. return self::$instance;
43. }
44. }

2、 单例模式

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

index.php

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

Extend/SingleObject.php

3. namespace Extend;
5. /**
6. * 单例模式创建唯一类对象
7. * Class SingleObject
8. * @package Extend
9. */
10. class SingleObject
11. {
12. //私有的静态属性，用于存储类对象
13. private static $instance = null;
15. //私有的构造方法,保证不允许在类外 new
16. private function __construct(){}
18. //私有的克隆方法, 确保不允许通过在类外 clone 来创建新对象
19. private function __clone(){}
21. //公有的静态方法，用来实例化唯一当前类对象
22. public static function getInstance()
23. {
24. if(is_null(self::$instance)){
25. self::$instance = new self;
26. }
27. return self::$instance;
28. }
30. }

3、注册树模式

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

Extend/RegisterTree,php

3. namespace Extend;
5. /**
6. * 注册树模式
7. * Class RegisterTree
8. * @package Extend
9. */
10. class RegisterTree
11. {
13. static protected $objects;//静态类属性，用于储存注册到注册树上的对象
15. /**
16. * 将对象注册到注册树上
17. * @param $alias 对象的别名
18. * @param $object 对象
19. */
20. static function setObject($alias,$object)
21. {
22. self::$objects[$alias] = $object;
23. }
26. /**
27. * 从注册树上取出给定别名相应的对象
28. * @param $alias 将对象插入到注册树上时写的别名
29. * @return mixed 对象
30. */
31. static protected function getObject($alias)
32. {
33. return self::$objects[$alias];
34. }
36. /**
37. * 将对象从注册树上删除
38. * @param $alias 将对象插入到注册树上时写的别名
39. */
40. public function unsetObject($alias)
41. {
42. unset(self::$objects[$alias]);
43. }
45. }

关于注册树模式，这里推荐一篇文章 ，可以方便理解。

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

1、适配器模式

2、策略模式

3、数据对象映射模式

4、观察者模式

5、原型模式

6、装饰器模式

7、迭代器模式

8、代理模式