碼上快樂

相關內容    簡體    繁體

php數據庫功能類-mysql類

本文轉載自   查看原文   2019-04-24 10:41   922    php
 

配置文件和Mysql類

一．創建Mysql類
1.本身我們將使用PDO來操控數據庫，而不管哪種數據庫引擎，直接操作都比較松散，所以我們有必要做適當的封裝(封裝過度也會導致學習成本過高，適當就好)。
2.創建一個方法端mysql.php的類。

//MySQL數據庫類
class Mysql
{
}

3.創建對外的調用端1.php引入方法端數據庫mysql.php

<?php

//引入數據庫類
require 'mysql.php';

$Mysql = new Mysql();

4.創建類中的構造方法，構造方法里通過PDO來連接數據庫。

方法端mysql.php類：

復制代碼 
//構造方法，自動連接PDO
<?php

//數據庫類
class Mysql
{

    //構造方法，自動PDO連接數據庫
    public function __construct()
    {
        try {

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host=localhost;dbname=example', 'xixi','123456');

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    
}
復制代碼

測試是否鏈接成功：http://192.168.3.62/Example/mysql/1.php

二．配置文件
1.數據庫配置信息直接在mysql.php文件中，當移植或配置其他數據庫服務器時，需要經常改動這里，帶來麻煩。我們需要創建一個配置文件config.php，來統一處理所有配置信息。
2.創建config.php，使用return array()數組方式配置信息。

復制代碼 
<?php

//返回配置文件數組
return array(

    //數據庫配置
    'DB_HOST'           =>          'localhost',        //服務器地址
    'DB_NAME'           =>          'example',          //數據庫名
    'DB_USER'           =>          'xixi',             //用戶名
    'DB_PASS'           =>          '123456'            //密碼

);
復制代碼

3.將配置信息config.php引入到Mysql.class.php類中去。

復制代碼 
<?php

//數據庫類
class Mysql
{

    //構造方法，自動PDO連接數據庫
    public function __construct()
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
}
復制代碼

調用端1.php測試是否連接成功

三．內部實例化
1.如果每次都要在外部進行new Mysql();這樣看上去顯得麻煩，也難受。
2.我們可以在方法端mysql.php的內部通過靜態方法進行實例化，外部直接調用這個方法，即完成了實例化的過程。

復制代碼 
<?php

//數據庫類
class Mysql
{

    //構造方法，自動PDO連接數據庫
    public function __construct()
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function stmt()
    {
        //返回出一個對象
        return new self();
    }

    public function test()
    {
        echo 'test';
    }
}
復制代碼

3.通過外部調用端1.php調用Mysql類。

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';
//實例化並創建對象
$Mysql = Mysql::stmt();
//調用
$Mysql->test();
復制代碼

調用端1.php查看測試
test

數據庫功能類-封裝新增方法

通過一個簡單的傳遞參數，即可智能實現數據新增。
一．調用猜想
1.如果使用過一些框架，它們就把增刪改查進行了有效的封裝。
2.通過實例化，將調用端1.php和方法端mysql.php關聯的數據表關聯上。

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql();
打印出$Mysql這個對象測試
var_dump($Mysql);
復制代碼

調用端1.php查看測試
object(Mysql)[1]

3.字段和值，通過數組傳遞。
給對外的調用端1.php新增數據，通過數組傳遞方式把字段和值傳進去：

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';

//實例化並創建對象，給這個ex_user表傳值
$Mysql = Mysql::mysql('ex_user');

//新增數據，通過數組實現字段和值的對應
$data = array(
    'name'              =>          '西西',
    'age'               =>           29,
    'create_time'       =>          date('Y-m-d H:i:s')
);

//寫入數據庫，並返回當前最新的ID值
echo $Mysql->add($data);
復制代碼

二．方法端mysql.php逐步實現數據庫封裝新增方法

第一步：在Mysql類中，創建一個新增方法，數據庫新增字段數組

復制代碼 
public function add($data)
    {
        //通過array_keys得到字段數組$keys，不管傳多少值只要得到$keys就行了
        $keys = array_keys($data);
        //打印$keys值查看
        print_r($keys);
    }
復制代碼

查看:
Array ( [0] => name [1] => age [2] => create_time )

第二步：新增方法關聯的表和PDO對象，需要在構造方法里保存。

復制代碼 
//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;

    //構造方法，自動PDO連接數據庫
    public function __construct()
    {
        try {
            //保存PDO對象為屬性
            $this->pdo = $pdo;

        } 
    }
    //數據庫新增操作
    public function add($data)
    {
    }
}
復制代碼

第三步：實現sql語句寫入到數據庫

復制代碼 
//數據庫實現新增
    public function add($data)
    {
        //SQL新增
        $sql = "INSERT INTO ex_user (name, age, create_time) VALUES ('西西',18,NOW())";
        //執行SQL語句
        $this->pdo->prepare($sql)->execute();
    }
復制代碼

第四步：sql寫入到數據庫后返回一個寫入的ID

//數據庫新增操作
    public function add($data)
    {
        //返回最新的ID值
        return $this->pdo->lastInsertId();
    }

第五步：將字段數組加上防止沖突的`符號，得到字段字符串

復制代碼 
//數據庫新增操作
    public function add($data)
    {
        //得到字段數組
        $keys = array_keys($data);

        //將字段數組加上防止沖突的`符號
        foreach ($keys as $key=>$value) {
            $keys[$key] = '`'.$value.'`';
        }

