search

博客列表 >PHP封装的PDO操作MySql数据库操作类！简单易用！

PHP封装的PDO操作MySql数据库操作类！简单易用！

TANKING的代码日志
TANKING的代码日志原创
2023年10月21日 09:53:3093浏览

摘要

数据库操作类可以封装数据库连接和操作，使代码更易于维护和扩展。它们提供了一种组织代码的方法，将数据库相关的功能放在一个类中，以便于复用。

良好的数据库操作类可以提供一定程度的安全性，通过参数化查询或准备语句来防止SQL注入攻击。这有助于保护数据库免受恶意输入的影响。

良好的数据库操作类可以提供一定程度的安全性，通过参数化查询或准备语句来防止SQL注入攻击。这有助于保护数据库免受恶意输入的影响。

数据库操作类有助于提高PHP应用程序的可维护性、安全性和性能，同时促进代码的重用和更好的代码组织。然而，选择适合项目需求的数据库操作类以及正确使用它们非常重要。

Database.php

  1. <?php
  3.     /**
  4.      * PHP PDO MySQL数据库操作类
  5.      * 作者：TANKING
  6.      * 时间：2023-10-12
  7.      * 博客：https://segmentfault.com/u/tanking
  8.      */
  10.     class DB_API {
  11.         private $pdo;
  12.         private $error;
  14.         // 连接数据库
  15.         public function __construct($config) {
  16.             $dsn = "mysql:host={$config['db_host']};port={$config['db_port']};dbname={$config['db_name']}";
  17.             try {
  18.                 $this->pdo = new PDO($dsn, $config['db_user'], $config['db_pass']);
  19.                 $this->pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
  20.             } catch (PDOException $e) {
  21.                 $this->error = $e->getMessage();
  22.             }
  23.         }
  25.         // 插入
  26.         public function add($table, $data) {
  27.             try {
  28.                 $columns = implode(', ', array_keys($data));
  29.                 $values = implode(', :', array_keys($data));
  30.                 $query = "INSERT INTO $table ($columns) VALUES (:$values)";
  31.                 $stmt = $this->pdo->prepare($query);
  32.                 $stmt->execute($data);
  33.                 return $this->pdo->lastInsertId();
  34.             } catch (PDOException $e) {
  35.                 $this->error = $e->getMessage();
  36.                 return false;
  37.             }
  38.         }
  40.         // 更新
  41.         public function update($table, $where, $data) {
  42.             try {
  44.                 // 构建SET子句
  45.                 $set = '';
  46.                 foreach ($data as $key => $value) {
  47.                     $set .= "$key = :$key, ";
  48.                 }
  49.                 $set = rtrim($set, ', ');
  51.                 // 构建WHERE子句
  52.                 $whereClause = '';
  53.                 foreach ($where as $key => $value) {
  54.                     $whereClause .= "$key = :where_$key AND ";
  55.                 }
  56.                 $whereClause = rtrim($whereClause, 'AND ');
  58.                 // 构建SQL查询
  59.                 $query = "UPDATE $table SET $set WHERE $whereClause";
  61.                 // 创建预处理语句
  62.                 $stmt = $this->pdo->prepare($query);
  64.                 // 绑定更新数据的参数
  65.                 foreach ($data as $key => $value) {
  66.                     $stmt->bindValue(":$key", $value);
  67.                 }
  69.                 // 绑定WHERE条件的参数
  70.                 foreach ($where as $key => $value) {
  71.                     $stmt->bindValue(":where_$key", $value);
  72.                 }
  74.                 // 执行预处理语句
  75.                 $stmt->execute();
  77.                 // 操作成功
  78.                 return true;
  80.             } catch (PDOException $e) {
  81.                 $this->error = $e->getMessage();
  83.                 // 操作失败
  84.                 return false;
  85.             }
  86.         }
  88.         // 删除
  89.         public function delete($table, $where, $params = array()) {
  90.             try {
  91.                 // 构建WHERE子句
  92.                 $whereClause = '';
  93.                 foreach ($where as $key => $value) {
  94.                     $whereClause .= "$key = :$key AND ";
  95.                 }
  96.                 $whereClause = rtrim($whereClause, 'AND ');
  98.                 // 构建SQL查询
  99.                 $query = "DELETE FROM $table WHERE $whereClause";
  101.                 // 创建预处理语句
  102.                 $stmt = $this->pdo->prepare($query);
  104.                 // 绑定WHERE条件的参数
  105.                 foreach ($where as $key => $value) {
  106.                     $stmt->bindValue(":$key", $value);
  107.                 }
  109.                 // 执行预处理语句
  110.                 $stmt->execute();
  112.                 // 操作成功
  113.                 return true;
  114.             } catch (PDOException $e) {
  115.                 $this->error = $e->getMessage();
  117.                 // 操作失败
  118.                 return false;
  119.             }
  120.         }
  122.         // 查询
  123.         public function select($table, $fields = "*", $conditions = null, $likeConditions = null, $orderBy = null, $limit = null, $params = array()) {
  124.             try {
  125.                 // 构建SELECT子句
  126.                 if (is_array($fields)) {
  127.                     $fields = implode(', ', $fields);
  128.                 } elseif ($fields === "*") {
  129.                     $fields = "*";
  130.                 } else {
  131.                     $fields = "";
  132.                 }
  134.                 // 构建WHERE子句
  135.                 $whereClause = '';
  136.                 if (!is_null($conditions) && is_array($conditions)) {
  137.                     foreach ($conditions as $key => $value) {
  138.                         $whereClause .= "$key = :$key AND ";
  139.                     }
  140.                     $whereClause = rtrim($whereClause, 'AND ');
  141.                 }
  143.                 // 合并LIKE条件
  144.                 if (!is_null($likeConditions) && is_array($likeConditions)) {
  145.                     if (!empty($whereClause)) {
  146.                         $whereClause .= ' AND ';
  147.                     }
  148.                     foreach ($likeConditions as $key => $value) {
  149.                         $whereClause .= "$key LIKE :like_$key AND ";
  150.                         $params[":like_$key"] = $value;
  151.                     }
  152.                     $whereClause = rtrim($whereClause, 'AND ');
  153.                 }
  155.                 // 构建ORDER BY子句
  156.                 $orderByClause = '';
  157.                 if (!is_null($orderBy) && is_array($orderBy)) {
  158.                     $orderByClause = "ORDER BY " . implode(', ', $orderBy);
  159.                 }
  161.                 // 构建LIMIT子句
  162.                 $limitClause = '';
  163.                 if (!is_null($limit)) {
  164.                     $limitClause = "LIMIT $limit";
  165.                 }
  167.                 // 构建SQL查询
  168.                 $query = "SELECT $fields FROM $table";
  169.                 if (!empty($whereClause)) {
  170.                     $query .= " WHERE $whereClause";
  171.                 }
  172.                 if (!empty($orderByClause)) {
  173.                     $query .= " $orderByClause";
  174.                 }
  175.                 if (!empty($limitClause)) {
  176.                     $query .= " $limitClause";
  177.                 }
  179.                 // 创建预处理语句
  180.                 $stmt = $this->pdo->prepare($query);
  182.                 // 绑定参数
  183.                 if (!is_null($conditions) && is_array($conditions)) {
  184.                     foreach ($conditions as $key => $value) {
  185.                         $stmt->bindValue(":$key", $value);
  186.                     }
  187.                 }
  189.                 if (!is_null($likeConditions) && is_array($likeConditions)) {
  190.                     foreach ($likeConditions as $key => $value) {
  191.                         $stmt->bindValue(":like_$key", $value);
  192.                     }
  193.                 }
  195.                 // 执行预处理语句
  196.                 $stmt->execute();
  198.                 // 获取查询结果
  199.                 $result = $stmt->fetchAll(PDO::FETCH_ASSOC);
  201.                 return $result; // 返回查询结果数组
  202.             } catch (PDOException $e) {
  203.                 $this->error = $e->getMessage();
  204.                 return false; // 操作失败
  205.             }
  206.         }
  208.         // 执行原生SQL语句
  209.         public function execQuery($query, $params = array()) {
  210.             try {
  211.                 // 创建预处理语句
  212.                 $stmt = $this->pdo->prepare($query);
  214.                 // 绑定参数
  215.                 foreach ($params as $key => $value) {
  216.                     $stmt->bindValue($key, $value);
  217.                 }
  219.                 // 执行预处理语句
  220.                 $stmt->execute();
  222.                 // 操作成功
  223.                 return true;
  224.             } catch (PDOException $e) {
  225.                 $this->error = $e->getMessage();
  227.                 // 操作失败
  228.                 return false;
  229.             }
  230.         }
  232.         // 错误信息
  233.         public function errorMsg() {
  234.             return $this->error;
  235.         }
  236.     }

