search

博客列表 >PHP中MySQLi常见的CURD操作以及接口多态的实现--***十期线上班

PHP中MySQLi常见的CURD操作以及接口多态的实现--***十期线上班

Miss灬懒虫
Miss灬懒虫原创
2020年02月17日 11:37:391423浏览

PHP中MySQLi常见的CURD操作以及接口多态的实现

学习总结

在本次学习内容的实践过程中，发现Mysqli相对于PDO的要简洁一些，而且mysql_result的结果集的操作个人感觉也比较简单。

其次，就是无论是PDO还是MySQLi，在访问数据库的步骤上基本是一致的，细节上略有差别而已。

最后，对于接口的多态实现，其本质上，还是利用了接口之间允许继承，并且可以多继承的特性。与此同时，也因为接口仅仅是定义，也就是说接口具备一个接口，允许有多个类进行不同的实现的特性。正是因为这些特性，接口才能很好地实现PHP面向对象开发中的多态。

以上仅代表个人观点哦！ - _ -

数据库

mysqli 面向对象操作-运行效果

mysqli 面向对象操作-代码

  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: Air15_2019
  5.  * Date: 2020/2/12
  6.  * Time: 10:57
  7.  */
  9. namespace Mysql_data;
  11. use mysqli;
  13. //mysqli 面向对象操作数据库
  15. class MySQLi_Basics{
  17.     //新增
  18.     public function inter_SQL(){
  20.         //1.创建mysqli对象，连接数据库
  21.         $mysqli=new mysqli('localhost','root','root888','test');
  23.         //2.传入需要---执行的SQL语句
  24.         $sql = 'INSERT `tf_users` SET `f_name`=?, `f_password`=?,`f_email`=?,`f_phone`=?,`f_regtime`=?;';
  26.         //3.通过stmt_init(),实例化一个预处理对象，防止SQL注入攻击
  27.         $stmt=$mysqli->stmt_init();
  29.         //3.1 使用预处理对象下的prepare()方法，将SQl注入到预处理对象中
  30.         $stmt->prepare($sql);
  32.         //参数
  33.         $user = ['李木子', sha1('5649725'), 'li_muzi@mayituyu.cn', '1786411111',date('yy-m-d h:i:s',time())];
  34.         list($name, $password, $email,$phone,$regtime) = $user;
  36.         // 使用预处理对象的 bind_param('参数的类型', 参数列表.....)方法，绑定参数到其中
  37.         $stmt->bind_param('sssss', $name, $password, $email, $phone,$regtime);
  39.         // 准备完成---执行
  40.         $stmt->execute();
  42.         // 4. 处理执行的结果
  43.         if ($stmt->affected_rows === 1) :
  44.             echo '添加成功, 新记录的主键id: ' . $stmt->insert_id;
  45.         else :
  46.             echo '添加失败' . $stmt->error;
  47.         endif;
  49.         // 5. 结束操作
  50.         // 关闭数据库连接
  51.         $stmt->close();
  52.     }
  54.     //更新
  55.     public function update_SQL(){
  57.         $mysqli=new mysqli('localhost','root','root888','test');
  58.         $sql = "UPDATE `tf_users` SET `f_phone`=?,`f_regtime`=? WHERE `f_id`=?;";
  60.         //3.通过stmt_init(),实例化一个预处理对象，防止SQL注入攻击
  61.         $stmt=$mysqli->stmt_init();
  63.         //3.1 使用预处理对象下的prepare()方法，将SQl注入到预处理对象中
  64.         $stmt->prepare($sql);
  66.         //参数
  67.         $user = ['15867425596',date('yy-m-d h:i:s',time()),2];
  68.         list($phone,$regtime,$id) = $user;
  70.         // 使用预处理对象的 bind_param('参数的类型', 参数列表.....)方法，绑定参数到其中
  71.         $stmt->bind_param('ssi',  $phone,$regtime,$id);
  73.         // 准备完成---执行
  74.         $stmt->execute();
  76.         // 4. 处理执行的结果
  77.         if ($stmt->affected_rows === 1) :
  78.             echo 'ID：'.$id.'的数据更新成功！更新时间:'.$regtime;
  79.         else :
  80.             echo '更新失败' . $stmt->error;
  81.         endif;
  83.         // 5. 结束操作
  84.         // 关闭数据库连接
  85.         $stmt->close();
  86.     }
  88.     //删除
  89.     public function delete_SQL($id){
  91.         //1.创建mysqli对象，连接数据库
  92.         $mysqli=new mysqli('localhost','root','root888','test');
  94.         //2.传入需要---执行的SQL语句
  95.         $sql = 'DELETE FROM `tf_users` WHERE `f_id`=?;';
  97.         //3.通过stmt_init(),实例化一个预处理对象，防止SQL注入攻击
  98.         $stmt=$mysqli->stmt_init();
  100.         //3.1 使用预处理对象下的prepare()方法，将SQl注入到预处理对象中
  101.         $stmt->prepare($sql);
  103.         //参数
  104.         $user_id = $id;
  106.         // 使用预处理对象的 bind_param('参数的类型', 参数列表.....)方法，绑定参数到其中
  107.         $stmt->bind_param('i', $user_id);
  109.         // 准备完成---执行
  110.         $stmt->execute();
  112.         // 4. 处理执行的结果
  113.         if ($stmt->affected_rows === 1) :
  114.             echo 'ID：'.$user_id.'的数据删除成功！删除时间:'.date('yy-m-d h:i:s',time());
  115.         else :
  116.             echo '删除失败' . $stmt->error;
  117.         endif;
  119.         // 5. 结束操作
  120.         // 关闭数据库连接
  121.         $stmt->close();
  122.     }
  124.     //查询-1 使用STMT对象查询（预处理对象）
  125.     public function select_SQL($id){
  127.         //1.创建mysqli对象，连接数据库
  128.         $mysqli=new mysqli('localhost','root','root888','test');
  130.         //2.传入需要---执行的SQL语句
  131.         $sql = 'SELECT `f_name`,`f_email`,`f_regtime` FROM `tf_users` WHERE `f_id`>?;';
  133.         //3.通过stmt_init(),实例化一个预处理对象，防止SQL注入攻击
  134.         $stmt=$mysqli->stmt_init();
  136.         //3.1 使用预处理对象下的prepare()方法，将SQl注入到预处理对象中
  137.         $stmt->prepare($sql);
  139.         //参数
  140.         $user_id = $id;
  142.         // 使用预处理对象的 bind_param('参数的类型', 参数列表.....)方法，绑定参数到其中
  143.         $stmt->bind_param('i', $user_id);
  145.         // 准备完成---执行
  146.         $stmt->execute();
  148.         // 4. 处理执行的结果
  150.         //4.1使用 bind_result()方法，将结果集中的字段绑定在变量上
  151.         $stmt->bind_result($name,$email,$regtime);
  153.         //4.2 使用fetch()方法，获取结果集中的当前一条记录，并且数据指针会自动下移一个；
  154.         while ($stmt->fetch()){
  155.             echo '用户名：'.$name.',的邮箱是：'.$email.'，用户注册时间：'.$regtime.'<br>';
  156.         }
  158.         // 5. 结束操作
  159.         //5.1 使用 free_result() 释放结果集所占用的内存
  160.         $stmt->free_result();
  162.         // 关闭数据库连接
  163.         $stmt->close();
  164.     }
  166.     //查询-2 使用
  167.     public function select_results($id){
  168.         $mysqli=new mysqli('localhost','root','root888','test');
  169.         $sql = 'SELECT `f_name`,`f_email`,`f_regtime` FROM `tf_users` WHERE `f_id`>?;';
  170.         $stmt=$mysqli->stmt_init();
  171.         $stmt->prepare($sql);
  172.         $user_id = $id;
  173.         $stmt->bind_param('i', $user_id);
  174.         $stmt->execute();
  176.         //1.使用 get_result()，获取结果集对象
  177.         $result=$stmt->get_result();
  179.         /*
  180.          * 2. 处理执行的结果
  181.          * fetch_array(),获取一条记录，包含索引和关联
  182.          * fetch_row(),获取一条记录，仅索引部分；
  183.          * fetch_assoc()获取一条记录，仅关联部分;
  184.          * fetch_all(),一次性获取所有数据(参数为MYSQLI_ASSOC)时，只返回关联部分;
  185.          * data_seek(0),索引归 0 复位;
  186.          * free_result(),释放结果集所占用的内存;
  187.          * */
  189.         //循环遍历输出
  190.         while ($users=$result->fetch_assoc()){
  191.             echo '用户名：'.$users['f_name'].',的邮箱是：'.$users['f_email'].'，用户注册时间：'.$users['f_regtime'].'<br>';
  192.         }
  194.         //索引复位  因为上面以及遍历完了 ，我们下面使用fetch_all一次性返回所有数据，所以需要先将指针复位;
  195.         echo '<br>========一次性输出所有========<br>';
  196.         $result->data_seek(0);
  198.         //fetch_all
  199.         $users=$result->fetch_all(MYSQLI_ASSOC);
  200.         foreach ($users as $user){
  201.             echo '用户名：'.$user['f_name'].',的邮箱是：'.$user['f_email'].'，用户注册时间：'.$user['f_regtime'].'<br>';
  202.         }
  204.         // 5. 结束操作
  205.         //5.1 使用 free_result() 释放结果集所占用的内存;
  206.         $result->free_result();
  208.         // 关闭数据库连接
  209.         $stmt->close();
  210.     }
  212. }
  214. $mysql_sql=new MySQLi_Basics();
  216. //新增
  217. $mysql_sql->inter_SQL();
  218. echo '<hr>';
  220. //更新
  221. $mysql_sql->update_SQL();
  222. echo '<hr>';
  224. //删除
  225. $mysql_sql->delete_SQL(9);
  226. echo '<hr>';
  228. //查询-1
  229. $mysql_sql->select_SQL(2);
  230. echo '<hr>';
  232. //查询-2
  233. $mysql_sql->select_results(2);
  235. ?>