        //得到字段字符串
        $fields = implode(',', $keys);
        echo $fields;
        
    }
復制代碼

通過echo $fields打印查看得到字段字符串：
`name`,`age`,`create_time`

第六步：得到值字符串，給值字符串加上單引號

復制代碼 
//數據庫新增操作
    public function add($data)
    {
        //給值字符串加上單引號
        foreach ($data as $key=>$value) {
            $data[$key] = "'".$value."'";
        }

        //得到值字符串
        $values = implode(',', $data);
        echo $values;
    }
復制代碼

通過echo $values打印查看將要寫入到數據庫值字符串   
'西西','29','2018-03-02 09:49:31'

第七步：在所有的方法里共享表名ex_user

復制代碼 
<?php

//數據庫類
class Mysql
{
    //將表名保存至屬性
    private $table;

    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {
            //保存數據表名,加上單引號防止出錯
            $this->table = '`'.$table.'`';
        } catch (PDOException $e) {
        }
    }

    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    //數據庫新增操作
    public function add($data)
    {
    }
}
復制代碼

第八步：通過得到的第五步字段字符串，第六步值字符串，第七步ex_user表名重組SQL語句

//數據庫新增操作
    public function add($data)
    {
        //重組SQL語句
        $sql = "INSERT INTO $this->table ($fields) VALUES ($values)";
    }

最后整理最終代碼：:

復制代碼 
<?php

//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;


    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }

    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    //數據庫新增操作
    public function add($data)
    {
        //得到字段數組
        $keys = array_keys($data);

        //將字段數組加上防止沖突的`符號
        foreach ($keys as $key=>$value) {
            $keys[$key] = '`'.$value.'`';
        }

        //得到字段字符串
        $fields = implode(',', $keys);

        //給值字符串加上單引號
        foreach ($data as $key=>$value) {
            $data[$key] = "'".$value."'";
        }

        //得到值字符串
        $values = implode(',', $data);


        //SQL新增
        $sql = "INSERT INTO $this->table ($fields) VALUES ($values)";


        //執行SQL語句
        $this->pdo->prepare($sql)->execute();

        //返回最新的ID值
        return $this->pdo->lastInsertId();
    }

}
復制代碼

數據庫功能類-封裝修改方法

一．封裝修改
調用端1.php倆種修改方式通過提交的ID判斷條件或自定義判斷條件

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';
//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');
//可以直接通過提交的ID判斷條件或自定義判斷條件。修改數據id篩選傳遞
<?php
//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//將要修改的數據，有兩種方式修改
$data = array(
    'id'                =>          1,
    'name'              =>          '西西',
    'age'               =>          18
);

//修改數據庫，並返回當前影響行數(返回大於0，說明修改成功)
//方式一：提交的ID判斷條
echo $Mysql->update($data);
//方式二：通過array('name'=>'西西')自定義判斷條件
echo $Mysql->update($data, array('name'=>'西西'));
復制代碼

方法部分mysql.php可以支持ID或自定義判斷
實現步驟：
第一步:測試mysql.php輸出的sql語句格式是否正確

復制代碼 
//數據庫修改操作
    public function update($data)
    {
        //重組SQL語句
        $sql = "UPDATE $this->table SET xxx=xxx,xxx=xxx WHERE xx=xx";
        echo $sql;

    }
復制代碼

調用端1.php測試輸出$sql語句格式
UPDATE `ex_user` SET xxx=xxx,xxx=xxx WHERE xx=xx

第二步：分離數組中的id和其他字段
(1)得到$idWhere

復制代碼 
//數據庫修改操作
    public function update($data)
    {
        //初始化id條件等於空
        $idWhere        =           '';
        
        //先通過array_key_exists這個函數判斷有沒有id這個字段
        //最后分離數組中的id和其他字段
        if (array_key_exists('id', $data)) {
            //$idWhere得到初始化的id條件
            $idWhere = "(`id`='{$data['id']}')";
        }

        //重組SQL語句
        $sql = "UPDATE $this->table SET xxx=xxx,xxx=xxx WHERE $idWhere";
        //輸出當前重組的SQL語句
        echo $sql;
    }
復制代碼

調用端1.php測試輸出$sql語句格式測試輸出$sql語句
UPDATE `ex_user` SET xxx=xxx,xxx=xxx WHERE (`id`='1')

第三步：得到將要修改的$key和$value的值
方式一：通過id條件得到將要修改的$key和$value的值

復制代碼 
 //數據庫修改操作
    public function update($data)
    {
        //初始化id條件
        $idWhere        =           '';

        //修改字符串
        $update         =           '';

        //先分離數組中的id和其他字段
        if (array_key_exists('id', $data)) {
            $idWhere = "(`id`='{$data['id']}')";
        }

        //使用id條件判斷
        $where = $idWhere;

        //得到剔除id索引的數組
        unset($data['id']);

        //將字段數組加上防止沖突的`符號
        foreach ($data as $key=>$value) {
            $update .= "`$key`='$value',";
        }
        
        //去掉最后的逗號
        $update = substr($update, 0, -1);

        //重組SQL語句
        $sql = "UPDATE $this->table SET $update WHERE $where";
        //輸出當前重組的SQL語句
        echo $sql;
    }