Db.php

  1. <?php
  3.     // 引入操作类
  4.     include 'Database.php';
  6.     // 配置文件
  7.     $config = array(
  8.         'db_host' => 'localhost',
  9.         'db_port' => 3306,
  10.         'db_name' => 'xxx',
  11.         'db_user' => 'xxx',
  12.         'db_pass' => 'xxx'
  13.     );
  14. ?>

使用示例

以表名为 test_table 为示例作为示例代码。

创建表SQL:

  1. CREATE TABLE `test_table` (
  2.   `id` int(10) PRIMARY KEY AUTO_INCREMENT NOT NULL,
  3.   `title` varchar(32) NOT NULL,
  4.   `content` varchar(255) NOT NULL
  5. ) ENGINE=InnoDB DEFAULT CHARSET=utf8;

insert示例

  1. <?php
  3.     // 引入配置
  4.     include 'Db.php';
  6.     // 实例化
  7.     $db = new DB_API($config);
  9.     // 数据
  10.     $insertData = array(
  11.         'title' => 'this is title',
  12.         'content' => 'this is content',
  13.     );
  15.     // 执行
  16.     $insertSQL = $db->add('test_table', $insertData);
  18.     // 结果
  19.     if ($insertSQL) {
  21.         // 成功
  22.         echo '插入成功，ID是：' . $insertSQL;
  23.     } else {
  25.         // 失败
  26.         echo '插入失败，原因：' . $db->errorMsg();
  27.     }
  28. ?>