接口多态—文件目录

运行效果

PDO


MySQLi

DB_interface.php 文件代码

  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: Air15_2019
  5.  * Date: 2020/2/12
  6.  * Time: 15:27
  7.  * Description: 数据访问接口定义
  8.  */
  10. /*
  11.  * 接口之间允许继承，并且可以多继承。与此同时，一个接口，允许有多个类进行不同的实现。
  12.  * 正是因为接口的这些特性，才能使其实现面向对象的 `多态`实现；
  13.  * */
  15. namespace Database;
  17. //设置数据库连接参数：默认值
  18. interface inter_DbParam{
  19.     const HOST='localhost';
  20.     const TYPE='mysql';
  21.     const DB_NAME='test';
  22.     const USER_NAME='root';
  23.     const PASSWORD='root888';
  24.     const PORT='3306';
  25.     const CHARSET='utf8'; //默认字符集
  26. }
  28. //接口构造方法
  29. interface inter_DbConnection{
  30.     //构造方法，
  31.     public function __construct(array $connectionParams);
  32. }
  34. //下面是数据库连接接口中，主要被实现的类
  35. interface inter_Execute extends inter_DbParam,inter_DbConnection{
  37.     //新增操作,其参数是多个，所以参数是一个数组类型
  38.     public function ex_Insert(array $data);
  40.     //删除操作,参数是删除数据的条件
  41.     public function ex_Delete(string $where);
  43.     //更新操作,参数是更新的数据和更新条件
  44.     public function ex_Update(array $data,string $where);
  46.     //查询操作
  47.     public function ex_Select(string $where);
  48. }

