search

博客列表 >PHP - 静态绑定/属性拦截器及连接数据库案例

PHP - 静态绑定/属性拦截器及连接数据库案例

晴天
晴天原创
2020年05月09日 22:28:29695浏览

1.静态继承上下文

  1. //静态继承上下文
  2. class A
  3. {
  4.     public function demo()
  5.     {
  6.         //.....
  7.     }
  8. }
  10. class B extends A{
  11.     public function demo()
  12.     {
  13.         parent::demo();
  14.     }
  15. }
  16. ## 上面便是一个继承上下文环境，若要改为静态继承上下文，直接在function前面加static 即可

2.后期静态绑定

  1. //后期静态绑定：也叫延迟静态绑定
  3. ## 后期静态绑定工作在静态继承上下文环境中
  5. //创建一个抽象类
  6. abstract class Creat
  7. {
  9. }
  11. //创建实现类
  12. class User extends Creat
  13. {
  14.     public static function create(){
  15.         return new static();
  16.     }
  17. }
  19. class Product extends User
  20. {
  22. }
  24. var_dump(User::create());
  25. //输出 object(User)#1 (0) { }
  26. echo '<hr>';
  27. var_dump(Product::create());
  28. //输出 object(Product)#1 (0) { }
  29. ## 方法里面如果用new self() 他返回的是实现该方法的类的类名  、 使用 new static() 他返回的是调用该方法的类的类名
  1. <?php
  3. //我们可以把它上移到抽象类中
  4. ## 注意：抽象类不能实例化，所以使用new self() 是错误的
  5. //解决方案：将类的定义与类的调用完全分离开。使用后期静态绑定方案 static 关键字将self替换掉
  6. //创建一个抽象类
  7. abstract class Creat
  8. {
  9.     public static function create(){
  10. //        return new self();
  11.         return new static();
  13. //        self 始终与定义该方法（属性）的类进行绑定
  14. //        static 始终与调用该方法（属性）的类进行绑定
  15.     }
  16. }
  18. //创建实现类
  19. class User extends Creat
  20. {
  22. }
  24. class Product extends User
  25. {
  27. }
  29. var_dump(User::create());
  30. //输出 object(User)#1 (0) { }
  31. echo '<hr>';
  32. var_dump(Product::create());
  33. //输出 object(Product)#1 (0) { }

3.魔术方法

  1. <?php
  2. //魔术方法
  3. //语法:类中有一些方法总是使用双下划线开头,这就叫魔术方法
  4. // 调用者:由系统根据一定的条件或用户行为，自动调用/触发，禁止用户主动调用
  5. //构造方法：__construct(),是类的实例化过程中被自动调用，new的时候
  7. class Product{
  8.     private $name;
  9.     private  $price;
  11. //    创建构造器:生成一个新对象
  12. public function __construct($name,$price)
  13. {
  14.     ## $this是由PHP接管的对象，不能用户设置
  15. //    $this = new self();   此段省略即可
  17.     ## 初始化这个新对象：给这个新对象添加属性并赋值，或自动执行某些操作方法
  18.     $this->name = $name;
  19.     $this->price = $price;
  20.     $this->white();
  22.     ## 返回这个刚创建并初始化的对象
  23. //    return $this;
  24.     ## 隐式返回当前新生的类实例，不用显示返回，自动完成
  25. }
  27.     public function white()
  28.     {
  29.         echo $this->name.':'.$this->price;
  30.     }
  31. }
  32. //只需将参数传入到类中即可
  33. $product = new Product('上衣',500);

4. 属性拦截器

名称 描述
__get 属性查询拦截器
__set 属性设置拦截器
__isset 属性检测拦截器
__unset 属性销毁拦截器

注意：__get可以单独使用，但是__set要同__get 一起使用方能生效

4.1 属性查询拦截器

  1. <?php
  2. class User
  3. {
  4.     private $name;
  5.     private $price;
  6.     public function __construct($name,$price)
  7.     {
  8.         $this->name = $name;
  9.         $this->price = $price;
  10.     }
  11. //    属性查询拦截器：拦截转发器：将拦截下来的值根据设置转发出去或拦截下来
  12.     public function __get($property)
  13.     {
  14. //        return ($private === 'name') ? mb_substr($this->name,0,5) :'禁止访问';
  15. //     将传进来的参数前面加get 首字母大写 转发给对应的方法，专用于处理属性访问
  16.         $method = 'get'.ucfirst($property);
  17. //        如果有该方法则转到，若没有返回没有该方法
  18.         return  method_exists($this,$method) ? $this->$method() : '没有该方法';
  19.     }
  20. // 创建方法，返回name值
  21.     private function getName()
  22.     {
  23. //        只返回前五个字符
  24.         return mb_substr($this->name,0,5);
  25.     }
  26. }
  28. //传参
  29. $user = new User('联想笔记本电脑Y7000p',7999);
  31. echo $user->name;
  32. //输出 联想笔记本
  33. //访问原理，这里访问的不是name的值，而是被属性拦截器拦截下来经过处理转发到getName方法返回的数据

