MVC 简介

MVC 是一个编程思想，将一个项目的很多文件进行功能上的分组。

优点

1. 编程的模块化更加明确
2. 后期的升级，维护很方便
3. 后期添加功能非常方便
4. 可以将代码的可重用性发挥到极致。

MVC 组成和作用

M（Model）模型，用来操作数据

V（View）视图，展示的页面，一般都是 html 页面

C（Controller）控制器，接受用户的请求并且根据请求的需要调用视图和模型

MVC 演化一

将上一讲的封装的 MyPDO 类拷贝到站点下，文件名改名为 “index.php”

显示 Products 表的所有数据

<?php

class MyPDO{

private $type; // 数据库类型

private $host; // 主机地址

private $port; // 端口号

private $dbname; // 数据库名

private $charset; // 字符编码

private $user; // 用户名

private $pwd; // 密码

private $pdo; //PDO 对象

private static $instance; // 私有的静态属性保存 MyPDO 的单例

private function __construct($config) { // 私有的构造函数阻止在类的外部实例化对象

$this->initParam($config);

$this->initPDO();

$this->initException();

}

private function __clone(){ // 私有的__clone() 阻止在类的外部 clone 对象

}

public static function getInstance($config=array()){ // 公有的静态方法获取 MyPDO 的单例

if(!self::$instance instanceof self)

self::$instance=new self($config);

return self::$instance;

}

/*

* 初始化成员变量

* @param $config array 配置数组

*/

private function initParam($config){

$this->type=isset($config[‘type’])?$config[‘type’]:’mysql’;

$this->host=isset($config[‘host’])?$config[‘host’]:’127.0.0.1′;

$this->port=isset($config[‘port’])?$config[‘port’]:’3306′;

$this->dbname=isset($config[‘dbname’])?$config[‘dbname’]:”;

$this->charset=isset($config[‘charset’])?$config[‘charset’]:’utf8′;

$this->user=isset($config[‘user’])?$config[‘user’]:”;

$this->pwd=isset($config[‘pwd’])?$config[‘pwd’]:”;

}

/*

* 实例化 pdo

*/

private function initPDO(){

try{

$dsn=”{$this->type}:host={$this->host};port={$this->port};dbname={$this->dbname};charset={$this->charset}”;

$this->pdo=new PDO($dsn, $this->user, $this->pwd);

} catch (Exception $e) {

$this->showException($e);

}

}

/*

* 设置自动抛出异常

*/

private function initException(){

$this->pdo->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);

}

/*

* 显示异常信息

* @param $e object 错误对象

* @parram $sql string 错误的 SQL 语句

*/

private function showException($e,$sql=”){

if($sql!=”)

echo “SQL 语句执行失败 <br> 错误的 SQL 语句是：{$sql}<br>”;

echo ‘错误信息：’.$e->getMessage(),'<br>’;

echo ‘错误编号：’.$e->getCode(),'<br>’;

echo ‘错误文件：’.$e->getFile(),'<br>’;

echo ‘错误行号：’.$e->getLine(),'<br>’;

exit;

}

/*

* 执行数据操作语句

* @return 成功返回受影响的记录数，失败返回 false

*/

public function exec($sql){

try

{

return $this->pdo->exec($sql);

}catch(PDOException $e){

$this->showException($e, $sql);

}

}

/*

* 返回插入数据的自动增长的编号

*/

public function lastInsertId(){

return $this->pdo->lastInsertId();

}

/*

* 获取 PDOStatement 对象

* @param $sql string SQL 语句

* @return PDOStatement 对象

*/

private function getPDOStatement($sql){

try

{

return $this->pdo->query($sql);

} catch (Exception $e) {

$this->showException($e);

}

}

/*

* 判断匹配类型

* @param $type string 用户需要的类型

* @return 常量

*/

private function getFetchType($type){

$allow=array(‘num’,’assoc’,’both’);

if(!in_array($type, $allow))

$type=’assoc’;

switch($type){

case ‘num’:

return PDO::FETCH_NUM;

case ‘assoc’:

return PDO::FETCH_ASSOC;

case ‘both’:

return PDO::FETCH_BOTH;

}

}

/*

* 获取一条记录

* @param $sql string SQL 语句

* @param $type string 匹配类型 num,assoc,both

* @return array 一维数组

*/

public function fetchRow($sql,$type=”){

$stmt= $this->getPDOStatement($sql);

$fetch_const= $this->getFetchType($type);

return $stmt->fetch($fetch_const);

}

/*

* 匹配所有数据

* @return array 二维数组

*/

public function fetchAll($sql,$type=”){

$stmt= $this->getPDOStatement($sql);

$fetch_const= $this->getFetchType($type);

return $stmt->fetchAll($fetch_const);

}

/*

* 获取遗憾一列的数据

*/

public function fetchColumn($sql){

try{

$stmt= $this->getPDOStatement($sql);

return $stmt->fetchColumn();

} catch (Exception $e) {

$this->showException($e);

}

}

}

?>

<!doctype html>

<html>

<head>

<meta charset=”utf-8″>

<title> 无标题文档 </title>

<style type=”text/css”>

table{

width:780px;

border:solid #000 1px;

margin:auto;

}

td,th{

border:solid #000 1px;

}

</style>

</head>

<body>

<?php

$config=array(

‘dbname’ => ‘data’,

‘user’ => ‘root’,

‘pwd’ => ‘root’

);

$mypdo= MyPDO::getInstance($config);

$list=$mypdo->fetchAll(‘select * from products’);

?>

<table>

<tr>

<th> 编号 </th>

<th> 商品名称 </th>

<th> 规格 </th>

<th> 价格 </th>

<th> 库存量 </th>

</tr>

<?php foreach($list as $rows):?>

<tr>

<td><?php echo $rows[‘proID’]?></td>

<td><?php echo $rows[‘proname’]?></td>

<td><?php echo $rows[‘proguige’]?></td>

<td><?php echo $rows[‘proprice’]?></td>

<td><?php echo $rows[‘proamount’]?></td>

</tr>

<?php endforeach;?>

</table>

</body>

</html>

运行结果

MVC 演化二

演化一中，所有的业务逻辑都在同一个页面上，没有将功能分组。

优化方案：

1. 将 MyPDO 类单独保存一个文件（MyPDO.class.php）
2. 将页面显示保存到视图中（products_list.html）
3. 在 index.php 中自动加载类

代码实现

1. 在站点下创建 MyPDO.class.php 页面，将 MyPDO 类拷贝到此页面中
2. 在站点下创建 products_list.html 页面，将视图代码拷贝到此页面中

<!doctype html>

<html>

<head>

<meta charset=”utf-8″>

<title> 无标题文档 </title>

<style type=”text/css”>

table{

width:780px;

border:solid #000 1px;

margin:auto;

}

td,th{

border:solid #000 1px;

}

</style>

</head>

<body>

<table>

<tr>

<th> 编号 </th>

<th> 商品名称 </th>

<th> 规格 </th>

<th> 价格 </th>

<th> 库存量 </th>

</tr>

<?php foreach($list as $rows):?>

<tr>

<td><?php echo $rows[‘proID’]?></td>

<td><?php echo $rows[‘proname’]?></td>

<td><?php echo $rows[‘proguige’]?></td>

<td><?php echo $rows[‘proprice’]?></td>

<td><?php echo $rows[‘proamount’]?></td>

</tr>

<?php endforeach;?>

</table>

</body>

</html>

1. index.php 页面代码如下：

<?php

// 自动加载类

function __autoload($class_name) {

require “./{$class_name}.class.php”;

}

// 连接数据库

$config=array(

‘dbname’ => ‘data’,

‘user’ => ‘root’,

‘pwd’ => ‘root’

);

$mypdo= MyPDO::getInstance($config);

$list=$mypdo->fetchAll(‘select * from products’);

// 调用视图

require ‘./products_list.html’;

演化二完毕后， 站点中有三个文件

MVC 演化三

在演化二中，index.php 页面（充当的是控制器）有连接数据库并获取数据的代码，这些代码应该放到模型中

优化方案：
1、一个表对应一个模型，模型名和表名同名

2、模型名以 Model 结尾，比如 User 表对应的模型：UserModel

3、文件名与类名同名

4、类文件以. class.php 结尾

代码实现：

1. 在站点中创建 ProductsModel.class.php 页面

<?php

/**

*Products 表的模型，用来对 Products 表进行操作

*/

class ProductsModel {

// 获取 products 表的所有数据

public function getList() {

$config=array(

‘dbname’ => ‘data’,

‘user’ => ‘root’,

‘pwd’ => ‘root’

);

$mypdo= MyPDO::getInstance($config);

return $mypdo->fetchAll(‘select * from products’);

}

}

1. index.php 页面中代码更改如下

<?php

// 自动加载类

function __autoload($class_name) {

require “./{$class_name}.class.php”;

}

// 调用模型

$model=new ProductsModel();

$list=$model->getList();

// 调用视图

require ‘./products_list.html’;

演化三结束，文件结构如下

MVC 演化四

在演化三中，如果有多个表模型，那么获取 mypdo 对象的代码需要写多次。这个是代码冗余

解决方法：

将模型的公共代码封装到基础模型中，所有的表模型都继承基础模型

代码实现