update示例

  1. <?php
  3.     // 引入配置
  4.     include 'Db.php';
  6.     // 实例化
  7.     $db = new DB_API($config);
  9.     // 条件
  10.     // 只支持=，不支持>，<，>=，<=之类的
  11.     // 如需更复杂的条件请使用执行原生语句的方法
  12.     $where = array(
  13.         'id' => '1'
  14.     );
  16.     // 数据
  17.     $updateData = array(
  18.         'content' => 'content is updated'
  19.     );
  21.     // 执行
  22.     $updatedSQL = $db->update('test_table', $where, $updateData);
  24.     // 结果
  25.     if ($updatedSQL) {
  27.         // 成功
  28.         echo '更新成功';
  29.     } else {
  31.         // 失败
  32.         echo '更新失败，原因：' . $db->errorMsg();
  33.     }
  35. ?>

delete示例

  1. <?php
  3.     // 引入配置
  4.     include 'Db.php';
  6.     // 实例化
  7.     $db = new DB_API($config);
  9.     // 条件
  10.     $where = array(
  11.         'id' => 4,
  12.     );
  14.     // 执行
  15.     $deleteSQL = $db->delete('test_table', $where);
  17.     // 结果
  18.     if ($deleteSQL) {
  20.         // 成功
  21.         echo '删除成功';
  22.     } else {
  24.         // 失败
  25.         echo '删除失败，原因：' . $db->errorMsg();
  26.     }
  28. ?>