DB_pdo.php 文件代码

  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: Air15_2019
  5.  * Date: 2020/2/12
  6.  * Time: 15:51
  7.  * Description: PDO方式，实现数据库访问
  8.  */
  10. namespace Database;
  12. //导入PDO
  13. use PDO;
  15. //载入接口文件
  16. require 'DB_interface.php';
  18. class db_PDO implements inter_Execute{
  19.     //连接对象
  20.     private $pdo=null;
  22.     //实现接口中的构造方法
  23.     public function __construct(array $connectionParams)
  24.     {
  25.         //将传入参数 $connectionParams 中的值，分别绑定给指定变量
  26.         list($dsn,$username,$password)=$connectionParams;
  28.         //实例化PDO对象
  29.         $this->pdo=new PDO($dsn,$username,$password);
  30.     }
  32.     //新增操作
  33.     public function ex_Insert(array $data){
  34.         $sql="INSERT `tf_users` SET `f_name`=?, `f_password`=?,`f_email`=?,`f_phone`=?,`f_regtime`=?;";
  36.         //使用PDO对象的 prepare方法创建预处理对象
  37.         $stmt=$this->pdo->prepare($sql);
  39.         //执行语句的时候，需要将新增的数据传参给execute()
  40.         $stmt->execute($data);
  42.         //rowCount()返回受影响的行数
  43.         if ($stmt->rowCount()===1){
  44.             $message='新增数据成功！';
  45.         }else{
  46.             $message='新增数据失败！';
  47.         }
  48.         return$message;
  49.     }
  51.     //删除操作
  52.     public function ex_Delete(string $where){
  53.         $sql = 'DELETE FROM `tf_users` WHERE '.$where;
  54.         $stmt=$this->pdo->prepare($sql);
  55.         $stmt->execute();
  57.         //rowCount()返回受影响的行数
  58.         if ($stmt->rowCount()===1){
  59.             $message='删除数据成功！';
  60.         }else{
  61.             $message='删除数据失败！';
  62.         }
  63.         return$message;
  64.     }
  66.     //更新操作
  67.     public function ex_Update(array $data,string $where){
  68.         //设置更新的参数
  69.         $params='';
  70.         foreach ($data as $key=>$value){
  71.             $params.="`$key`='$value',";
  72.         }
  73.         //使用 rtrim() 去掉最后的多于的 逗号
  74.         $params=rtrim($params,',');
  76.         //执行更新
  77.         $sql = "UPDATE `tf_users` SET {$params} WHERE {$where}";
  78.         $stmt = $this->pdo->prepare($sql);
  79.         $stmt->execute();
  81.         //rowCount()返回受影响的行数
  82.         if ($stmt->rowCount()===1){
  83.             $message='更新数据成功！';
  84.         }else{
  85.             $message='更新数据失败！';
  86.         }
  87.         return$message;
  88.     }
  90.     //查询操作
  91.     public function ex_Select(string $where){
  92.         //判断传入条件
  93.         $where = empty($where) ? '' : ' WHERE ' . $where;
  94.         $sql='SELECT * FROM  `tf_users` '.$where;
  95.         $stmt=$this->pdo->prepare($sql);
  96.         $stmt->execute();
  97.         //PDO::FETCH_ASSOC 输出关联部分
  98.         return $stmt->fetchAll(PDO::FETCH_ASSOC);
  100.     }
  101. }