1. 在站点下创建基础模型类（Model.class.php）

<?php

// 基础模型类

class Model {

protected $mypdo; // 保存 mypdo 对象

public function __construct() {

$this->initMyPDO();

}

// 初始化 mypdo 对象

private function initMyPDO() {

$config=array(

‘dbname’ => ‘data’,

‘user’ => ‘root’,

‘pwd’ => ‘root’

);

$this->mypdo= MyPDO::getInstance($config);

}

}

1. 更改 ProductsModel.class.php

class ProductsModel extends Model {

// 获取 products 表的所有数据

public function getList() {

return $this->mypdo->fetchAll(‘select * from products’);

}

}

演化四完毕后，结构如下：

MVC 演化五

在演化四中，只能请求一个功能，因为控制器放在 index.php 中，项目中功能很多，如何实现多个功能？

1. 一个模块对应一个控制器，比如商品模块，新闻模块
2. 控制器以 Controller 结尾
3. 控制器中方法名以 Action 结尾

访问控制器

通过传递不同的参数来访问不同的方法

c 表示控制器名 a 表示方法名

代码实现

1. 在站点下创建 ProductsController.class.php 页面（Products 控制器）

<?php

/**

* 商品控制器

*/

class ProductsController {

// 显示商品

public function listAction() {

// 调用模型

$model=new ProductsModel();

$list=$model->getList();

// 调用视图

require ‘./products_list.html’;

}

}

1. 更改 index.php 页面

<?php

// 自动加载类

function __autoload($class_name) {

require “./{$class_name}.class.php”;

}

// 确定路由

$c=isset($_GET[‘c’])?$_GET[‘c’]:’Products’; // 获取控制器名

$a=isset($_GET[‘a’])?$_GET[‘a’]:’list’; // 获取方法名

$c=ucfirst(strtolower($c)); // 首字母大写

$a=strtolower($a); // 全部小写

$controller_name=$c.’Controller’; // 拼接控制器类名

$action_name=$a.’Action’; // 拼接方法名

// 请求分发

$controller=new $controller_name();

$controller->$action_name();

Index.php 的作用：确定路由和请求分发

通过传递参数确定路由

删除商品

每实现一个功能，将对应的代码放到对应 MVC 中

视图（products_list.html）

运行结果

控制器（ProductsController）

模型（ProductsModel）

运行成功

回顾

1. MVC 是一种编程思想，通过 MVC 思想来组织项目中的代码
2. MVC 由 M（模型），V（视图），C（控制器）组成
3. 模型用来操作数据
4. 视图用来显示数据的
5. 控制器用来接收请求，并根据需求调用模型和视图
6. 通过 c 和 a 参数确定路由，c 参数表示控制器，a 参数表示方法

框架搭建

问题

在上一讲 MVC 中，所有的文件都存放在站点下，不便于管理，我们需要将所有的文件分类存放。

创建框架目录

所有的代码分成两部分，一个部分代码是与具体的业务没有直接关系，用来支撑项目的运行，这部分称为框架代码（Framework），另一部分与具体项目相关，称为项目代码（Application）。

将上一讲的文件放到对应的目录中

将所有的类文件添加上命名空间

通过文件的地址做命名空间

创建 Framework.class.php 文件

在 Core 文件夹下创建 Framework.class.php 页面

定义路径常量

思路：将所有文件放到对应目录后，我们就围绕如何加载类去写代码。

思路：由于加载类需要路径，首先我们定义路径才常量

获取文件的绝对路径

获取目录分隔符

代码如下：

namespace Core;

class Framework{

// 定义路径常量

private static function initConst(){

define(‘DS’, DIRECTORY_SEPARATOR); // 定义目录分隔符

define(‘ROOT_PATH’, getcwd().DS); // 定义根目录路径

// 定义一级目录

define(‘APP_PATH’, ROOT_PATH.’Application’.DS); // 定义 Application 目录的路径

define(‘FRAMEWROK_PATH’, ROOT_PATH.’Framework’.DS);

// 定义二级目录

define(‘CONFIG_PATH’, APP_PATH.’Config’.DS);

define(‘CONTROLLER_PATH’, APP_PATH.’Controller’.DS);

define(‘MODEL_PATH’, APP_PATH.’Model’.DS);

define(‘VIEW_PATH’, APP_PATH.’View’.DS);

define(‘CORE_PATH’, FRAMEWROK_PATH.’Core’.DS);

define(‘LIB_PATH’, FRAMEWROK_PATH.’Lib’.DS);

}

}

加载配置文件

1. 在 config 文件夹创建 config.php 页面

1. 代码如下

<?php

return array(

// 数据库配置

‘database’ =>array(

‘dbname’ => ‘data’,

‘user’ => ‘root’,

‘pwd’ => ‘root’

),

// 应用程序配置

‘app’ => array(

‘default_platform’ => ‘Admin’,

‘default_controller’ => ‘Products’,

‘default_action’ => ‘list’

)

);

1. 在 Framework 类中加载配置文件

private static function initConfig(){

$GLOBALS[‘config’]=require CONFIG_PATH.’config.php’;

}

确定路由

通过传递参数的方法确定路由

p: 平台

c：控制器

a：方法

在 URL 地址中访问

代码如下：

private static function initRoutes(){

$p=isset($_REQUEST[‘p’])?$_REQUEST[‘p’]:$GLOBALS[‘config’][‘app’][‘default_platform’];

$c=isset($_REQUEST[‘c’])?$_REQUEST[‘c’]:$GLOBALS[‘config’][‘app’][‘default_controller’];

$a=isset($_REQUEST[‘a’])?$_REQUEST[‘a’]:$GLOBALS[‘config’][‘app’][‘default_action’];

$p=ucfirst(strtolower($p)); // 首字母大写

$c=ucfirst(strtolower($c)); // 首字母大写

$a=strtolower($a); // 全部小写

define(‘PLATFORM_NAME’, $p); // 定义平台名称常量

define(‘CONTROLLER_NAME’, $c); // 定义控制器名称常量

define(‘ACTION_NAME’, $a); // 定义方法名称常量

define(‘__URL__’, CONTROLLER_PATH.$p.DS); // 当前请求的控制器的路径

define(‘__VIEW__’, VIEW_PATH.$p.DS); // 当前请求视图的路径

}

自动加载类

/*

* 加载类的方法

* @param $class_name string 需要加载的类

*/

private static function loadClass($class_name) {

$namespace= dirname($class_name); // 获取命名空间

$class_name= basename($class_name); // 类名

if(in_array($namespace,array(‘Core’,’Lib’)))

$path=FRAMEWROK_PATH.$namespace.DS.$class_name.’.class.php’;

elseif($namespace==’Model’)

$path=MODEL_PATH.$class_name.’.class.php’;

else

$path=__URL__.$class_name.’.class.php’;

// 如果文件存在就加载

if(isset($path) && file_exists($path))

require $path;

}

注册加载类

加载类的方法写到类中不会自动执行，需要将加载类的方法注册到__autoload() 栈中

private static function initRegisterLoadClass(){

spl_autoload_register(‘self::loadClass’);

}

请求分发

private static function initDispatch(){

、$controller_name=’\Controller\\’.PLATFORM_NAME.’\\’.CONTROLLER_NAME.’Controller’; // 拼接控制器类名

$action_name=ACTION_NAME.’Action’; // 拼接方法名

// 请求分发

$controller=new $controller_name();

$controller->$action_name();

}

封装 run() 方法

public static function run(){

self::initConst();

self::initConfig();

self::initRoutes();

self::initRegisterLoadClass();

self::initDispatch();

}

在 index.php 页面执行 run() 方法

执行 run() 方法就会启动框架

注意：现在的 index.php 页面只起接受请求的作用，接受请求后就会启动框架，index.php 称为 “入口文件”

由于在每次请求的都是入口文件，所以在框架中 “.” 表示入门文件所在的目录。

项目中需要更改代码的地方

测试，成功

总结：框架搭建的步骤

1. 创建框架文件夹
2. 将项目文件放到对应的文件夹中
3. 在原来的类文件上添加命名空间
4. 定义了路径常量
5. 确定路由
6. 加载类的方法
7. 注册自动加载类
8. 请求分发
9. 引入配置文件
10. 调试

完善删除功能

删除记录后，显示一个消息页面，n 秒以后跳转到指定的地址上。

所有控制器都会用到跳转功能，所以将跳转的方法写到基础控制器中

步骤

1. 在 Core 文件夹中创建 Controller.class.php

<?php

/*

* 基础控制器

*/

namespace Core;

abstract class Controller{

// 封装 jump 方法, 正确跳转

protected function success($url,$info=”,$time=1){

$this->jump($url, $info, $time, true);

}

// 封装 jump() 方法，错误跳转

protected function error($url,$info=”,$time=3){

$this->jump($url, $info, $time, false);

}

/*

* 跳转的方法

* @param $url string 跳转的 URL 地址

* @param $info string 显示的信息

* @param $time int 页面停留时间

* @param $success bool 显示正确或错误的图标

*/

private function jump($url,$info=”,$time=3,$success=true){

if($info==”)

header (“location:{$url}”);

else{

$img=’true.fw.png’;

$class=’success’;

if(!$success){

$img=’error.fw.png’;

$class=’error’;

}

echo <<<str

<!doctype html>

<html>

<head>

<meta charset=”utf-8″>

<meta http-equiv=”refresh” content=”{$time};url={$url}”>

<title> 无标题文档 </title>

<style type=”text/css”>

body{

text-align:center;

padding-top:100px;

font-size:24px;

}

.success{

color:#090;

}

.error{

color:#F00;

}

</style>

</head>

<body>

<img src=”/Public/images/{$img}”>

<h2 class=”{$class}”>{$info}</h2>

{$time} 秒以后跳转

</body>

</html>

str;

}

}

}