復制代碼

調用端1.php查看測試
UPDATE `ex_user` SET `name`='西西',`age`='18' WHERE (`id`='1')

方式二：通過array('name'=>'西西')傳的參數得到將要修改$key和$value的值

復制代碼 
//數據庫修改操作
    public function update($data, $otherWhere = [])
    {
        //初始化id 條件
        $idWhere        =           '';

        //修改字符串
        $update         =           '';

        //先分離數組中的id和其他字段
        if (array_key_exists('id', $data)) {
            $idWhere = "(`id`='{$data['id']}')";
        }

        //如果沒有指定otherWhere，則使用id
        if (empty($otherWhere)) {
            //使用id 條件判斷
            $where = $idWhere;
        } else {
            //使用指定條件判斷
            $key    =   key($otherWhere);
            $value  =   current($otherWhere);
            $where  =   "(`$key`='$value')";
        }

        //得到剔除id 索引的數組
        unset($data['id']);

        //將字段數組加上防止沖突的`符號
        foreach ($data as $key=>$value) {
            $update .= "`$key`='$value',";
        }

        //去掉最后的逗號
        $update = substr($update, 0, -1);
        
        //重組SQL語句
        $sql = "UPDATE $this->table SET $update WHERE $where";
        
        //輸出當前重組SQL語句查看
        echo $sql;
    }
復制代碼

調用端1.php查看測試
UPDATE `ex_user` SET `name`='西西',`age`='18' WHERE (`name`='西西')

最終方法部分mysql.php語句：

復制代碼 
<?php
//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;
    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }

    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }
    
    //數據庫修改操作
    public function update($data, $otherWhere = [])
    {

        //初始化id 條件
        $idWhere        =           '';

        //修改字符串
        $update         =           '';

        //先分離數組中的id 和其他字段
        if (array_key_exists('id', $data)) {
            $idWhere = "(`id`='{$data['id']}')";
        }

        //如果沒有指定otherWhere，則使用id
        if (empty($otherWhere)) {
            //使用id 條件判斷
            $where = $idWhere;
        } else {
            //使用指定條件判斷
            $key    =   key($otherWhere);
            $value  =   current($otherWhere);
            $where  =   "(`$key`='$value')";
        }

        //得到剔除id 索引的數組
        unset($data['id']);

        //將字段數組加上防止沖突的`符號
        foreach ($data as $key=>$value) {
            $update .= "`$key`='$value',";
        }

        //去掉最后的逗號
        $update = substr($update, 0, -1);

        //重組SQL語句
        $sql = "UPDATE $this->table SET $update WHERE $where";

        //得到准備語句
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回影響行數
        return $stmt->rowCount();
    }
}
復制代碼

數據庫功能類-封裝刪除方法

調用端1.php可以直接傳遞ID值或條件判斷的鍵值對數組。

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//刪除數據，默認id 篩選或傳遞指定條件，並返回影響行數
//方式一：通過id條件刪除的$key和$value的值
echo $Mysql->delete(12);
//方式二：指定name=西西的刪除
echo $Mysql->delete(array('name'=>'西西'));
復制代碼

方法端mysql.php刪除的倆種方式
方式一：通過id條件刪除的$key和$value的值

復制代碼 
//數據庫刪除操作
    public function delete($param)
    {
        //使用id 條件判斷
        $where = "(`id`='$param')";

        //重組SQL
        $sql = "DELETE FROM $this->table WHERE $where";

        //得到准備語句
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回影響行數
        return $stmt->rowCount();
    }
復制代碼

方式二：指定name=西西的刪除

復制代碼 
//數據庫刪除操作
    public function delete($param)
    {
        //判斷參數是否是數字ID，還是數組
        if (is_array($param)) {
            //使用指定條件判斷
            $key    =   key($param);
            $value  =   current($param);
            $where  =   "(`$key`='$value')";
        } else {
            //使用id 條件判斷
            $where = "(`id`='$param')";
        }

        //重組SQL
        $sql = "DELETE FROM $this->table WHERE $where";
        
        //得到准備語句
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回影響行數
        return $stmt->rowCount();
    }
復制代碼

最終完整mysql.php語句：

復制代碼 
<?php

//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;


    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }

    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }
    //數據庫刪除操作
    public function delete($param)
    {
        //判斷參數是否是數字ID，還是數組
        if (is_array($param)) {
            //使用指定條件判斷
            $key    =   key($param);
            $value  =   current($param);
            $where  =   "(`$key`='$value')";
        } else {
            //使用id 條件判斷
            $where = "(`id`='$param')";
        }

        //重組SQL
        $sql = "DELETE FROM $this->table WHERE $where";

        //得到准備語句
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回影響行數
        return $stmt->rowCount();
    }
}
復制代碼

封裝數據庫功能類-單查詢和多查詢

一．封裝單一查詢
單一查詢基本上需要where條件判斷，一般默認都是通過ID操作的。

實現步驟：
第一步：測試方法端mysql.php輸出的sql語句格式是否正確：