DB_mysqli 文件代码

  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: Air15_2019
  5.  * Date: 2020/2/12
  6.  * Time: 17:56
  7.  * Description: MySQLi方式，实现数据库访问
  8.  */
  10. namespace Database;
  12. //导入MySQLi
  13. use mysqli;
  15. //载入接口文件
  16. require 'DB_interface.php';
  18. class db_MySQLi implements inter_Execute{
  19.     //连接对象
  20.     private $mysqli=null;
  22.     //实现接口中的构造方法
  23.     public function __construct(array $connectionParams)
  24.     {
  25.         //将传入参数 $connectionParams 中的值，分别绑定给指定变量
  26.         list($host,$username,$password,$dbname)=$connectionParams;
  28.         //实例化mysqli
  29.         $this->mysqli=new mysqli($host,$username,$password,$dbname);
  32.         //设置默认字符集
  33.         $this->mysqli->set_charset('utf8');
  34.     }
  37.     //新增操作
  38.     public function ex_Insert(array $data){
  39.         $sql="INSERT `tf_users` SET `f_name`=?, `f_password`=?,`f_email`=?,`f_phone`=?,`f_regtime`=?;";
  41.         //使用PDO对象的 prepare方法创建预处理对象
  42.         $stmt=$this->mysqli->prepare($sql);
  44.         //数据绑定
  45.         $stmt->bind_param('sssss',$name,$password,$email,$phone,$regtime);
  46.         list($name,$password,$email,$phone,$regtime)=$data;
  47.         //执行语句的时候，需要将新增的数据传参给execute()
  48.         $stmt->execute();
  50.         //rowCount()返回受影响的行数
  51.         if ($stmt->affected_rows===1){
  52.             $message='新增数据成功！';
  53.         }else{
  54.             $message='新增数据失败！';
  55.         }
  56.         return$message;
  57.     }
  59.     //删除操作
  60.     public function ex_Delete(string $where){
  61.         $sql = 'DELETE FROM `tf_users` WHERE '.$where;
  62.         $stmt=$this->mysqli->prepare($sql);
  63.         $stmt->execute();
  65.         //rowCount()返回受影响的行数
  66.         if ($stmt->affected_rows===1){
  67.             $message='删除数据成功！';
  68.         }else{
  69.             $message='删除数据失败！';
  70.         }
  71.         return$message;
  72.     }
  74.     //更新操作
  75.     public function ex_Update(array $data,string $where){
  76.         //设置更新的参数
  77.         $params='';
  78.         foreach ($data as $key=>$value){
  79.             $params.="`$key`='$value',";
  80.         }
  82.         //使用 rtrim() 去掉最后的多于的 逗号
  83.         $params=rtrim($params,',');
  85.         //执行更新
  86.         $sql = "UPDATE `tf_users` SET {$params} WHERE {$where}";
  87.         $stmt = $this->mysqli->prepare($sql);
  88.         $stmt->execute();
  90.         //rowCount()返回受影响的行数
  91.         if ($stmt->affected_rows===1){
  92.             $message='更新数据成功！';
  93.         }else{
  94.             $message='更新数据失败！';
  95.         }
  96.         return$message;
  97.     }
  99.     //查询操作
  100.     public function ex_Select(string $where){
  101.         //判断传入条件
  102.         $where = empty($where) ? '' : ' WHERE ' . $where;
  103.         $sql='SELECT * FROM  `tf_users` '.$where;
  104.         $stmt=$this->mysqli->prepare($sql);
  105.         $stmt->execute();
  107.         //通过 get_result()获取预处理对象的结果集
  108.         $results=$stmt->get_result();
  109.         return $results;
  111.     }
  112. }