1. 所有的控制器都继承基础控制器

1. 在控制器中调用 success() 和 error()

PDO 简介

PDO（PHP Data Object）PHP 数据对象，可以对各种数据库进行操作。PHP 默认情况下不支持 PDO 扩展，需要在 php.ini 中开启 PDO 扩展

PDO 扩展为 PHP 访问数据库定义了一个轻量级，一致性的接口，无论访问什么数据库都可以通过这个一致性的接口进行操作。

PDO 可以连接的数据库种类

PDO 的核心类

PDO 类：表示 PHP 和数据库之间的一个连接

PDOStatement 类

第一：表示执行 SQL 语句后的相关结果

第二：表示一条预处理语句

PDOException 类：表示 PDO 的异常类

在帮助文档中位置如下：

实例化 PDO 对象

开启 PDO 扩展

语法

构造函数：__construct(dsn, 用户名, 密码)

dsn

data source name 数据源对象

数据库类型: host = 主机地址; port = 端口号; dbname = 数据库名; charset = 字符集

例题

脚下留心：

有默认值的参数都可以省略，没有写数据库表示连接上但是没有选择数据库。

数据库类型只能小写

使用 PDO 对象

PDO->exec()：执行数据操作语句，成功返回受影响的记录数，失败返回 false。

PDO->query()：执行数据查询语句，返回 PDOStatement 对象

PDO->lastInsertId()：返回插入的最后一条记录的 id 编号

PDO-> errorCode()：返回执行 SQL 语句错误的编码

PDO-> errorInfo()：返回错误信息数组

PDO->beginTransaction()：开启事务

PDO->commit()：提交事务

PDO->rollback()：回滚事务

例题：PDO->exec()

创建 stu 数据表

create table stu(

id int unsigned auto_increment primary key comment ‘学号’,

name varchar(20) not null comment ‘姓名’,

score tinyint unsigned comment ‘成绩’

)

执行数据操作语句

$dsn=’mysql:host=localhost;dbname=data;port=3306;charset=utf8′;

$pdo=new PDO($dsn,’root’,’root’); // 实例化 pdo 对象

//$sql=”insert into stu values (5,’tom’,88)”;

$sql=”update stu set name=’tony’where id=5″;

if($result=$pdo->exec($sql)){ // 成功返回受影响的记录数，失败返回 false

echo ‘SQL 语句执行成功 <br>’;

echo ‘受影响的记录数：’.$result,'<Br>’;

echo ‘最后的 id 编号是：’.$pdo->lastInsertId(),'<br>’;

}

elseif($result===0){

echo ‘没有数据变化 <br>’;

}

elseif($result===false){

echo ‘SQL 执行失败，语句有误 <br>’;

echo ‘错误编号：’.$pdo->errorCode(),'<br>’;

$error=$pdo->errorInfo(); // 获取错误信息

//var_dump($error);

echo ‘错误信息：’.$error[2];

}

例题：事务

事务是一个整体，要么一起执行，要么一起不执行。

回顾数据库中事务

开启事务： start transaction 或者 begin work 或 begin

提交事务：commit

回滚事务：rollback

— 创建数据表

drop table if exists bank;

create table bank(

cardid char(4) primary key comment ‘卡号’,

name varchar(10) not null comment ‘姓名’,

balance decimal(10,2) not null comment ‘余额’

)engine=innodb charset=utf8 comment ‘银行表’;

— 插入测试数据

insert into bank values (‘1001′,’tom’,1000),(‘1002′,’berry’,1)

— 使用事务

mysql> begin //

mysql> update bank set balance=balance-100 where cardid=’1001′;

-> update bank set balance=balance+100 where cardid=’1002’//

mysql> select * from bank //

+——–+——-+———+

| cardid | name | balance |

+——–+——-+———+

| 1001 | tom | 900.00 |

| 1002 | berry | 101.00 |

+——–+——-+———+

2 rows in set (0.00 sec)

mysql> rollback //

Query OK, 0 rows affected (0.00 sec)

mysql> select * from bank //

+——–+——-+———+

| cardid | name | balance |

+——–+——-+———+

| 1001 | tom | 1000.00 |

| 1002 | berry | 1.00 |

+——–+——-+———+

2 rows in set (0.00 sec)

例题：使用 PDO 操作事务

<?php

$dsn=’mysql:dbname=data’;

$pdo=new PDO($dsn,’root’,’root’);

$pdo->beginTransaction(); // 开启事务

$rs1=$pdo->exec(“update bank set balance=balance-100 where cardid=’1001′”);

$rs2=$pdo->exec(“update bank set balance=balance+100 where cardid=’1002′”);

if($rs1>0 && $rs2>0)

$pdo->commit (); // 提交事务

else

$pdo->rollBack (); // 回滚事务

例题：PDO->query()

使用 PDOStatement 对象

$stmt->fetch()：将对象中的一条数据匹配成关联和索引数组

$stmt->fetchAll()：将对象中的所有数据匹配成二维数组

$stmt->fetchColumn()：匹配列

$stmt->rowCount()：总行数

$stmt->columnCount()：总列数

$stmt->fetchObject()：获取一条数据，匹配成类的对象

$stmt->bindColumn()：将列绑定到变量上

匹配一条数据（$stmt->fetch()）

$rows=$stmt->fetch(); // 默认匹配成关联索引数组

$rows=$stmt->fetch(PDO::FETCH_BOTH); // 同上

$rows=$stmt->fetch(PDO::FETCH_ASSOC); // 匹配成关联数组

$rows=$stmt->fetch(PDO::FETCH_NUM); // 匹配成索引数组

$rows=$stmt->fetch(PDO::FETCH_OBJ); // 匹配成对象

匹配所有记录（$stmt->fetchAll()）

//$rs=$stmt->fetchAll();

//$rs=$stmt->fetchAll(PDO::FETCH_BOTH);

//$rs=$stmt->fetchAll(PDO::FETCH_ASSOC);

//$rs=$stmt->fetchAll(PDO::FETCH_BOTH);

//$rs=$stmt->fetchAll(PDO::FETCH_NUM);

//$rs=$stmt->fetchAll(PDO::FETCH_OBJ);

匹配列（$stmt->fetchColumn()）

//echo $stmt->fetchColumn(); // 默认是第一行的第 0 列

echo $stmt->fetchColumn(1); // 当前行的第 1 列，索引从 0 开始

获取总行数、总列数

echo ‘总行数：’.$stmt->rowCount().'<br>’;

echo ‘总列数：’.$stmt->columnCount(),'<br>’;

获取一条数据并匹配成指定类的对象

//$obj=$stmt->fetchObject(); // 不指定类，默认匹配成 stdClass 类

//$obj=$stmt->fetchObject(‘Student’); // 将数据匹配成 Student 类的属性

将列的数据绑定到变量上

$stmt->bindColumn(1, $id); // 将第 1 列绑定到 $id 变量上

$stmt->bindColumn(2, $name);// 将第 2 列绑定到 $name 变量上

$stmt->fetch();

echo $id,’-‘,$name,'<br>’; //1-tom

$stmt->bindColumn(‘id’, $id); // 将 id 字段绑定到 $id 变量上

$stmt->bindColumn(‘score’, $score); // 将 score 字段绑定到 $score 变量上

$stmt->fetch();

echo $id,’-‘,$score,'<br>’; //2-99

通过循环获取全部数据

while($rows=$stmt->fetch(PDO::FETCH_ASSOC)){

echo $rows[‘id’],’-‘,$rows[‘name’],’-‘,$rows[‘score’],'<br>’;

}

通过迭代获取全部数据

foreach($stmt as $rows){

echo $rows[‘id’],’-‘,$rows[‘name’],’-‘,$rows[‘score’],'<br>’;

}

全部代码

<?php

header(‘Content-Type:text/html;charset=utf-8′);

$dsn=’mysql:dbname=data’;

$pdo=new PDO($dsn,’root’,’root’);

$stmt=$pdo->query(‘select * from stu’); // 返回 PDOStatement 对象

/********** 第一个操作：匹配一条数据 *********/

/*

$rows=$stmt->fetch(); // 默认匹配成关联索引数组

$rows=$stmt->fetch(PDO::FETCH_BOTH); // 同上

$rows=$stmt->fetch(PDO::FETCH_ASSOC); // 匹配成关联数组

$rows=$stmt->fetch(PDO::FETCH_NUM); // 匹配成索引数组

$rows=$stmt->fetch(PDO::FETCH_OBJ); // 匹配成对象

*

*/

/********** 第二个操作：匹配所有记录 *********/

//$rs=$stmt->fetchAll();

//$rs=$stmt->fetchAll(PDO::FETCH_BOTH);