復制代碼 
//單一查詢方法
    public function find()
    {
        //SQL語句
        $sql = "SELECT id,name,age,create_time FROM $this->table WHERE id=1";
        //打印查詢的語句
        echo $sql;
復制代碼

 調用端1.php增加單一查詢模式：

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//單一查詢模式
$Mysql->find();
復制代碼

調用端執行的1.php測試輸出的sql語句
SELECT id,name,age,create_time FROM `ex_user` WHERE id=1

第二步：方法端mysql.php得到將要查詢的id值($where)

復制代碼 
//單一查詢方法
    public function find($param)
    {
        //得到where條件
        $where = $this->getParam($param);

        //帶$where的SQL語句
        $sql = "SELECT id,name,age,create_time FROM $this->table WHERE $where";
        //打印查詢的語句
        echo $sql;
    }

//重復的ID條件代碼內部調用，包裹成私有化方法
    private function getParam($param)
    {
        //判斷參數是否是數字ID，還是數組
        if (is_array($param)) {
            //使用指定條件判斷
            $key    =   key($param);
            $value  =   current($param);
            $where  =   "(`$key`='$value')";
        } else {
            //使用id條件判斷
            $where = "(`id`='$param')";
        }

        return $where;
    }
復制代碼

 調用端1.php增加ID數1查看是否可以調用成功

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//單一查詢模式
//實現ID=1
$Mysql->find(1);
復制代碼

調用端執行的1.php測試輸出的sql語句

SELECT id,name,age,create_time FROM `ex_user` WHERE (`id`='1')

第三步：方法端得到mysql.php將要查詢的id,name,age,create_time的值($fields)

復制代碼 
///單一查詢方法
    public function find($fields, $param)
    {
        //得到where條件
        $where = $this->getParam($param);

        //得到加上`符號的字段,先轉換成數組
        $fields = $this->getFields($fields);

        //加上$this的SQL語句
        $sql = "SELECT $fields FROM $this->table WHERE id=$where";

        echo $sql;
    }

    //重復的ID條件代碼內部調用，包裹成私有化方法
    private function getParam($param)
    {
        //判斷參數是否是數字ID，還是數組
        if (is_array($param)) {
            //使用指定條件判斷
            $key    =   key($param);
            $value  =   current($param);
            $where  =   "(`$key`='$value')";
        } else {
            //使用id 條件判斷
            $where = "(`id`='$param')";
        }

        return $where;
    }

    //重組fields字段，私有化方法
    private function getFields($fields)
    {
        //給fields 加上`符號
        $fields = explode(',', $fields);

        //將字段數組加上防止沖突的`符號
        foreach ($fields as $key=>$value) {
            $fields[$key] = "`$value`";
        }

        //得到值字符串
        $fields = implode(',', $fields);

        return $fields;
    }
復制代碼

 調用端1.php增加ID數1查看id,name,age,create_time是否可以調用成功

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//實現id,name,age,create_time
$Mysql->find('id,name,age,create_time', 1);
復制代碼

調用端執行的1.php測試輸出的sql語句

SELECT `id`,`name`,`age`,`create_time` FROM `ex_user` WHERE id=(`id`='1')

方法端mysql.php最終通過得到的sql得到准備對象$stmt最終實現單一查詢

復制代碼 
<?php

//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;


    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    //單一查詢方法
    public function find($fields, $param)
    {
        //得到where條件
        $where = $this->getParam($param);

        //得到加上`符號的字段
        $fields = $this->getFields($fields);

        //重組SQL語句，LIMIT 1只顯示一條
        $sql = "SELECT $fields FROM $this->table WHERE $where LIMIT 1";

        //得到准備對象
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回單一數據
        return $stmt->fetchObject();
    }

    //重復的代碼內部調用，私有化方法
    private function getParam($param)
    {

        //判斷參數是否是數字ID，還是數組
        if (is_array($param)) {
            //使用指定條件判斷
            $key    =   key($param);
            $value  =   current($param);
            $where  =   "(`$key`='$value')";
        } else {
            //使用id 條件判斷
            $where = "(`id`='$param')";
        }

        return $where;
    }

    //重組fields字段，私有化方法
    private function getFields($fields)
    {

        //給fields 加上`符號
        $fields = explode(',', $fields);

        //將字段數組加上防止沖突的`符號
        foreach ($fields as $key=>$value) {
            $fields[$key] = "`$value`";
        }

        //得到值字符串
        $fields = implode(',', $fields);

        return $fields;
    }
}
復制代碼

調用端1.php最終實現查詢ID=3的姓名

復制代碼 
<?php

//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//最終實現單一查詢模式
$object = $Mysql->find('id,name,age,create_time', 3);
//輸出姓名
echo $object->name;
復制代碼

二．封裝多查詢
方法端mysql.php多查詢和單查詢基本一樣，這里不用where

復制代碼 
<?php

//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;


    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    //多查詢方法
    public function select($fields)
    {

        //得到加上`符號的字段
        $fields = $this->getFields($fields);

        //重組SQL語句
        $sql = "SELECT $fields FROM $this->table";

        //得到准備對象
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //初始化列表對象
        $objects = [];

        //組裝數據列表
        while ($rows = $stmt->fetchObject()) {
            $objects[] = $rows;
        }

        //返回數據對象數組
        return $objects;

    }
    
    //重組fields字段，私有化方法
    private function getFields($fields)
    {
        //給fields 加上`符號
        $fields = explode(',', $fields);

        //將字段數組加上防止沖突的`符號
        foreach ($fields as $key=>$value) {
            $fields[$key] = "`$value`";
        }

        //得到值字符串
        $fields = implode(',', $fields);

        return $fields;
    }
}
復制代碼

