码上快乐

相关内容   简体   繁体

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