DB.php 文件代码

  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: Air15_2019
  5.  * Date: 2020/2/12
  6.  * Time: 16:34
  7.  * Description: DB通用类，面向接口实现PDO、MySQLi的动态支持（多态）
  8.  */
  10. namespace Database;
  11. use Database\inter_Execute as iDb;
  13. /*
  14.  * DB 通用类中，使用了接口作为 类方法参数，
  15.  * 并且在类方法中返回了接口的方法结果;
  16.  * */
  17. class DB{
  18.     //新增
  19.     public static function db_Insert(iDb $db,array $data){
  20.         return $db->ex_Insert($data);
  21.     }
  23.     //删除
  24.     public static function db_Delete(iDb $db,string $where){
  25.         return $db->ex_Delete($where);
  26.     }
  28.     //更新
  29.     public static function db_Update(iDb $db,array $data,string $where){
  30.         return $db->ex_Update($data,$where);
  31.     }
  33.     //查询
  34.     public static function db_Select(iDb $db, $where){
  35.         return $db->ex_Select($where);
  36.     }
  37. }

Access_pdo.php 文件代码

  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: Air15_2019
  5.  * Date: 2020/2/12
  6.  * Time: 16:51
  7.  * Description: 通过BD类，使用PDO方式访问数据库
  8.  */
  10. namespace Database;
  12. //加载文件
  13. require 'DB_pdo.php';
  14. require 'DB.php';
  16. // 拼接 $dsn
  17. $dsn= inter_DbParam::TYPE . ':host='.inter_DbParam::HOST . ';dbname=' . inter_DbParam::DB_NAME . ';charset='.inter_DbParam::CHARSET;
  19. // 拼接数组参数
  20. $paranms=[
  21.     $dsn,
  22.     inter_DbParam::USER_NAME,
  23.     inter_DbParam::PASSWORD
  24. ];
  26. //创建PDO
  27. $link=new db_PDO($paranms);
  29. echo '===========PDO测试============<br>';
  30. // 测试新增操作
  31. echo '消息：'.DB::db_Insert($link,['李继承',sha1('584627'),'zhang_chenghao@mayitiyu.cn','17569842711',date('yy-m-d h:i:s',time())]);
  32. echo '<hr>';
  34. // 测试查询
  35. foreach (DB::db_Select($link, 'f_id > 2') as $user) {
  36.     echo '用户名：'.$user['f_name'].',的邮箱是：'.$user['f_email'].'，用户注册时间：'.$user['f_regtime'].'<br>';
  37. }
  38. echo '<hr>';
  40. // 更新测试
  41. echo DB::db_Update($link,['f_name'=>'逍遥王子', 'f_email'=>'xiaoyao_wangzi@mayitiyu.cn'], 'f_id=5');
  42. echo '<hr>';
  44. // 删除操作
  45. echo DB::db_Delete($link,'f_id=13');