調用端1.php最終實現多查詢

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//多查詢，模式
$objects = $Mysql->select('id,name,age,create_time');

//遍歷
foreach ($objects as $key=>$obj) {
    echo $obj->name.'<br>';
}
復制代碼

數據庫功能類-封裝連綴操作

封裝連綴功能讓where、fields和limit等操作，變得簡單易學。
一．為何要連綴
1.如果封裝越發復雜，參數傳遞就越多，學習成本就越大，讓開發者摸不着頭腦。
2.而連綴模式，可以無限的復雜下去，且不提升學習成本，開發者思路清晰。

二．where連綴
通過where連綴方式刪除：
方法端mysql.php實現代碼

復制代碼 
<?php

//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;
    //第一步：設置條件屬性
    private $where;

    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    //數據庫刪除操作
    public function delete()
    {
        //第三步：重組SQL語句保存where為屬性即可
        $sql = "DELETE FROM $this->table $this->where";

        //得到准備語句
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回影響行數
        return $stmt->rowCount();
    }

    //第二步：設置where條件
    public function where($param)
    {
        //得到第一組key=value
        $key    =   key($param);
        $value  =   current($param);

        //如果沒有第二下標，則默認=
        $sign = empty($param[0]) ? '=' : $param[0];

        //合並成判斷條件，保存到屬性里去
        $this->where = "WHERE (`$key`$sign'$value')";

        //返回當前Mysql對象
        return $this;
    }
}
復制代碼

調用端1.php使用->where()倆種方式刪除。

復制代碼 
?php

//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//第一種調用方式：把條件分離出來，更清晰，把id等於3的刪除掉
$condition['id'] = 3;
$Mysql->where($condition)->delete();

//第二種調用方式：默認=號，可以通過這種使用大於號把id大於三的都刪除掉
$condition = array('id'=>3, '>');
$Mysql->where($condition)->delete();
復制代碼

通過where連綴方式修改：
方法端mysql.php實現代碼

復制代碼 
<?php
//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;
    //第一步：設置條件屬性
    private $where;

    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    //數據庫修改操作
    public function update($data)
    {

        //修改字符串
        $update         =           '';

        //得到剔除id 索引的數組
        unset($data['id']);

        //將字段數組加上防止沖突的`符號
        foreach ($data as $key=>$value) {
            $update .= "`$key`='$value',";
        }

        //去掉最后的逗號
        $update = substr($update, 0, -1);

        //重組SQL語句，保存where為屬性
        $sql = "UPDATE $this->table SET $update $this->where";

        //得到准備語句
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回影響行數
        return $stmt->rowCount();

    }

    //第二步：設置where條件
    public function where($param)
    {
        //使用指定條件判斷
        $key    =   key($param);
        $value  =   current($param);

        //如果沒有第二下標，則默認=
        $sign = empty($param[0]) ? '=' : $param[0];

        //合並成判斷條件，保存到屬性里去
        $this->where = "WHERE (`$key`$sign'$value')";

        //返回當前Mysql對象
        return $this;
    }
}
復制代碼

調用端1.php使用->where()方式修改

復制代碼 
<?php

//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//修改數據
$data = array(
    'name'              =>          '西西',
    'age'               =>          18
);

//修改數據庫，並返回當前影響行數(大於0，說明修改成功)
$condition = array('name'=>'小西西');
echo $Mysql->where($condition)->update($data);
復制代碼

三．fields連綴
通過fields連綴方式實現單一查詢：
方法端mysql.php實現代碼

復制代碼 
mysql.php
<?php
//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;
    //條件屬性
    private $where;
    //第一步：設置字段屬性
    private $fields = '*';

    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    //單一查詢方法
    public function find()
    {
        //重組SQL語句
        $sql = "SELECT $this->fields FROM $this->table $this->where LIMIT 1";


        //得到准備對象
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回單一數據
        return $stmt->fetchObject();
    }

    //所有的where條件都在這里
    public function where($param)
    {
        //使用指定條件判斷
        $key    =   key($param);
        $value  =   current($param);

        //如果沒有第二下標，則默認=
        $sign = empty($param[0]) ? '=' : $param[0];

        //合並成判斷條件，保存到屬性里去
        $this->where = "WHERE (`$key`$sign'$value')";

        //返回當前Mysql對象
        return $this;
    }

    //第二步：設置fields直接復制，並保存屬性,方便調用
    public function fields($fields)
    {

        //給fields 加上`符號
        $fields = explode(',', $fields);

        //將字段數組加上防止沖突的`符號
        foreach ($fields as $key=>$value) {
            $fields[$key] = "`$value`";
        }

        //得到值字符串
        $this->fields = implode(',', $fields);

        //Mysql對象
        return $this;
    }
}
復制代碼

調用端1.php使用fields連綴實現查詢

復制代碼 
<?php

//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//單一查詢，模式
$condition = array('id'=>1);
$object = $Mysql->where($condition)->find();
echo $object->name;;
復制代碼