select示例

  1. <?php
  3.     // 引入配置
  4.     include 'Db.php';
  6.     // 实例化
  7.     $db = new DB_API($config);
  9.     // 使用方法
  10.     // $db->select('表名', ['字段1','字段2',...], where条件, LIKE条件, ORDER条件, LIKIT条件);
  11.     // 如果查询所有字段，使用'*'代替数组
  12.     // $db->select('表名', '*', where条件, LIKE条件, ORDER条件, LIKIT条件);
  13.     // 无需使用的条件传递null
  14.     // $db->select('表名', '*', where条件, null, null, null);
  16.     // 查询所有字段，没有查询条件
  17.     $selectSQL = $db->select('test_table', '*');
  19.     // 查询指定字段，没有查询条件
  20.     // $selectSQL = $db->select('test_table', ['id', 'title']);
  22.     // 根据以下条件
  23.     // 查询所有字段
  24.     // $where = array(
  25.     //     'id' => 3
  26.     // );
  27.     // $selectSQL = $db->select('test_table', '*', $where);
  29.     // 根据以下条件
  30.     // 查询指定字段
  31.     // $where = array(
  32.     //     'id' => 3
  33.     // );
  34.     // $selectSQL = $db->select('test_table', ['title'], $where);
  36.     // 使用LIKE条件
  37.     // 如果没有where条件就直接传入null
  38.     // '*'是查询所有字段，如需查询指定字段传入['字段1','字段2',....]
  39.     // $likeWhere = array(
  40.     //     'title' => '%一带一路%'
  41.     // );
  42.     // $selectSQL = $db->select('test_table', '*', null, $likeWhere);
  44.     // 使用where条件和LIKE条件
  45.     // '*'是查询所有字段，如需查询指定字段传入['字段1','字段2',....]
  46.     // $where = array(
  47.     //     'id' => 3
  48.     // );
  49.     // $likeWhere = array(
  50.     //     'title' => '%一带一路%'
  51.     // );
  52.     // $selectSQL = $db->select('test_table', '*', $where, $likeWhere);
  54.     // 使用排序条件
  55.     // $orderBy = array('id DESC');
  56.     // $selectSQL = $db->select('test_table', '*', null, null, $orderBy);
  58.     // 使用限制条件
  59.     // $limit = 2; // 取2条
  60.     // $limit = '0,3'; // 第1条开始，取3条
  61.     // $limit = '5,2'; // 第5条开始，取2条
  62.     // $selectSQL = $db->select('test_table', '*', null, null, null, $limit);
  64.     // 结果
  65.     if ($selectSQL) {
  67.         // 成功
  68.         echo json_encode($selectSQL, JSON_UNESCAPED_UNICODE);
  69.     } else {
  71.         // 失败
  72.         echo '查询失败，原因：' . $db->errorMsg();
  73.     }
  75. ?>

执行原生语句示例

  1. <?php
  3.     // 引入配置
  4.     include 'Db.php';
  6.     // 实例化
  7.     $db = new DB_API($config);
  9.     // SQL语句
  10.     $query = "INSERT INTO test_table (title, content) VALUES (:title, :content)";
  12.     // 数据绑定
  13.     $params = array(
  14.         ':title' => 'New Title By execQuery',
  15.         ':content' => 'New Content By execQuery',
  16.     );
  18.     // 执行
  19.     $querySQL = $db->execQuery($query, $params);
  21.     // 结果
  22.     if ($querySQL) {
  24.         // 成功
  25.         echo 'SQL执行成功！';
  26.     } else {
  28.         // 失败
  29.         echo 'SQL执行失败，原因：' . $db->errorMsg();
  30.     }
  31. ?>

作者

TANKING

上一条：一个php文件搞定微信小程序订阅消息推送（含access_token的获取、缓存、刷新）下一条：JS基础要点
声明：本文内容转载自脚本之家，由网友自发贡献，版权归原作者所有，如您发现涉嫌抄袭侵权，请联系admin@php.cn 核实处理。
全部评论
文明上网理性发言，请遵守新闻评论服务协议

相关文章

查看更多