//$rs=$stmt->fetchAll(PDO::FETCH_ASSOC);

//$rs=$stmt->fetchAll(PDO::FETCH_BOTH);

//$rs=$stmt->fetchAll(PDO::FETCH_NUM);

//$rs=$stmt->fetchAll(PDO::FETCH_OBJ);

/********** 第三个操作：匹配列 *********/

//echo $stmt->fetchColumn(); // 默认是第一行的第 0 列

//echo $stmt->fetchColumn(1); // 当前行的第 1 列，索引从 0 开始

/********** 第四个操作：获取总行数，总列数 *********/

//echo ‘总行数：’.$stmt->rowCount().'<br>’;

//echo ‘总列数：’.$stmt->columnCount(),'<br>’;

/********** 第五个操作：获取一条数据并匹配成指定类的对象 *********/

class Student{

}

//$obj=$stmt->fetchObject(); // 不指定类，默认匹配成 stdClass 类

//$obj=$stmt->fetchObject(‘Student’); // 将数据匹配成 Student 类的属性

/********** 第六个操作：将列绑定到变量上 *********/

/*

$stmt->bindColumn(1, $id); // 将第 1 列绑定到 $id 变量上

$stmt->bindColumn(2, $name);// 将第 2 列绑定到 $name 变量上

$stmt->fetch();

echo $id,’-‘,$name,'<br>’; //1-tom

$stmt->bindColumn(‘id’, $id); // 将 id 字段绑定到 $id 变量上

$stmt->bindColumn(‘score’, $score); // 将 score 字段绑定到 $score 变量上

$stmt->fetch();

echo $id,’-‘,$score,'<br>’; //2-99

*

*/

/********** 第七个操作：循环所有数据 *********/

while($rows=$stmt->fetch(PDO::FETCH_ASSOC)){

echo $rows[‘id’],’-‘,$rows[‘name’],’-‘,$rows[‘score’],'<br>’;

}

/********** 第八个操作：通过迭代器遍历数据 *********/

foreach($stmt as $rows){

echo $rows[‘id’],’-‘,$rows[‘name’],’-‘,$rows[‘score’],'<br>’;

}

预处理语句

思考：为什么需要用到预处理？
答：如果有多个相同结构的 SQL 语句执行，都要会经历重复的以下过程：词法分析——语法分析——编译——执行, 我们可以使用预处理，编译一次，多次执行。提高执行效率。

MySQL 的预处理

声明预处理语句的语法：prepare 预处理名字 from ‘SQL 语句’

执行预处理语句：execute 预处理名字 [using 变量]

例题一（没有传递参数）：

例题二（传递参数）

例题三（传递多个参数）

PDO 中的预处理

1、位置占位符

<?php

$dsn=’mysql:dbname=data’;

$pdo=new PDO($dsn,’root’,’root’);

$sql=’insert into stu values (null,?,?)’; //? 是位置占位符

$stmt=$pdo->prepare($sql); // 声明预处理语句，返回 PDOStatement 对象

$array=array(

array(‘aa’,10),

array(‘bb’,20),

array(‘cc’,30)

);

foreach($array as $a){

// 方法一

//$stmt->execute($a);

// 方法二：

/*

$stmt->bindValue(1, $a[0]); // 绑定数据

$stmt->bindValue(2, $a[1]);

$stmt->execute();

*/

// 方法三：

$stmt->bindParam(1, $a[0]); // 绑定数据

$stmt->bindParam(2, $a[1]);

$stmt->execute();

}

多学一招：bindValue() 和 bindParam() 的区别

bindValue() 可以将值或变量绑定到占位符上，bindParam() 只能将变量绑定到占位符上

2、参数占位符

<?php

$dsn=’mysql:dbname=data’;

$pdo=new PDO($dsn,’root’,’root’);

$sql=’insert into stu values (null,?,?)’; //? 是位置占位符

$stmt=$pdo->prepare($sql); // 声明预处理语句，返回 PDOStatement 对象

$array=array(

array(‘aa’,10),

array(‘bb’,20),

array(‘cc’,30)

);

$sql=’insert into stu values (null,:p1,:p2)’; // :p1,:p2 是参数占位符

$stmt=$pdo->prepare($sql); // 声明预处理语句

foreach($array as $a){

$stmt->bindParam(‘:p1’, $a[0]); // 编订参数

$stmt->bindParam(‘:p2’, $a[1]);

$stmt->execute();

}

预处理的好处

提高速度

提高安全性

PDO 属性操作

$pdo->getAttribute()：获取 PDO 属性的值

$pdo->setAttribute()：设置 PDO 属性

PDO 异常处理

单例模式实现 MyPDO 类的封装

<?php

class MyPDO{

private $type; // 数据库类型

private $host; // 主机地址

private $port; // 端口号

private $dbname; // 数据库名

private $charset; // 字符编码

private $user; // 用户名

private $pwd; // 密码

private $pdo; //PDO 对象

private static $instance; // 私有的静态属性保存 MyPDO 的单例

private function __construct($config) { // 私有的构造函数阻止在类的外部实例化对象

$this->initParam($config);

$this->initPDO();

$this->initException();

}

private function __clone(){ // 私有的__clone() 阻止在类的外部 clone 对象

}

public static function getInstance($config=array()){ // 公有的静态方法获取 MyPDO 的单例

if(!self::$instance instanceof self)

self::$instance=new self($config);

return self::$instance;

}

/*

* 初始化成员变量

* @param $config array 配置数组

*/

private function initParam($config){

$this->type=isset($config[‘type’])?$config[‘type’]:’mysql’;

$this->host=isset($config[‘host’])?$config[‘host’]:’127.0.0.1′;

$this->port=isset($config[‘port’])?$config[‘port’]:’3306′;

$this->dbname=isset($config[‘dbname’])?$config[‘dbname’]:”;

$this->charset=isset($config[‘charset’])?$config[‘charset’]:’utf8′;

$this->user=isset($config[‘user’])?$config[‘user’]:”;

$this->pwd=isset($config[‘pwd’])?$config[‘pwd’]:”;

}

/*

* 实例化 pdo

*/

private function initPDO(){

try{

$dsn=”{$this->type}:host={$this->host};port={$this->port};dbname={$this->dbname};charset={$this->charset}”;

$this->pdo=new PDO($dsn, $this->user, $this->pwd);

} catch (Exception $e) {

$this->showException($e);

}

}

/*

* 设置自动抛出异常

*/

private function initException(){

$this->pdo->setAttribute(PDO::ATTR_ERRMODE,PDO::ERRMODE_EXCEPTION);

}

/*

* 显示异常信息

* @param $e object 错误对象

* @parram $sql string 错误的 SQL 语句

*/

private function showException($e,$sql=”){

if($sql!=”)

echo “SQL 语句执行失败 <br> 错误的 SQL 语句是：{$sql}<br>”;

echo ‘错误信息：’.$e->getMessage(),'<br>’;

echo ‘错误编号：’.$e->getCode(),'<br>’;

echo ‘错误文件：’.$e->getFile(),'<br>’;

echo ‘错误行号：’.$e->getLine(),'<br>’;

exit;

}

/*

* 执行数据操作语句

* @return 成功返回受影响的记录数，失败返回 false

*/

public function exec($sql){

try

{

return $this->pdo->exec($sql);

}catch(PDOException $e){

$this->showException($e, $sql);

}

}

/*

* 返回插入数据的自动增长的编号

*/

public function lastInsertId(){

return $this->pdo->lastInsertId();

}

/*

* 获取 PDOStatement 对象

* @param $sql string SQL 语句

* @return PDOStatement 对象

*/

private function getPDOStatement($sql){

try

{

return $this->pdo->query($sql);

} catch (Exception $e) {

$this->showException($e);

}

}

/*

* 判断匹配类型

* @param $type string 用户需要的类型

* @return 常量

*/

private function getFetchType($type){

$allow=array(‘num’,’assoc’,’both’);

if(!in_array($type, $allow))

$type=’assoc’;

switch($type){

case ‘num’:

return PDO::FETCH_NUM;

case ‘assoc’:

return PDO::FETCH_ASSOC;

case ‘both’:

return PDO::FETCH_BOTH;

}

}

/*

* 获取一条记录

* @param $sql string SQL 语句

* @param $type string 匹配类型 num,assoc,both

* @return array 一维数组

*/

public function fetchRow($sql,$type=”){

$stmt= $this->getPDOStatement($sql);

$fetch_const= $this->getFetchType($type);

return $stmt->fetch($fetch_const);

}

/*

* 匹配所有数据

* @return array 二维数组

*/

public function fetchAll($sql,$type=”){

$stmt= $this->getPDOStatement($sql);

$fetch_const= $this->getFetchType($type);

return $stmt->fetchAll($fetch_const);

}

/*

* 获取遗憾一列的数据

*/

public function fetchColumn($sql){

try{

$stmt= $this->getPDOStatement($sql);

return $stmt->fetchColumn();

} catch (Exception $e) {

$this->showException($e);

}

}

}

header(‘Content-Type:text/html;charset=utf-8’);

// 测试

$config=array(

‘dbname’ => ‘data’,

‘user’ => ‘root’,

‘pwd’ => ‘root’

);

$mypdo= MyPDO::getInstance($config);