通過fields連綴方式實現單一查詢：
方法端mysql.php實現代碼

復制代碼 
<?php
//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;
    //條件屬性
    private $where;
    //字段屬性
    private $fields = '*';

    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    ///多查詢方法
    public function select()
    {

        //重組SQL語句
        $sql = "SELECT $this->fields FROM $this->table $this->where";

        //得到准備對象
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //初始化列表對象
        $objects = [];

        //組裝數據列表
        while ($rows = $stmt->fetchObject()) {
            $objects[] = $rows;
        }

        //返回數據對象數組
        return $objects;

    }

    //所有的where條件都在這里
    public function where($param)
    {
        //使用指定條件判斷
        $key    =   key($param);
        $value  =   current($param);

        //如果沒有第二下標，則默認=
        $sign = empty($param[0]) ? '=' : $param[0];

        //合並成判斷條件，保存到屬性里去
        $this->where = "WHERE (`$key`$sign'$value')";

        //返回當前Mysql對象
        return $this;
    }

    //所有的字段設置都在這里
    public function fields($fields)
    {

        //給fields 加上`符號
        $fields = explode(',', $fields);

        //將字段數組加上防止沖突的`符號
        foreach ($fields as $key=>$value) {
            $fields[$key] = "`$value`";
        }

        //得到值字符串
        $this->fields = implode(',', $fields);

        //Mysql對象
        return $this;
    }
}
復制代碼

調用端1.php使用fields連綴實現多查詢

復制代碼 
<?php

//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//多選模式
$objects = $Mysql->fields('id,name')->select();

foreach ($objects as $key=>$obj) {
    echo $obj->name.'<br>';
}
復制代碼

四．Limit連綴
使用limit連綴方式實現多選模式查詢
方法端mysql.php

復制代碼 
mysql.php
<?php
//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;
    //條件屬性
    private $where;
    //字段屬性
    private $fields = '*';
    //limit屬性
    private $limit;

    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    ///多查詢方法
    public function select()
    {

        //重組SQL語句
        $sql = "SELECT $this->fields FROM $this->table $this->where $this->limit";

        //得到准備對象
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //初始化列表對象
        $objects = [];

        //組裝數據列表
        while ($rows = $stmt->fetchObject()) {
            $objects[] = $rows;
        }

        //返回數據對象數組
        return $objects;

    }

    //所有的where條件都在這里
    public function where($param)
    {
        //使用指定條件判斷
        $key    =   key($param);
        $value  =   current($param);

        //如果沒有第二下標，則默認=
        $sign = empty($param[0]) ? '=' : $param[0];

        //合並成判斷條件，保存到屬性里去
        $this->where = "WHERE (`$key`$sign'$value')";

        //返回當前Mysql對象
        return $this;
    }

    //所有的字段設置都在這里
    public function fields($fields)
    {

        //給fields 加上`符號
        $fields = explode(',', $fields);

        //將字段數組加上防止沖突的`符號
        foreach ($fields as $key=>$value) {
            $fields[$key] = "`$value`";
        }

        //得到值字符串
        $this->fields = implode(',', $fields);

        //Mysql對象
        return $this;
    }

    //所有的limit 設置都在這里
    public function limit($start, $end)
    {
        //得到Limit 字符串
        $this->limit = "LIMIT $start, $end";
        //返回當前Mysql 對象
        return $this;
    }
}
復制代碼

調用端1.php使用limit連綴實現多選模式查詢

復制代碼 
<?php

//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//多選模式
$objects = $Mysql->fields('id,name')->limit(0,3)->select();

foreach ($objects as $key=>$obj) {
    echo $obj->id.$obj->name.'<br>';
}
復制代碼

五．order功能
使用order功能實現多選模式查詢排序
方法端mysql.php

復制代碼 
mysql.php
<?php
//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;
    //條件屬性
    private $where;
    //字段屬性
    private $fields = '*';
    //limit屬性
    private $limit;
    //order屬性
    private $order;

    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    ///多查詢方法
    public function select()
    {

        //重組SQL語句
        $sql = "SELECT $this->fields FROM $this->table $this->order $this->where $this->limit";

        //得到准備對象
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //初始化列表對象
        $objects = [];

        //組裝數據列表
        while ($rows = $stmt->fetchObject()) {
            $objects[] = $rows;
        }

        //返回數據對象數組
        return $objects;

    }

    //所有的where條件都在這里
    public function where($param)
    {
        //使用指定條件判斷
        $key    =   key($param);
        $value  =   current($param);

        //如果沒有第二下標，則默認=
        $sign = empty($param[0]) ? '=' : $param[0];

        //合並成判斷條件，保存到屬性里去
        $this->where = "WHERE (`$key`$sign'$value')";

        //返回當前Mysql對象
        return $this;
    }

    //所有的字段設置都在這里
    public function fields($fields)
    {

        //給fields 加上`符號
        $fields = explode(',', $fields);

        //將字段數組加上防止沖突的`符號
        foreach ($fields as $key=>$value) {
            $fields[$key] = "`$value`";
        }

        //得到值字符串
        $this->fields = implode(',', $fields);

        //Mysql對象
        return $this;
    }

    //所有的limit 設置都在這里
    public function limit($start, $end)
    {
        //得到Limit 字符串
        $this->limit = "LIMIT $start, $end";
        //返回當前Mysql 對象
        return $this;
    }

    //所有的order設置都在這里
    public function order($param)
    {

        //分割成數組按空格分割，字符和排序關鍵字
        $order = explode(' ', $param);

        //組裝排序SQL
        $this->order = "ORDER BY `$order[0]` ".strtoupper($order[1]);

        //返回Mysql對象
        return $this;
    }
}
復制代碼

