mysql php类_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 functionstmt()

{//返回出一个对象

return newself();

}public functiontest()

{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 functionfind()

{//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 functiondelete()

{//第三步：重组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<?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 functionfind()

{//重组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 functionselect()

{//重组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<?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 functionselect()

{//重组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<?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 functionselect()

{//重组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<?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 functionselect()

{//重组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 functiongetPdo()

{//返回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 functiondelete()

{//重组SQL

$sql = "DELETE FROM $this->table $this->where";//得到准备语句

$stmt = $this->pdo->prepare($sql);//执行SQL语句

$stmt->execute();//返回影响行数

return $stmt->rowCount();

}//单一查询方法

public functionfind()

{//重组SQL语句

$sql = "SELECT $this->fields FROM $this->table $this->where LIMIT 1";//得到准备对象

$stmt = $this->pdo->prepare($sql);//执行SQL语句

$stmt->execute();//返回单一数据

return $stmt->fetchObject();

}//多查询方法

public functionselect()

{//重组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());

~