/*

if($mypdo->exec(“insert into stu values (null,’bb’,20)”))

echo $mypdo->lastInsertId ();

*/

/*

$rows=$mypdo->fetchAll(‘select * from stu order by id asc’,’num’);

echo ‘<pre>’;

print_r($rows);

*

*/

echo $mypdo->fetchColumn(‘select count(*) from stu’);

常见的编程思想

面向过程思想

通过程序的执行顺序为主线开发代码

优点：简单，易学，上手快。

缺点：多人合作不方便

面向对象思想

以组成项目的对象为主线进行开发。在面向对象的思想里面，所有的事物都看成对象。

优点：多人合作方便，代码冗余很少

缺点：学起来比面向过程复杂。

面向对象简介

OOP：面向对象编程（Object Oriented Programming），OOP，面向对象编程

OOAD：OOA和OOD

OOA: 面向对象分析(Object-Oriented Analysis,OOA)

OOD: 面向对象设计（Object-Oriented Design，OOD）

对象

对象是由属性和方法组成的

属性的本质就是变量

方法的本质就是函数

类

类是所有对象共同的属性和方法的组合。

我们在开发时候是通过调用对象的方法或属性来实现某个效果，要调用方法必须先有对象，要想有对象必须先有类。

开发顺序：类——（实例化）对象——调用对象的方法和属性。

类和对象的关系

通过类可以创建多个对象，类就类似于模具，一个模具制造很多形状一致的对象。

类是有父类和子类之分的

再比如：老师是类，语文老师也是类，老师是父类，语文老师是子类。

在PHP中实现类

语法

class 类名{

//属性

//方法

//常量

}

类名的命名规则

1. 以字母、下划线开头，后面跟的是字母、数字、下划线
2. 一般用帕斯卡命名法
3. 不能用PHP关键字做类名
4. 类名不区分大小写

实例化对象

实例化：创造实例（对象）的过程

通过new关键字实例化

$对象名=new 类名()

例题

对象的传递

对象的传递的地址传递

操作属性

对象调用属性和方法使用“->”，

语法：

对象名->属性

对象名->方法名()

<?php

//类

class Student {

public $name; //语法结构：访问修饰符+变量名

}

//实例化

$stu1=new Student; //类名后不加()也可以

$stu2=new Student(); //类名后加()也可以

$stu1->name=’tom’; //操作1、给属性赋值

echo $stu1->name,'<br>’; //tom //操作2、显示属性的值

$stu1->add=’beijing’; //操作3、给stu1对象添加add属性

unset($stu2->name); //操作4、删除stu2对象的name属性

var_dump(isset($stu1->name));//bool(true) //操作5：判断属性是否存在

定义方法

语法结构

访问修饰符 function 方法名(参数){

//方法体

}

例题

对象的比较

全等：指向同一个对象是全等

相等：只要属于同一个类，结构和属性值都一致才相等

访问修饰符

用来修饰属性和方法，控制属性和方法的权限

例题一

脚下留心：一般来说，属性都是私有的，通过公有的方法对私有的属性进行赋值和取值。这样做可以在方法中对数据进行过滤，提高数据安全性。

<?php

class Student {

public $name; //私有属性

public $sex; //私有属性

//通过公有的方法进行赋值

public function setInfo($name,$sex) {

if($sex!=’男’ && $sex!=’女’){

echo ‘性别只能是男或女<br>’;

return;

}

$this->name=$name; //$this表示调用当前方法的对象

$this->sex=$sex;

}

//通过公有的方法进行取值

public function getInfo() {

echo ‘姓名：’.$this->name,'<br>’;

echo ‘性别：’.$this->sex.'<hr>’;

}

}

//调用

header(‘Content-Type:text/html;charset=utf-8’);

$stu1=new Student;

$stu1->setInfo(‘tom’,’男’);

$stu1->getInfo();

$stu2=new Student;

$stu2->setInfo(‘berry’,’女’);

$stu2->getInfo();

$this

$this在方法的内部使用，表示调用当前方法的对象。

构造函数

普通方法不调用就不执行

构造函数也叫构造方法，在实例化对象的时候自动调用执行

语法一：

Public function __construct(){

}

脚下留心：__construct()前面是两个下划线。

语法二：和类名同名的函数是构造函数

Public function 类名(){

}

例题

脚下留心：推荐使用__construct(),因为__construct()的优先级最高。

构造函数用来初始化成员变量

成员变量就是属性

析构函数

当对象销毁的时候自动调用

语法

Public function __destruct(){

}

代码

脚下留心：

1. 构造函数和析构函数是PHP自己调用，不能手动调用
2. 构造函数可以带有参数，析构函数不能带有参数。

多学一招：数据的存储和销毁分为两种情况:先进先出（队列）

先进后出（出入栈）

对象在内存中的分布

对象的本质就是复杂变量

类的本质就是复杂的数据类型

分析如下代码

<?php

class Student {

private $name;

private $sex;

public function show() {

echo ‘i am a student<br>’;

}

}

$stu1=new Student(); //将堆区的地址付给栈区的$stu1

$stu1->show();

$stu2=new Student();

$stu2->show();

在内存中结构

堆区特点：体积大，查询速度慢

栈区特点：体积小，查询速度快

基本数据类型的数据都存放在栈区中；复杂数据类型都存储在堆区中，但是堆区中的地址保存到栈区中。

继承

1. 代码具有层次结构
2. 子类继承了父类的属性和方法，实现了代码的可重用性。

语法

Class 子类 extends 父类{

}

继承的例题

<?php

//父类

class Person {

public $name=’tom’;

public function show() {

echo ‘i am a boy!’;

}

}

//子类

class Student extends Person {

}

//测试

$stu=new Student();

echo $stu->name,'<br>’;

$stu->show();

分析：$stu->name执行过程，首先在Student中寻找$name,如果找到就访问，如果找不到，就到Person类中找$name。

调用父类的属性和方法

在子类中通过$this关键字可以调用父类属性和方法

调用父类的构造方法

总结一句话：如果子类有构造方法就调用子类的，如果子类没有就调用父类的。

通过parent::__construct()调用父类的构造函数

Parent表示父类的名字

给父类传递参数

<?php

//父类

class Person {

protected $name;

protected $sex;

public function __construct($name,$sex) {

$this->name=$name;

$this->sex=$sex;

}

}

//子类

class Student extends Person {

private $score;

public function __construct($name,$sex,$score) {

parent::__construct($name,$sex);//调用父类的构造函数

$this->score=$score;

}

public function show() {

echo “姓名：{$this->name}<br>”;

echo “性别：{$this->sex}<br>”;

echo “成绩：{$this->score}<br>”;

}

}

//测试

header(‘Content-Type:text/html;charset=utf-8’);

$stu=new Student(‘tom’,’男’,88);

$stu->show();

运行结果

parent表示父类的名字

提醒：使用parent关键字可以降低程序的耦合性。

protected（受保护的）

protected修饰的在整个继承链上访问

$this

$this表示当前对象的引用（地址）

封装

通过访问修饰符来封装，有选择性的提供数据。

多态

多种形态，多态分为两种，方法重写和方法重载，PHP不支持方法重载

方法重写

子类重写了父类的同名方法

规则：

1. 子类中的方法必须和父类中的方法同名
2. 子类可以拥有和父类不同数量的参数

1. 子类中覆盖的方法不能比父类中被覆盖的方法更加严格

方法重载

通过参数的个数来区分不同的方法，PHP不支持。

面向对象的三大特性

1. 封装，通过访问修饰符来实现封装
   1. Public
   2. Private
   3. protected
2. 继承：子类继承了父类的属性和方法
3. 多态：多种形态
   1. 方法重写
   2. 方法重载（PHP不支持）

私有属性的继承和重写

私有属性可以被继承，但是不能被重写

思考如下例题

方法修饰符

1. static：静态的
2. final：最终的
3. abstract：抽象的

static修饰符

1. static修饰属性叫静态属性，static修饰方法叫静态方法
2. 静态属性在加载类的时候分配空间（普通属性在实例化的时候分配空间）,所以不需要实例化就可以访问
3. 因为静态成员属于类，不属于某个对象，所以通过类名来调用静态成员
   1. 类名::静态属性
   2. 类名::静态方法()
4. 静态成员在内存中就一份。

多学一招： 由于普通方法在加载类的时候也加载了，所以也可以通过静态调用的方式来调用普通方法。

静态成员可以被继承

静态延时绑定

static也可以表示类名，表示调用当前访问的对象所属的类。

self：当前类的名字

self总是表示当前类的名字

final修饰符

final修饰的类不能被继承

final修饰的方法不能被重写

abstract修饰符

1. abstract修饰的方法叫抽象方法，abstract修饰的类叫抽象类
2. 只有方法的声明，没有方法的实现称为抽象方法。
3. 一个类中只要只要有一个方法是抽象方法，这个类必须是抽象类

1. 抽象类不可以被实例化，必须在子类中重新实现抽象方法
2. 抽象方法的作用：用来定义命名规范的。

<?php

//类中只要有一个方法是抽象的，这个类就是抽象类

abstract class Goods {

protected $name; //商品名

public function setName($name) {

$this->name=$name;

}

public abstract function show(); //只有方法的声明，没有方法的实现

}

//手机类继承商品类