Access_mysqli.php 文件代码

  1. <?php
  2. /**
  3.  * Created by PhpStorm.
  4.  * User: Air15_2019
  5.  * Date: 2020/2/12
  6.  * Time: 17:55
  7.  * Description: 通过BD类，使用MySQLi方式访问数据库
  8.  */
  10. namespace Database;
  12. //加载文件
  13. require 'DB_mysqli.php';
  14. require 'DB.php';
  16. // 拼接数组参数
  17. $paranms=[
  18.     inter_DbParam::HOST,
  19.     inter_DbParam::USER_NAME,
  20.     inter_DbParam::PASSWORD,
  21.     inter_DbParam::DB_NAME
  22. ];
  24. //创建PDO
  25. $link=new db_MySQLi($paranms);
  27. echo '===========MySQLi测试============<br>';
  28. // 测试新增操作
  29. echo '消息：'.DB::db_Insert($link,['王重阳',sha1('75264889'),'wang_chongyang@mayitiyu.cn','17569842711',date('yy-m-d h:i:s',time())]);
  30. echo '<hr>';
  32. // 测试查询
  33. foreach (DB::db_Select($link, 'f_id > 2') as $user) {
  34.     echo '用户名：'.$user['f_name'].',的邮箱是：'.$user['f_email'].'，用户注册时间：'.$user['f_regtime'].'<br>';
  35. }
  36. echo '<hr>';
  38. // 更新测试
  39. echo DB::db_Update($link,['f_name'=>'逍遥王孙', 'f_email'=>'xiaoyao_wangsun@mayitiyu.cn'], 'f_id=5');
  40. echo '<hr>';
  42. // 删除操作
  43. echo DB::db_Delete($link,'f_id=14');

MySQLi 基础知识抄写



上一条：0211作业-mysqli基础和接口实战-php培训十期线上班下一条：HTML元素
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多