4.2 属性设置拦截器

  1. <?php
  3. //属性设置拦截器
  4. class User
  5. {
  6.     private $name;
  7.     private $price;
  9. //    创建构造器
  10.     public function __construct($name, $price)
  11.     {
  12.         $this->name = $name;
  13.         $this->price = $price;
  14.     }
  15. //    属性查询拦截器：拦截转发器：将拦截下来的值根据设置转发出去或拦截下来
  16.     public function __get($property)
  17.     {
  18. //        return ($private === 'name') ? mb_substr($this->name,0,5) :'禁止访问';
  19. //     将传进来的参数前面加get 首字母大写 转发给对应的方法，专用于处理属性访问
  20.         $method = 'get'.ucfirst($property);
  21. //        如果有该方法则转到，若没有返回没有该方法
  22.         return  method_exists($this,$method) ? $this->$method() : '没有该方法';
  23.     }
  24. // 创建方法，返回name值
  25.     private function getName()
  26.     {
  27. //        只返回前五个字符
  28.         return mb_substr($this->name,0,5);
  29.     }
  30.     private function  getPrice(){
  31.         return $this->price;
  32.     }
  36.     //////////////////////////////////
  37. // 创建属性设置拦截器 set给两个值，第一个 属性名  第二个 新属性值
  38.     public function __set($property,$value)
  39.     {
  40.         $method = 'Set'.ucfirst($property);
  41. //        转发设置请求
  42.             return method_exists($this,$method) ? $this->$method($value) : null;
  43.     }
  45. //    创建属性设置方法
  46.     public function setName($value)
  47.     {
  48. //        清一下空白字符
  49.         $this->name = trim($value);
  50.     }
  51.     public function setPrice($value)
  52.     {
  53.         $this->price = $value * 0.2;
  54.     }
  55. }
  57. $user = new User('联想笔记本电脑', 7999);
  58. echo $user->name; //输出联想笔记本
  59. echo $user->price;//输出 7999
  60. echo '<hr>';
  61. //更新name值
  62. $user->name = ' macbook ';
  63. //更新price值
  64. $user->price = 121121;
  65. echo $user->name; //输出 macbo  因为__get拦截器只返回五个字符
  66. echo $user->price;//输出 24224.2

4.3 属性检测/销毁拦截器

  1. <?php
  3. //属性设置拦截器
  4. class User
  5. {
  6.     private $name;
  7.     private $price;
  9. //    创建构造器
  10.     public function __construct($name, $price)
  11.     {
  12.         $this->name = $name;
  13.         $this->price = $price;
  14.     }
  15.     /*       * * * * *             *    * * * * *      */
  16. //    给一个属性查询拦截器 供销毁测试
  18.     public function __get($property)
  19.     {
  20.         $method = 'get' . ucfirst($property);
  21. //    先检测有没有该方法
  22.         return method_exists($this, $method) ? $this->$method() :  'djdsdhjkds';
  23.     }
  25.     private function getName()
  26.     {
  27.         return $this->name;
  28.     }
  30.     private function getPrice()
  31.     {
  32.         return $this->price;
  33.     }
  34.     /*       * * * * *             *    * * * * *      */
  35. //    属性检测拦截器
  36.     public function __isset($property)
  37.     {
  38. //    只让检测name值
  39.         return $property === 'name' ? isset($this->name) : false;
  40.     }
  42. //属性销毁拦截器
  43.     public function __unset($property)
  44.     {
  45. //    只让删除name值
  46.         $property === 'name' ? $this->name = null : null;
  47.     }
  48. }
  50. $user = new User('联想笔记本电脑', 7999);
  52. //检测一下是否存在
  53. var_dump(isset($user->name)); //输出 true
  54. //检测price
  55. var_dump(isset($user->price));  //输出 false
  56. echo $user->price;
  57. echo $user->name;
  59. echo '<hr>';
  60. //删除name值
  61. unset($user->name);
  62. echo $user->name; //成功
  64. //删除price值
  65. unset($user->price);
  66. echo $user->price; //正常输出  删除失败