class Mobile extends Goods {

public function show() { //实现父类的抽象方法

echo $this->name,'<br>’;

}

}

//图书类继承商品类

class Book extends Goods {

public function show() { //实现父类的抽象方法

echo “《{$this->name}》<br>”;

}

}

//测试

header(‘Content-Type:text/html;charset=utf-8’);

$mobile=new Mobile();

$mobile->setName(‘iPhone7’);

$mobile->show();

$book=new Book();

$book->setName(‘PHP入门与精通’);

$book->show();

多学一招：类中一个抽象方法都没有也可以声明成抽象类。可以通过这种方法阻止类的实例化。

接口（interface）

1. 如果一个类中所有的方法都是抽象方法，这个类就可以声明成接口。
2. 使用interface关键字声明接口
3. 接口中的抽象方法只能是public的，默认也是public。
4. 接口不能继承，而是实现接口（implements）
5. abstract和final不能修饰接口中的抽象方法
6. 接口的作用也是用来定义命名规范

类不允许多重继承

一个父类可以有多个子类

一个子类不能有多个父类（只有c++可以多重继承，其他语言都不允许多重继承。）

多学一招：为什么很多语言不支持多重继承，因为多重继承容易产生二义性。

接口的多重实现

继承类同时实现接口

必须是先继承类再实现接口

类常量

常量也是加载代码的时候加载，所以也是通过类名来方法

类常量用const声明

const常量也可以放在接口中（接口中只能放抽象方法和常量）

参数约束

1. 参数约束在PHP5.3以后才支持
2. 只能约束对象，不能约束基本类型

父类可以指向子类的引用

父类可以保存子类对象的地址

<?php

class Person {

}

class Student extends Person {

}

class Employee extends Person {

}

function show(Person $obj) {

}

//测试

show(new Student);

show(new Employee);

分页功能

知识点：select * from 表名 limit 起始位置，记录数

起始位置从0开始。

分析：起始位置和页码的关系

一页放10条记录（$pagesize=10）

推导公式：$startno(起始位置)=($pageno-1)*$pagesize;

分析：总共有多少页

推导公式：$pagecount=ceil($rowcount/$pagesize)

实现第一步：输出页码

点击页码——获取页码——通过页码获取页码的内容

代码实现

//第一步：获取总记录数

$sql=”select count(*) from contents where title=$titleid”;

$rs=mysql_query($sql);

$rows=mysql_fetch_row($rs);

$rowcount=$rows[0]; //获取到总记录数

//第二步：求得总页数

$pagesize=10; //页码大小

$pagecount=ceil($rowcount/$pagesize); //求得总页数

在页码底部循环输出页码

<tr>

<td colspan=’3′>

<?php for($i=1;$i<=$pagecount;$i++):?>

<?php if($pageno==$i):?>

<span class=”pageno”><?php echo $i?></span> &nbsp;

<?php else:?>

<a href=”?pageno=<?php echo $i?>&titleid=<?php echo $titleid?>”><?php echo $i?></a>&nbsp;

<?php endif;?>

<?php endfor;?>

<a href=”?pageno=1&titleid=<?php echo $titleid?>”>【首页】</a>

<a href=”?pageno=<?php echo $pageno-1?>&titleid=<?php echo $titleid?>”>【上一页】</a>

<a href=”?pageno=<?php echo $pageno+1?>&titleid=<?php echo $titleid?>”>【下一页】</a>

<a href=”?pageno=<?php echo $pagecount?>&titleid=<?php echo $titleid?>”>【末页】</a>

</td>

</tr>

实现第二步：获取页码，并取出当前页面中的内容

代码

//第三步：获取当前页的内容

$pageno=isset($_GET[‘pageno’])?$_GET[‘pageno’]:1; //获取当前页码

$pageno=$pageno<1?1:$pageno; //如果页码小于1，定位到第一页

$pageno=$pageno>$pagecount?$pagecount:$pageno; //页码大于总页数，定位到最后一页

$startno=($pageno-1)*$pagesize; //计算当前页的起始位置

$sql=”select * from contents where title=$titleid limit {$startno},{$pagesize}”;

$rs=mysql_query($sql);

完整代码

<!doctype html>

<html>

<head>

<meta charset=”utf-8″>

<title>无标题文档</title>

<style type=”text/css”>

table{

width:980px;

}

table,td,th{

border:solid 1px #000;

margin:auto;

font-size:14px;

}

.pageno{

font-size:24px;

color:#FF0000;

}

</style>

</head>

<body>

<?php

//连接数据库

mysql_connect(‘localhost’,’root’,’root’) or die(‘数据库连接失败’);

mysql_select_db(‘jokedb’);

mysql_query(‘set names utf8’);

?>

<!–显示分类–>

<?php

$rs=mysql_query(‘select * from title’);

?>

<table>

<tr>

<?php

$n=0;

while($rows=mysql_fetch_assoc($rs)):

?>

<td><a href=”?titleid=<?php echo $rows[‘Id’]?>”><?php echo $rows[‘Title’]?></a></td>

<?php

if(++$n%9==0)

echo ‘</tr><tr>’;

endwhile;

?>

</tr>

</table>

<!–显示内容–>

<?php

$titleid=isset($_GET[‘titleid’])?$_GET[‘titleid’]:1;

//第一步：获取总记录数

$sql=”select count(*) from contents where title=$titleid”;

$rs=mysql_query($sql);

$rows=mysql_fetch_row($rs);

$rowcount=$rows[0]; //获取到总记录数

//第二步：求得总页数

$pagesize=10; //页码大小

$pagecount=ceil($rowcount/$pagesize); //求得总页数

//第三步：获取当前页的内容

$pageno=isset($_GET[‘pageno’])?$_GET[‘pageno’]:1; //获取当前页码

$pageno=$pageno<1?1:$pageno; //如果页码小于1，定位到第一页

$pageno=$pageno>$pagecount?$pagecount:$pageno; //页码大于总页数，定位到最后一页

$startno=($pageno-1)*$pagesize; //计算当前页的起始位置

$sql=”select * from contents where title=$titleid limit {$startno},{$pagesize}”;

$rs=mysql_query($sql);

?>

<table>

<tr>

<th>编号</th> <th>内容</th> <th>作者</th>

</tr>

<?php while($rows=mysql_fetch_assoc($rs)):?>

<tr>

<td><?php echo $rows[‘Id’]?></td>

<td><?php echo $rows[‘Contents’]?></td>

<td><?php echo $rows[‘Author’]?></td>

</tr>

<?php endwhile;?>

<!–输出页码–>

<tr>

<td colspan=’3′>

<?php for($i=1;$i<=$pagecount;$i++):?>

<?php if($pageno==$i):?>

<span class=”pageno”><?php echo $i?></span> &nbsp;

<?php else:?>

<a href=”?pageno=<?php echo $i?>&titleid=<?php echo $titleid?>”><?php echo $i?></a>&nbsp;

<?php endif;?>

<?php endfor;?>

<a href=”?pageno=1&titleid=<?php echo $titleid?>”>【首页】</a>

<a href=”?pageno=<?php echo $pageno-1?>&titleid=<?php echo $titleid?>”>【上一页】</a>

<a href=”?pageno=<?php echo $pageno+1?>&titleid=<?php echo $titleid?>”>【下一页】</a>

<a href=”?pageno=<?php echo $pagecount?>&titleid=<?php echo $titleid?>”>【末页】</a>

</td>

</tr>

</table>

</body>

</html>

回顾

1. 多态：多种形态
2. 多态分为：方法重载和方法重写
   1. 方法重写：之类重写了父类的同名方法
      1. 规则：
         1. 子类重写的方法必须和父类名字一样
         2. 可以具有不同个数的参数，但是严格标准必须是个数一样
         3. 子类中覆盖的方法不能比父类更加严格
   2. 方法重载：在同一个类中有多个同名的方法，通过不同的参数个数和参数类型区分不同方法。PHP不支持方法重载。
3. 私有属性可以继承，但不能被重写
4. 方法修饰符
   1. Static（静态的）
      1. Static可以修饰属性和方法
      2. 静态成员在加载类的分配空间
      3. 静态成员在内存中只有一份，属于类，不属于某个对象
      4. 通过类名来调用静态成员 类名::静态成员
      5. 静态成员也是可以被继承的
      6. Static也可以表示类名，表示调用当前方法对象的所属的类
   2. Final（最终的）
      1. Final修饰的方法不能被重写
      2. Final修饰的类不能被继承
   3. Abstract（抽象的）
      1. 只有方法的声明，没有方法的实现成为抽象方法
      2. 一个类中只要有一个方法是抽象方法这个类必须是抽象类
      3. 没有抽象方法的类也可以声明成抽象类
      4. 抽象类不可以被实例化，抽象方法必须在子类中重新实现
      5. 抽象方法是用来定义方法的命名规范的
5. Self：总是表示当前类的类名
6. 接口
   1. 如果一个类中所有的方法都是抽象类，这个类可以声明成接口
   2. 使用interface关键字
   3. 通过implements关键字实现接口
   4. 接口中所有的方法都是抽象的，公有的
   5. 不能使用abstract和final来修饰接口中的方法
   6. 类不允许多重继承，接口可以多种实现
7. 类常量
   1. 使用const关键字声明
   2. Const常量可以放在类和接口中
8. 参数约束：只能约束对象
9. 父类可以指向子类的引用。

思考：如何实现C可以调用A和B中的方法

类的自动加载

在项目层面上类文件规则

1. 一个文件中只能有一个类
2. 文件名和类名同名
3. 文件名以.class.php结尾

场景（一个文件中需要用到3个类）

1. 创建Goods.class.php页面

<?php

//商品类

abstract class Goods {

protected $name;

final public function setName($name) {

$this->name=$name;

}

abstract function getName();

}

1. 创建Book.class.php页面

<?php

//图书类

class Book extends Goods {

public function getName() { //重写了父类的方法

echo “《{$this->name}》<br>”;

}

}

1. 创建Mobile.class.php

<?php

//手机类

class Mobile extends Goods {

public function getName() {

echo $this->name,'<br>’;

}

}

1. 在PHP页面中使用上面的3个类

问题：在代码之前要引入需要的类。如果页面中需要用到很多的类，这样引入就很麻烦了。

类的自动加载

当页面执行的时候，通过PHP核心程序（zend engine）判断用户需要用到那个类，如果没有找到该类，就会自动调用__autoload()函数，并且以缺少的类名做为参数传递到__autoload()函数中，我们只要在__autoload()函数中加载需要的类即可。

通过缺少的类名加载类文件

在类文件保存地址规则的情况下使用

把类的地址映射到数组中然后加载

适合在类文件保存不规则的时候使用

clone和__clone()

clone：用来创建一个对象

__clone()：当调用clone指令的时候自动执行__clone()函数

<?php

class Student {

//执行clone指令的时候自动调用__clone()方法

public function __clone() {

echo ‘你调用了clone指令<br>’;

}

}

header(‘Content-Type:text/html;charset=utf-8’);

$stu1=new Student;

$stu2=clone $stu1; //创建一个新的对象

var_dump($stu1);echo ‘<br>’;

var_dump($stu2);

总结：创建对象的方式：

1. 实例化
2. clone

单例模式

一个类只能创建一个对象

阻止类实例化的方法

1. 抽象方法（可以阻止在类的外部和内部实例化）
2. 私有的构造函数（阻止在类的外部实例化）

判断对象是否属于某个类

通过三私一公来实现

<?php

/**

*单例模式，三私一公

*/

class MySQL {

//保存MySQL的单例

private static $instance;

//阻止在类的外部实例化对象

private function __construct() {

}

//阻止在类的外部clone对象

private function __clone() {

}

//获取MySQL的单例

public static function getInstance() {

if(!self::$instance instanceof self) //静态属性中保存的对象是否属于MySQL类

self::$instance= new self(); //实例化对象对象

return self::$instance;

}

}

//测试

$db1=MySQL::getInstance();

$db2=MySQL::getInstance();

var_dump($db1); // object(MySQL)#1 (0) { } 

echo ‘<br>’;

var_dump($db2); // object(MySQL)#1 (0) { } 

项目层面的单例模式

多个对象的单例

工厂模式

传递不同的参数，返回不同的对象

<?php

class ProductA {

public function show() {

echo ‘获取A商品<br>’;

}

}

class ProductB {

public function show() {

echo ‘获取B商品<br>’;

}

}

//工厂模式(传递不同的参数获取不同的对象)

class Factory {

public static function create($num) {

switch($num%2) {

case 1:

return new ProductA();

case 0:

return new ProductB;

}

}

}

//测试

header(‘Content-Type:text/html;charset=utf-8’);

$objA=Factory::create(10);

$objB=Factory::create(15);

$objA->show(); //获取B商品

$objB->show(); //获取A商品

策略模式

传递不同的参数调用不同的策略（方法）

<?php

class Walk {

public function method() {

echo ‘走着去学校<br>’;

}

}

class Bus {

public function method() {

echo ‘坐车去学校<br>’;

}

}

class Bike {

public function method() {

echo ‘骑车去学校<br>’;

}

}

//策略模式，传递不同的对象，调用不同的方法

class Strategy {

public function go($obj) {

$obj->method();

}

}

//测试

header(‘Content-Type:text/html;charset=utf-8’);

$strategy=new Strategy();

$strategy->go(new Walk()); //走着去学校

$strategy->go(new Bus()); //坐车去学校

$strategy->go(new Bike()); //骑车去学校

魔术方法

已经学过的魔术方法

__construct()：构造函数，当实例化对象的时候自动调用

__destruct()：析构函数，当对象销毁的时候自动调用

__clone()：当调用clone指令的时候自动调用

__toString()和__invoke()

__tostring()：当对象作为字符串使用的时候自动执行

__invoke()：当将对象作为函数使用的时候自动执行

__set()、__get()、__isset()

1、__set($key,$value)：当给无法访问的属性赋值的时候自动调用

2、__get($key)：当给无法访问的属性取值的时候自动调用

3、__isset($key)：当判断无法访问的属性是否存在

4、__unset($key)：当销毁无法访问的属性的时候自动调用

总结：给私有属性赋值的方法

1. 通过公有的方法给私有属性赋值
2. 通过构造函数给私有属性赋值
3. 通过魔术方法__set()赋值，__get()取值

<?php

class Student {

private $name;

private $age;

/**

*当给无法访问的属性赋值的时候自动调用

*@param $key string 属性名

*@param $value string 属性值

*/

public function __set($key,$value) {

if($key==’age’ && !($value>=20 && $value<=30)){

echo ‘年龄必须在20~30之间<br>’;

return;

}

$this->$key=$value;

}

/**

*当给无法访问的属性取值的时候自动调用

*@param $key string 属性名

*/

public function __get($key) {

return $this->$key;

}

/**

*当判断无法访问的属性是否存在

*/

public function __isset($key) {

return isset($this->$key);

}

/**

*当销毁无法访问的属性的时候自动调用

*/

public function __unset($key) {

unset($this->$key);

}

}

header(‘Content-Type:text/html;charset=utf-8’);

$stu=new Student;

$stu->name=’tom’; //给私有属性赋值

$stu->age=25;

echo ‘姓名：’.$stu->name,'<br>’; //获取私有属性的值

echo ‘年龄：’.$stu->age,'<br>’;

var_dump(isset($stu->name)); //判断私有属性是否存在

echo ‘<br>’;

unset($stu->name); //销毁私有属性

var_dump($stu);

__call()、 __callStatic()

<?php

class Student {

/**

*当调用无法访问的属性的时候自动调用

*@param $name string 方法名

*@param $args array 参数数组

*/

public function __call($name,$args) {

echo “对象中没有'{$name}’的方法<br>”;

echo ‘你传递”‘.implode(‘,’,$args).'”参数给我也没用<hr>’;

}

/**

*当调用无法访问的静态方法的时候自动调用

*/

public static function __callstatic($name,$args) {

echo “对象中没有'{$name}’这个静态方法<br>”;

echo ‘你传递”‘.implode(‘,’,$args).'”参数给我也没用<hr>’;

}

}

header(‘Content-Type:text/html;charset=utf-8’);

$stu=new Student;

$stu->show(10,20); //调用无法访问的方法

Student::connect(); //调用无法访问的静态方法

__sleep()和 __wakeup()

__sleep()：在序列化的时候自动调用

__wakeup()；在反序列化的时候自动调用

<?php

class Student {

private $name;

private $sex;

private $add;

/**

*在调用serialize时候自动调用

*作用：只保留需要序列化的属性

*/

public function __sleep() {

return array(‘name’,’sex’); //返回需要序列化的属性

}

/**

*在调用unserialize时候自动调用

*作用：初始化对象的值

*/

public function __wakeup() {

$this->name=’tom’;

$this->sex=’男’;

$this->add=’中国’;

}

}

header(‘Content-Type:text/html;charset=utf-8’);

$stu=new Student;

$str=serialize($stu);

echo $str,'<hr>’;

$stu=unserialize($str);

print_r($stu);

序列化（serialize）和反序列化（unserialize）

思考：能否将数组和对象永久保存？

答：可以，但是必须先序列化

序列化就是将数组或对象变成一个字符串序列

数组序列化和反序列化

序列化

反序列化

对象序列化和反序列化

序列化

反序列化

发现可以反序列化，但是类名没有反编译出来，解决方法在反序列化之前引入对应的类就可以了

foreach遍历对象

foreach遍历只能遍历到可以访问到的属性

迭代器（Iterator）

场景：一个班级有60个学生，如何遍历这个班？

解决：

Iterator是PHP内置的接口，定义了5个抽象方法，只要实现了这5个抽象方法，迭代器就可以工作了。

例题

<?php

//班级类

class MyClass implements Iterator {

private $list=array(‘tom’,’berry’,’ketty’,’rose’); //学生数组

//复位数组

public function rewind() {

reset($this->list);

}

//判断当前指针是否有效

public function valid() {

return key($this->list)!==null;

}

//返回当前键

public function key() {

return key($this->list);

}

//返回当前值

public function current() {

return current($this->list);

}

//指针下移

public function next() {

next($this->list);

}

}

//测试

$class=new MyClass();

foreach($class as $key=>$val) {

echo $key,’-‘,$val,'<br>’;

}

通过单例模式封装MySQL数据库操作类

实现功能

1. 连接数据库
2. 查询数据

