php mysql类_php数据库功能类-mysql类

配置文件和Mysql类

一．创建Mysql类

1.本身我们将使用PDO来操控数据库，而不管哪种数据库引擎，直接操作都比较松散，所以我们有必要做适当的封装(封装过度也会导致学习成本过高，适当就好)。

2.创建一个方法端mysql.php的类。

//MySQL数据库类

class Mysql

{

}

3.创建对外的调用端1.php引入方法端数据库mysql.php

//引入数据库类

require 'mysql.php';

$Mysql = new Mysql();

4.创建类中的构造方法，构造方法里通过PDO来连接数据库。

方法端mysql.php类：

//构造方法，自动连接PDO

//数据库类

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()数组方式配置信息。

//返回配置文件数组

return array(

//数据库配置

'DB_HOST' => 'localhost', //服务器地址

'DB_NAME' => 'example', //数据库名

'DB_USER' => 'xixi', //用户名

'DB_PASS' => '123456' //密码

);

3.将配置信息config.php引入到Mysql.class.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的内部通过静态方法进行实例化，外部直接调用这个方法，即完成了实例化的过程。

//数据库类

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类。

//引入数据库类

require 'mysql.php';

//实例化并创建对象

$Mysql = Mysql::stmt();

//调用

$Mysql->test();

调用端1.php查看测试

test

数据库功能类-封装新增方法

通过一个简单的传递参数，即可智能实现数据新增。

一．调用猜想

1.如果使用过一些框架，它们就把增删改查进行了有效的封装。

2.通过实例化，将调用端1.php和方法端mysql.php关联的数据表关联上。

//引入数据库类

require 'mysql.php';

//实例化并创建对象

$Mysql = Mysql::mysql();

打印出$Mysql这个对象测试

var_dump($Mysql);

调用端1.php查看测试

object(Mysql)[1]

3.字段和值，通过数组传递。

给对外的调用端1.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

//数据库类

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)";

}

最后整理最终代码：:

//数据库类

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判断条件或自定义判断条件

//引入数据库类

require 'mysql.php';

//实例化并创建对象

$Mysql = Mysql::mysql('ex_user');

//可以直接通过提交的ID判断条件或自定义判断条件。修改数据id筛选传递

//引入数据库类

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语句：

//数据库类

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值或条件判断的键值对数组。

//引入数据库类

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语句：

//数据库类

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增加单一查询模式：

//引入数据库类

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查看是否可以调用成功

//引入数据库类

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是否可以调用成功

//引入数据库类

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最终实现单一查询

//数据库类

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的姓名

//引入数据库类

require 'mysql.php';

//实例化并创建对象

$Mysql = Mysql::mysql('ex_user');

//最终实现单一查询模式

$object = $Mysql->find('id,name,age,create_time', 3);

//输出姓名

echo $object->name;

二．封装多查询

方法端mysql.php多查询和单查询基本一样，这里不用where

//数据库类

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最终实现多查询

//引入数据库类

require 'mysql.php';

//实例化并创建对象

$Mysql = Mysql::mysql('ex_user');

//多查询，模式

$objects = $Mysql->select('id,name,age,create_time');

//遍历

foreach ($objects as $key=>$obj) {

echo $obj->name.'
';

}

数据库功能类-封装连缀操作

封装连缀功能让where、fields和limit等操作，变得简单易学。

一．为何要连缀

1.如果封装越发复杂，参数传递就越多，学习成本就越大，让开发者摸不着头脑。

2.而连缀模式，可以无限的复杂下去，且不提升学习成本，开发者思路清晰。

二．where连缀

通过where连缀方式删除：

方法端mysql.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实现代码

//数据库类

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()方式修改

//引入数据库类

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

//数据库类

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连缀实现查询

//引入数据库类

require 'mysql.php';

//实例化并创建对象

$Mysql = Mysql::mysql('ex_user');

//单一查询，模式

$condition = array('id'=>1);

$object = $Mysql->where($condition)->find();

echo $object->name;;

通过fields连缀方式实现单一查询：

方法端mysql.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连缀实现多查询

//引入数据库类

require 'mysql.php';

//实例化并创建对象

$Mysql = Mysql::mysql('ex_user');

//多选模式

$objects = $Mysql->fields('id,name')->select();

foreach ($objects as $key=>$obj) {

echo $obj->name.'
';

}

四．Limit连缀

使用limit连缀方式实现多选模式查询

方法端mysql.php

mysql.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连缀实现多选模式查询

//引入数据库类

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.'
';

}

五．order功能

使用order功能实现多选模式查询排序

方法端mysql.php

mysql.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功能实现多选模式查询排序

//引入数据库类

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.'
';

}

六．countr功能

使用count功能查询总共的条数

方法端mysql.php

mysql.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功能打印查询的条数

//引入数据库类

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.'
';

}

//count打印有几条

echo $Mysql->count();

数据库功能类-原生方式

1.由于功能的学习成本或是更复杂的无法实现，可以直接提供给开发者原生使用的入口。

方法端mysql.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通过原生方式实现增删改查

//引入数据库类

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());