調用端1.php使用order功能實現多選模式查詢排序

復制代碼 
<?php

//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//多選模式
$objects = $Mysql->fields('id,name')->limit(0,3)->order('id desc')->select();

foreach ($objects as $key=>$obj) {
    echo $obj->id.$obj->name.'<br>';
}
復制代碼

六．countr功能
使用count功能查詢總共的條數
方法端mysql.php

復制代碼 
mysql.php
<?php
//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;
    //條件屬性
    private $where;
    //字段屬性
    private $fields = '*';
    //limit屬性
    private $limit;
    //order屬性
    private $order;
    //count屬性
    private $count;

    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host='.$config['DB_HOST'].';dbname='.$config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`'.$table.'`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }
    //內部自我實例化，靜態方法
    public static function mysql($table)
    {
        return new self($table);
    }

    ///多查詢方法
    public function select()
    {

        //重組SQL語句
        $sql = "SELECT $this->fields FROM $this->table $this->order $this->where $this->limit";

        //得到准備對象
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //初始化列表對象
        $objects = [];

        //組裝數據列表
        while ($rows = $stmt->fetchObject()) {
            $objects[] = $rows;
        }

        //將查詢的記錄數保存到count屬性里
        $this->count = $stmt->rowCount();

        //返回數據對象數組
        return $objects;

    }

    //所有的where條件都在這里
    public function where($param)
    {
        //使用指定條件判斷
        $key    =   key($param);
        $value  =   current($param);

        //如果沒有第二下標，則默認=
        $sign = empty($param[0]) ? '=' : $param[0];

        //合並成判斷條件，保存到屬性里去
        $this->where = "WHERE (`$key`$sign'$value')";

        //返回當前Mysql對象
        return $this;
    }

    //所有的字段設置都在這里
    public function fields($fields)
    {

        //給fields 加上`符號
        $fields = explode(',', $fields);

        //將字段數組加上防止沖突的`符號
        foreach ($fields as $key=>$value) {
            $fields[$key] = "`$value`";
        }

        //得到值字符串
        $this->fields = implode(',', $fields);

        //Mysql對象
        return $this;
    }

    //所有的limit 設置都在這里
    public function limit($start, $end)
    {
        //得到Limit 字符串
        $this->limit = "LIMIT $start, $end";
        //返回當前Mysql 對象
        return $this;
    }

    //所有的order設置都在這里
    public function order($param)
    {

        //分割字符和排序關鍵字
        $order = explode(' ', $param);

        //組裝排序SQL
        $this->order = "ORDER BY `$order[0]` ".strtoupper($order[1]);

        //返回Mysql對象
        return $this;
    }

    //返回count
    public function count()
    {
        //返回記錄數
        return $this->count;
    }
}
復制代碼

調用端1.php使用count功能打印查詢的條數

復制代碼 
<?php

//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::mysql('ex_user');

//多選模式
$objects = $Mysql->fields('id,name')->limit(0,3)->order('id desc')->select();

foreach ($objects as $key=>$obj) {
    echo $obj->id.$obj->name.'<br>';
}
//count打印有幾條
echo $Mysql->count();
復制代碼

數據庫功能類-原生方式

1.由於功能的學習成本或是更復雜的無法實現，可以直接提供給開發者原生使用的入口。
方法端mysql.php生成原生方式

復制代碼 
<?php

//數據庫類
class Mysql
{
    //將PDO對象保存至屬性
    private $pdo;
    //將表名保存至屬性
    private $table;
    //條件屬性
    private $where;
    //字段屬性
    private $fields = '*';
    //limit屬性
    private $limit;
    //order屬性
    private $order;
    //count屬性
    private $count;


    //構造方法，自動PDO連接數據庫
    public function __construct($table)
    {
        try {

            //引入配置文件
            $config = require('config.php');

            //連接MySQL數據庫
            $pdo = new PDO('mysql:host=' . $config['DB_HOST'] . ';dbname=' . $config['DB_NAME'], $config['DB_USER'], $config['DB_PASS']);

            //設置UTF8字符編碼
            $pdo->query('SET NAMES UTF8');

            //保存PDO對象為屬性
            $this->pdo = $pdo;

            //保存數據表名
            $this->table = '`' . $table . '`';

        } catch (PDOException $e) {
            //輸出錯誤信息
            echo $e->getMessage();
        }
    }

    //內部自我實例化，靜態方法
    public static function getMysql($table = '')
    {
        return new self($table);
    }

    //原生執行SQL 語句，返回准備對象
    public function query($sql)
    {
        //得到准備語句
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回准備對象
        return $stmt;
    }

    //還可以返回PDO 對象，用於原生時的一些操作
    public function getPdo()
    {
        //返回PDO對象
        return $this->pdo;
    }