需要注意的点：

1. 一个方法只实现一个功能，方法的功能越单一越好，这样可以最大限度的实现代码的可重用性。

代码

<?php

/**

*MySQL数据库操作类(单例模式实现)

*/

class MySQLDB {

private $host; //主机地址

private $port; //端口号

private $user; //用户名

private $pwd; //密码

private $dbname; //数据库名称

private $charset; //支付编码

private static $instance; //保存MySQLDB的实例

//阻止在类的外部实例化

private function __construct($config) {

$this->initParam($config);

$this->connect();

$this->selectDb();

$this->setCharSet();

}

//阻止在类的外部调用clone指令

private function __clone() {

}

//获取MySQLDB类的单例

public static function getInstrance($config=array()) {

if(!self::$instance instanceof self)

self::$instance=new self($config);

return self::$instance;

}

//初始化数据

private function initParam($config) {

$this->host=isset($config[‘host’])?$config[‘host’]:’127.0.0.1′;

$this->port=isset($config[‘port’])?$config[‘port’]:’3306′;

$this->user=isset($config[‘user’])?$config[‘user’]:”;

$this->pwd=isset($config[‘pwd’])?$config[‘pwd’]:”;

$this->dbname=isset($config[‘dbname’])?$config[‘dbname’]:’data’;

$this->charset=isset($config[‘charset’])?$config[‘charset’]:’utf8′;

}

//连接数据库

private function connect() {

if(!$link=@mysql_connect(“{$this->host}:{$this->port}”,$this->user,$this->pwd))

$this->showMessage();

}

//选择数据库

private function selectDb() {

if(!mysql_select_db(“$this->dbname”))

$this->showMessage();

}

//设置字符编码

private function setCharSet() {

if(!@mysql_query(“set names {$this->charset}”)){

$this->showMessage();

}

}

//显示错误的方法

private function showMessage($sql=”) {

if($sql!=”)

echo ‘错误SQL语句：’.$sql,'<br>’;

echo ‘错误信息：’.mysql_error(),'<br>’;

echo ‘错误编号：’.mysql_errno(),'<br>’;

exit;

}

//执行SQL语句的方法

private function query($sql) {

if($rs=mysql_query($sql))

return $rs;

$this->showMessage($sql);

}

//拼接函数名

private function createFunction($type) {

$allow=array(‘assoc’,’row’,’array’);

if(!in_array($type,$allow))

$type=’assoc’;

return ‘mysql_fetch_’.$type;

}

//获取二维表的数据

public function getAll($sql,$type=’assoc’) {

$fn=$this->createFunction($type);

$rs=$this->query($sql);

$array=array();

while($rows=$fn($rs)) {

$array[]=$rows;

}

return $array;

}

}

header(‘Content-Type:text/html;charset=utf-8’);

//测试

$config=array(

‘user’ => ‘root’,

‘pwd’ => ‘root’,

‘dbname’=> ‘jokedb’,

);

$mysql=MySQLDB::getInstrance($config);

$rs=$mysql->getAll(‘select * from title’,’aa’);

echo ‘<pre>’;

var_dump($rs);

命名空间

命名空间介绍

如果一个项目很大，项目中由很多文件组成，如何有序的组织这些文件就是一个大问题，PHP提供了命名空间来解决。

多学一招：

C#语言中也是通过“命名空间”来解决的

Java语言通过“包”来解决的。

命名空间的声明与使用

通过namespace来声明命名空间

多级命名空间

<?php

namespace China\ShangHai\PuDong; //多级命名空间

function getInfo() {

echo ‘我是中国人<br>’;

}

namespace USA\Washington;

function getInfo() {

echo ‘I am a America<br>’;

}

//调用

header(‘Content-Type:text/html;charset=utf-8’);

getInfo(); //I am a America

\China\ShangHai\PuDong\getInfo(); //我是中国人

访问空间元素的三种方法

1. 非限定名称访问（类似于相对路径）
2. 完全限定名称访问（绝对路径）
3. 【部分】限定名称访问（相对路径）

引入命名空间（use）

分析：PuDong\getInfo()如何调用的？

第一步：通过命名空间拼接，拼接成\ USA\Washington\ PuDong\getInfo()，但是在这个地址下找不到此函数，所以继续执行第二步

第二步：由于引入了China\ShangHai\PuDong命名空间，又可以拼接成China\ShangHai\PuDong\ getInfo()，这个地址是可以找到函数的，所以调用此函数。

引入类（use）

通过use关键字引入类

给类取别名（as）

如果引入的类和已经存在的类同名，就会报错，我们可以引入类的同时给类取别名

<?php

namespace China\ShangHai\PuDong;

class Person {

public $name=’中国人’;

}

namespace USA\Washington;

class Person{

public $name=’美国人’;

}

header(‘Content-Type:text/html;charset=utf-8’);

use China\ShangHai\PuDong\Person as P; //引入类,并给类取别名

$person=new P();

echo $person->name; //中国人

公共命名空间

如果PHP文件中没有namespace关键字声明，该文件的元素都在“公共命名空间”下，访问公共命名空间用“\”。

命名空间的注意事项

1. 命名空间中可以放函数，类，const常量

1. 在第一个namespace之前不能有任何的代码，header()也不行。

1. 包含文件不能改变当前的命名空间

用文件的地址做命名空间，通过命名空间就可以实现自动加载类

1. 在Framework/Core文件夹下创建Student.class.php

<?php

namespace Framework\Core;

class Student {

public function show() {

echo ‘Core\Student\show()<br>’;

}

}

1. 在Framework/Lib文件夹下创建Student.class.php

<?php

namespace Framework\Lib;

class Student {

public function show() {

echo ‘Lib\Student\show()<br>’;

}

}

1. 在php中通过命名空间实现自动加载类

异常处理（Exception）

使用的关键字

try：检测代码中的异常

catch：捕获抛出的异常

throw：抛出异常

Exception：PHP内置的异常类

Exception异常类中的方法

Exception是基础异常类，该类提供了一些方法

异常的例题

自定义异常，捕获多个异常

PHP只提供了异常类，没有提供具体的某种异常，比如年龄异常，邮件异常等。

自定义异常必须继承Exception类，Exception类是所有异常类的父类。

<?php

//空异常

class NullException extends Exception {

}

//年龄异常

class AgeException extends Exception {

}

if(isset($_POST[‘button’])) {

$name=$_POST[‘name’];

$age=$_POST[‘age’];

try

{

if($name==”)

throw new NullException(‘姓名不能为空’); //抛出空异常

if($age==”)

throw new NullException(‘年龄不能为空’); //抛出空异常

if(!($age>=10 && $age<=20))

throw new AgeException(‘年龄必须在10-20之间’); //抛出年龄异常

}

catch(NullException $e)

{

echo $e->getMessage();

}

catch(AgeException $e)

{

echo $e->getMessage();

}

catch(Exception $e){ //必须放在所有的catch的最后

echo $e->getMessage();

}

}

?>

<form method=”post” action=””>

姓名： <input type=”text” name=”name”> <br />

年龄： <input type=”text” name=”age”> <br />

<input type=”submit” name=”button” value=”提交”>

</form>

介绍netbeans

安装netbeans

在安装netbeans之前必须先安装jdk（java开发包）

安装JDK后，再下一步，下一步安装netbeans.。

使用netbeans

双击netbeans图标

继续如下操作

创建完毕后，在虚拟目录的文件夹中多了一个“nbproject”文件夹，此文件夹用来让netbeans软件管理虚拟目录的，不是项目文件夹。在最后项目上传到服务器的时候要将此文件夹删除。

反射（Reflection）

反射的概念

程序可以访问、检测和修改它本身状态或行为的一种能力

反射的作用

获取对象对应的类中的属性，方法，参数，注释等封闭的信息，主要用来了解类、方法等内部结构。

反射的分类

了解如下几个反射类即可。

使用反射类（了解内容）

通过反射了解类的内部结构

语法：

ReflectionClass::export(类名);

例题

通过上面的例题可以得出结论，PHP最顶层的父类是一个空类，代码

class stdClass{

}

通过反射获取类中的属性、方法、常量

<?php

class Student{

const PI=3.14;

public $name=’tom’;

private $sex=’f’;

public function show(){

}

}

//通过反射获取类中的成员

$info= new ReflectionClass(‘Student’); //实例化反射类对象，此对象中包含了Student类中的信息

//获取常量信息

$const=$info->getConstants(); //获取所有常量,返回常量数组

$const=$info->getConstant(‘PI’); //获取PI常量

//获取方法信息

$method=$info->getMethods(); //获取所有方法,返回方法信息数组

$method=$info->getMethod(‘show’); //获取show()方法信息

//获取属性信息

$propty=$info->getProperties(); //获取所有属性信息

$propty=$info->getProperty(‘sex’); //获取sex属性

var_dump($propty);

通过反射实例化对象

newInstance()就是用来实例化对象，构造函数需要几个参数，就通过newInstance()传递几个参数。

通过反向代理调用类方法

正向代理：局域网中所有电脑通过服务器访问外网，局域网中电脑感受到服务器的存在，这种代理是正向代理

反向代理

将上面的理论平移到反射中来

A调用A的方法：正向代理

通过反射，A调用B的方法：反向代理