5. 方法拦截器

  1. <?php
  3. // 方法拦截器
  4. // __call(), __callSTatic()
  5. // 就是创建一个方法
  7. class User
  8. {
  10. //创建方法拦截器
  11.     public function __call($name, $arguments)
  12.     {
  13.         // implode 将数组转为字符串
  14.         printf('方法名：%s --- 参数：%s ', $name, implode(',', $arguments));
  15.     }
  17. //    创建静态方法拦截器
  19.     public static function __callStatic($name,$arguments)
  20.     {
  21.         printf('方法名：%s --- 参数：%s ', $name, implode(',', $arguments));
  22.     }
  23. }
  25. $user = new User();
  26. $user->demo(1, 2, 3, 4);  // 输出  方法名：demo --- 参数：1,2,3,4
  28. echo '<hr>';
  29. //静态访问
  30. User::demo(1,2,3,3)  // 输出 方法名：demo --- 参数：1,2,3,3

6. 小案例：利用构造器和拦截器实现链接数据库并查询

  1. <?php
  3. //利用构造器 方法拦截器实现数据库查询
  5. class Datebase
  6. {
  7. //    数据库链接
  8.     protected $db;
  9. //表名
  10.     protected $table;
  11. //字段列表
  12.     protected $field;
  13. //查询条数
  14.     protected $limit;
  16. //构造方法实现数据库链接
  17.     public function __construct($dsn, $username, $password)
  18.     {
  19. //        转发给connect
  20.         $this->connect($dsn, $username, $password);
  21.     }
  23. //创建PDO链接
  24.     private function connect($dsn, $username, $password)
  25.     {
  26. //        用PDO方式链接
  27.         $this->db = new PDO($dsn, $username, $password);
  28.     }
  30. //    写入表名
  31.     public function table($table)
  32.     {
  33.         $this->table = $table;
  34.         return $this;
  35.     }
  37. //    字段列表
  38.     public function field($field)
  39.     {
  40.         $this->field = $field;
  41.         return $this;
  42.     }
  44. //查询条数
  45.     public function limit($limit)
  46.     {
  47.         $this->limit = $limit;
  48.         return $this;
  49.     }
  51. //    创建查询数据库字段
  52.     public function getSql()
  53.     {
  54.         return sprintf('SELECT %s FROM %s LIMIT %s', $this->field, $this->table, $this->limit);
  55.     }
  57. //    创建查询
  58.     public function select()
  59.     {
  60.         return $this->db->query($this->getSql())->fetchAll(PDO::FETCH_ASSOC);
  61.     }
  62. }
  64. class DB
  65. {
  66. //    传参 静态方法拦截器
  67. public static function __callStatic($name, $arguments)
  68. {
  69.     // TODO: Implement __callStatic() method.
  70.     $dsn = 'mysql:host=localhost;dbname=php11.edu';
  71.     $datebase = new Datebase($dsn,'php11.edu','php11.edu');
  72.     return call_user_func([$datebase,$name],...$arguments);
  73. }
  74. }
  76. $res = DB::table('staffs')
  77.     ->field('id,name,age')
  78.     ->limit(5)
  79.     ->select();
  81. print_r($res);
  83. //输出Array
  84. //(
  85. //    [0] => Array
  86. //        (
  87. //            [id] => 1
  88. //            [name] => 侯亮平
  89. //            [age] => 40
  90. //        )
  91. //
  92. //    [1] => Array
  93. //        (
  94. //            [id] => 2
  95. //            [name] => 祁同伟
  96. //            [age] => 46
  97. //        )
  98. //
  99. //    [2] => Array
  100. //        (
  101. //            [id] => 3
  102. //            [name] => 高育良
  103. //            [age] => 57
  104. //        )
  105. //
  106. //    [3] => Array
  107. //        (
  108. //            [id] => 4
  109. //            [name] => 李达康
  110. //            [age] => 51
  111. //        )
  112. //
  113. //    [4] => Array
  114. //        (
  115. //            [id] => 5
  116. //            [name] => 沙瑞金
  117. //            [age] => 56
  118. //        )
  119. //
  120. //)

7. 总结

方法拦截器中 若使用__set必须先创建__get;
数据库案例 学了数据库后终于可以看明白了~~

上一条：trait 与接口,抽象类实战下一条：【个人用】VsCode编辑器初始个性化设置
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多