    //數據庫新增操作
    public function add($data)
    {
        //得到字段數組
        $keys = array_keys($data);

        //將字段數組加上防止沖突的`符號
        foreach ($keys as $key => $value) {
            $keys[$key] = '`' . $value . '`';
        }

        //得到字段字符串
        $fields = implode(',', $keys);

        //給值字符串加上單引號
        foreach ($data as $key => $value) {
            $data[$key] = "'" . $value . "'";
        }

        //得到值字符串
        $values = implode(',', $data);


        //重組SQL語句
        $sql = "INSERT INTO $this->table ($fields) VALUES ($values)";


        //執行SQL語句
        $this->pdo->prepare($sql)->execute();

        //返回最新的ID值
        return $this->pdo->lastInsertId();
    }

    //數據庫修改操作
    public function update($data)
    {

        //修改字符串
        $update = '';

        //得到剔除id 索引的數組
        unset($data['id']);

        //將字段數組加上防止沖突的`符號
        foreach ($data as $key => $value) {
            $update .= "`$key`='$value',";
        }

        //去掉最后的逗號
        $update = substr($update, 0, -1);

        //重組SQL語句
        $sql = "UPDATE $this->table SET $update $this->where";

        echo $sql;

        //得到准備語句
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回影響行數
        return $stmt->rowCount();

    }

    //數據庫刪除操作
    public function delete()
    {
        //重組SQL
        $sql = "DELETE FROM $this->table $this->where";

        //得到准備語句
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回影響行數
        return $stmt->rowCount();
    }


    //單一查詢方法
    public function find()
    {

        //重組SQL語句
        $sql = "SELECT $this->fields FROM $this->table $this->where LIMIT 1";

        //得到准備對象
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //返回單一數據
        return $stmt->fetchObject();

    }

    //多查詢方法
    public function select()
    {

        //重組SQL語句
        $sql = "SELECT $this->fields FROM $this->table $this->order $this->where $this->limit";

        //得到准備對象
        $stmt = $this->pdo->prepare($sql);

        //執行SQL語句
        $stmt->execute();

        //初始化列表對象
        $objects = [];

        //組裝數據列表
        while ($rows = $stmt->fetchObject()) {
            $objects[] = $rows;
        }

        //將查詢的記錄數保存到count屬性里
        $this->count = $stmt->rowCount();

        //返回數據對象數組
        return $objects;

    }

    //所有的where 條件都在這里
    public function where($param)
    {

        //使用指定條件判斷
        $key = key($param);
        $value = current($param);

        //如果沒有第二下標，則默認=
        $sign = empty($param[0]) ? '=' : $param[0];

        //合並成判斷條件，保存到屬性里去
        $this->where = "WHERE (`$key`$sign'$value')";

        //返回當前Mysql對象
        return $this;
    }

    //所有的字段設置都在這里
    public function fields($fields)
    {

        //給fields 加上`符號
        $fields = explode(',', $fields);

        //將字段數組加上防止沖突的`符號
        foreach ($fields as $key => $value) {
            $fields[$key] = "`$value`";
        }

        //得到值字符串
        $this->fields = implode(',', $fields);

        //Mysql對象
        return $this;
    }

    //所有的limit 設置都在這里
    public function limit($start, $end)
    {
        //得到Limit 字符串
        $this->limit = "LIMIT $start, $end";
        //返回當前Mysql 對象
        return $this;
    }

    //所有的order設置都在這里
    public function order($param)
    {

        //分割字符和排序關鍵字
        $order = explode(' ', $param);

        //組裝排序SQL
        $this->order = "ORDER BY `$order[0]` ".strtoupper($order[1]);

        //返回Mysql對象
        return $this;
    }

    //返回count
    public function count()
    {
        //返回記錄數
        return $this->count;
    }
}
復制代碼

調用端2.php通過原生方式實現增刪改查

復制代碼 
<?php
//引入數據庫類
require 'mysql.php';

//實例化並創建對象
$Mysql = Mysql::getMysql();

//原生刪除
$stmt = $Mysql->query('DELETE FROM ex_user WHERE id=2');
echo $stmt->rowCount();

//原生修改
$stmt = $Mysql->query("UPDATE ex_user SET name='西西' WHERE id=1");
echo $stmt->rowCount();

//原生新增
$stmt = $Mysql->query("INSERT INTO ex_user (name,age,create_time) VALUES ('小西西', 17, NOW())");
echo $stmt->rowCount();
echo $Mysql->getPdo()->lastInsertId();

//原生查詢
$stmt = $Mysql->query("SELECT id,name,age FROM ex_user");
print_r($stmt->fetchObject());
復制代碼


免責聲明！

本站轉載的文章為個人學習借鑒使用，本站對版權不負任何法律責任。如果侵犯了您的隱私權益，請聯系本站郵箱yoyou2525@163.com刪除。



猜您在找 php數據庫功能類-mysql類 完整的PHP MYSQL數據庫類 php開發_鏈接mysql數據庫的一個類 一個通用的PHP連接MYSQL數據庫類 PHP數據庫基於PDO操作類（mysql） PHP 基於pdo的數據庫操作類 PHP 數據庫操作類：ezSQL Python連接MYSQL數據庫類 MySql數據庫操作類---MySqlHelper MySql數據庫幫助類：DbHelperMySQL
 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM