FuelPHP - 快速指南
FuelPHP - 简介
FuelPHP 是一个开源 Web 应用程序框架。它使用 PHP 5.3 编写，并实现了 HMVC 模式。HMVC 是一个 分层模型-视图-控制器框架，允许对控制器进行子请求，该控制器返回部分页面(如评论、菜单等)，而不是像普通 MVC 中那样返回完整页面。
FuelPHP 的创建旨在将 CodeIgniter 和 Kohana 等框架的最佳实践与自己的改进和想法结合起来。 FuelPHP 数据库迁移工具和脚手架功能受到流行的 Ruby on Rails 框架的启发。
FuelPHP 通过名为 "Oil" 的实用程序利用 命令行 的强大功能。该实用程序旨在帮助加快开发速度、提高效率、测试、调试和 HTML 支持。
FuelPHP 是一种纯粹的面向对象方法。其架构基于模块化的理念。应用程序可以分为模块，每个组件都可以扩展或替换，而无需重写一行代码。Fuel 支持任何模板解析器，例如 Smarty、Twig、PHPTal 等，用于解析视图。
FuelPHP 社区庞大而活跃，拥有 300 多名贡献者。其大型社区定期创建和改进软件包和扩展。 FuelPHP 框架的主要目标是提供灵活性和兼容性。它速度快、易学，是开发 Web 应用程序的完整解决方案。
FuelPHP 成为 PHP 开发人员使用的首要框架之一的原因在于 - 由于其稳定的 API，FuelPHP 的新版本与其旧版本反向兼容。它非常灵活。
包和模块使以系统方式重用现有代码变得简单而轻松。FuelPHP 通过小型库提供最大性能。它的交互式调试允许轻松消除开发中的错误。此外，其干净稳定的代码使编程更容易。
FuelPHP - 功能
FuelPHP 提供许多功能来创建成熟的 Web 应用程序。它提供了灵活的组件、简单的配置、易于使用的 ORM、基于 REST 的应用程序开发模式等。以下是一些突出的功能 −
- 灵活且由社区驱动的 Web 框架
- 易于配置和使用
- FuelPHP 非常便携，几乎可以在任何服务器上工作
- 灵活的 URI 路由系统
- FuelPHP 提供 RESTful API 开发支持
- 轻量级 ORM 模型
- 输入过滤并防止 SQL 注入
- 安全的身份验证和授权框架
- 代码可重用且更易于维护
- 自动加载类、会话管理和异常处理。
FuelPHP - 优势
FuelPHP 是一个优雅的 HMVC PHP 5.3 框架，它提供了用于构建 Web 应用程序的组件集，具有以下优点 −
模块化结构 − Fuel 不会强迫您使用模块或 HMVC 文件结构。如果您想使用，该过程很容易集成。 FuelPHP 应用程序采用模块化结构创建，对开发人员来说更容易，好处明显。
HMVC 模式 − 该框架最重要的特性是 HMVC(分层模型视图控制器)，它可以轻松访问或使用更高级别的任何属性、类方法、函数、文件。
安全哈希函数 − FuelPHP 支持强大的加密工具和密码哈希技术。它使用强大的 PHPSecLib 处理加密、解密和哈希。
脚手架功能 − 脚手架是一种用于构建数据库操作的元编程方法。 Fuel 的脚手架非常简单。它允许您通过非常简单的步骤获得基本的 CRUD 应用程序。
以下热门产品使用 FuelPHP 框架 −
Matic Technology − 离岸定制软件开发解决方案的全球提供商。在 Matic Technologies，他们根据客户的要求通过 FuelPHP 提供所有最佳解决方案。
Kroobe − Kroobe 是一家社交网络分类广告公司。Fuel 为 Kroobe 团队提供极低的开发成本和服务，以实现高效的解决方案。
FuelPHP - 安装
本章介绍如何在您的机器上安装 FuelPHP 框架。FuelPHP 安装非常简单易行。您有两种方法可以创建 FuelPHP 应用程序 −
第一种方法是使用名为 Oil 的 FuelPHP 工具进行 命令行 安装。
第二种方法是 基于 Composer 的安装。FuelPHP 使用 Composer 进行安装和包依赖项，因此在继续该过程之前，请确保本地安装了 Composer。
让我们在后续章节中逐一详细介绍每种方法。
系统要求
在进行安装之前，必须满足以下系统要求。
Web 服务器(以下任何一种)
- WAMP (Windows)
- Microsoft IIS (Windows)
- LAMP (Linux)
- MAMP (Macintosh)
- XAMP (Multi-platform)
- Nginx (Multi-platform)
- PHP 内置开发 Web 服务器(多平台)
浏览器支持(以下任意一种)
- IE(Internet Explorer 8 以上)
- Firefox
- Google Chrome
- Safari
PHP 兼容性 − PHP 5.3 或更高版本。要获得最大优势，请使用最新版本。
让我们在本教程中使用 PHP 的内置开发 Web 服务器。内置的开发 Web 服务器易于启动，并且足以理解 FuelPHP Web 应用程序的基础知识，而无需了解复杂的 Web 服务器和配置世界。
命令行安装
FuelPHP 的命令行安装非常简单，最多只需五分钟。
安装 Oil 包
Oil 是 FuelPHP 框架提供的一个特殊包/命令，用于执行 FuelPHP 应用程序开发所需的许多任务，包括安装、开发和测试应用程序。
要安装 Oil 包，请打开 shell 并运行以下命令 −
sudo curl https://get.fuelphp.com/oil | sh
该命令使用curl下载并安装oil包，命令会输出类似如下信息，并最终安装oil包。
% Total % Received % Xferd Average Speed Time Time Time Current
Dload Upload Total Spent Left Speed
100 479 100 479 0 0 353 0 0:00:01 0:00:01 --:--:-- 353
创建新项目
要使用 Oil 创建新项目，请使用以下命令 −
oil create <project_name>
让我们使用以下命令创建一个名为"HelloWorld"的新项目。
oil create HelloWorld
现在，您可以看到类似于以下的响应，并最终创建一个简单的 FuelPHP 框架应用程序。
composer create-project fuel/fuel HelloWorld
Installing fuel/fuel (1.8.0.1)
- Installing fuel/fuel (1.8.0.1)
Loading from cache
Created project in HelloWorld
Loading composer repositories with package information
Updating dependencies (including require-dev)
- Installing composer/installers (v1.3.0)
Loading from cache
- Installing fuelphp/upload (2.0.6)
Loading from cache
- Installing michelf/php-markdown (1.4.0)
Loading from cache
- Installing psr/log (1.0.2)
Loading from cache
- Installing monolog/monolog (1.18.2)
Loading from cache
- Installing phpseclib/phpseclib (2.0.0)
Loading from cache
- Installing fuel/core (1.8.0.4)
Loading from cache
- Installing fuel/auth (1.8.0.4)
Loading from cache
- Installing fuel/email (1.8.0.4)
Loading from cache
- Installing fuel/oil (1.8.0.4)
Loading from cache
- Installing fuel/orm (1.8.0.1)
Loading from cache
- Installing fuel/parser (1.8.0.4)
Loading from cache
- Installing fuel/docs (1.8.0.4)
Loading from cache
…………….
…………….
Writing lock file
Generating autoload files
Oil 版本
要测试 Oil 是否可用并检查版本，请使用以下命令 −
$ cd HelloWorld $ php oil -v
上述命令产生以下结果 −
Fuel: 1.8 running in "development" mode
Oil 帮助命令
要获取 Oil 的基本帮助文档，请使用以下命令 −
$ php oil help
上述命令将显示类似于以下结果的帮助文档 −
Usage: php oil [cell|console|generate|package|refine|help|server|test] Runtime options: -f, [--force] # Overwrite files that already exist -s, [--skip] # Skip files that already exist -q, [--quiet] # Supress status output -t, [--speak] # Speak errors in a robot voice Description: The 'oil' command can be used in several ways to facilitate quick development, help with testing your application and for running Tasks. Environment: If you want to specify a specific environment oil has to run in, overload the environment variable on the commandline: FUEL_ENV=staging php oil <commands> More information: You can pass the parameter "help" to each of the defined command to get information about that specific command: php oil package help Documentation: http://docs.fuelphp.com/packages/oil/intro.html
到目前为止，您已经了解如何使用 Oil 安装 Fuel。下一节中，我们将介绍基于 Composer 的安装。
基于 Composer 的安装
以下命令用于使用 Composer 安装 FuelPHP。
$ composer create-project fuel/fuel --prefer-dist.
Git 存储库克隆
要将最新开发版本安装为本地 git 存储库克隆，请使用以下命令。
$ composer create-project fuel/fuel:dev-1.9/develop --prefer-source.
运行应用程序
移动到项目目录公共文件夹，使用以下命令在生产服务器运行应用程序。
$ cd path/to/HelloWorld/public $ php -S localhost:8080 index.php
它产生以下响应。
PHP 5.5.31 Development Server started at Sun May 21 12:26:10 2017 Listening on http://localhost:8080 Document root is /Users/workspace/php-fuel/HelloWorld/public Press Ctrl-C to quit.
现在，请求 URL，http://localhost:8080，它将产生以下结果。
结果
这是在开发环境中运行 FuelPHP 应用程序的最简单方法。如果您在生产环境中以这种方式创建应用程序，您将面临安全问题。推荐的方法是设置虚拟主机配置。下一节将针对 apache web 服务器进行解释。
设置虚拟主机
这是访问 FuelPHP 应用程序的更安全的方法。要设置虚拟主机，您需要将 apache 虚拟主机文件链接到您的应用程序。如果是内网应用，请将系统主机文件 URL 重定向到虚拟主机。
虚拟主机文件
打开虚拟主机并添加以下更改。
<VirtualHost *:80>
ServerName hello.app
DocumentRoot /path/to/public
SetEnv FUEL_ENV "development"
<Directory /path/to/public>
DirectoryIndex index.php
AllowOverride All
Order allow,deny
Allow from all
</Directory>
</VirtualHost>
系统主机文件
现在，使用以下命令将主机条目添加到您的机器。
sudo vi /etc/hosts
然后，将以下行添加到文件末尾。
127.0.0.1 hello.app
要使所有更改可用，请重新启动 Apache 服务器并请求 URL，http://hello.app。它会生成 FuelPHP 主页。
FuelPHP - 架构概述
FuelPHP 基于经过实战检验的 Model-View-Controller 架构以及 HMVC(分层 MVC) 支持。虽然 MVC 提供了灵活和分层的应用程序开发，但 HMVC 更进一步，实现了 Web 应用程序的小部件化。
FuelPHP 的优势在于它不强制使用特定的应用程序开发方式。它只是提供了一个简单易用的标准结构。开发人员可以自由使用 FuelPHP 提供的预定义功能集，也可以在需要时对其进行修改。FuelPHP 提供的所有功能(包括核心功能)都可以根据应用程序的要求进行更改。
模型
模型是应用程序的业务实体。控制器和视图以模型的形式交换数据。模型可以统一表示我们的业务数据。它使数据库层能够以标准方式与 Web 应用程序层交互，并提供选择、保存、编辑和删除数据库实体的选项。
控制器
典型的 MVC 应用程序从控制器开始。一旦用户向 FuelPHP Web 应用程序发送请求，应用程序就会收集有关该请求的所有信息并将其发送给控制器。控制器执行所请求页面所需的业务逻辑，然后以模型的形式调用相关视图以及处理后的数据。
视图
视图是 MVC 应用程序的表示层。视图决定如何向用户显示模型。它支持从简单的数据呈现到高级布局，使网站能够在所有页面上规范设计。视图还提供主题支持，使整个应用程序的设计能够快速更改。
Presenter
Presenter 是 FuelPHP 提供的一项特殊功能。它是控制器和视图之间的粘合剂。控制器可以共享其一些低级职责，例如从数据库检索模型、为视图生成数据等。控制器调用 Presenter 而不是视图，而视图又调用视图。 Presenter 实现了业务逻辑和表示层的完全分离。
分层 MVC
FuelPHP 提供了一个从另一个控制器调用一个控制器的选项，类似于来自客户端(浏览器)的请求。如果任何控制器调用另一个控制器，被调用的控制器将向调用控制器返回响应，而不是将其呈现给客户端(浏览器)。这实现了 Web 应用程序的小部件化。例如，评论部分可以显示为独立页面以及主(博客)页面的子部分。
模块
FuelPHP 的一个显著特点是可以将 Web 应用程序的一部分转换为模块，这些模块可以在不同的应用程序之间共享。例如，只需将模块代码从源应用程序复制到目标应用程序，即可在另一个应用程序中重用为应用程序创建的博客模块。
请注意，创建新模块与开发主应用程序一样简单。结构类似于主应用程序，唯一的不同之处在于模块应该编码一个单独的文件夹。
包
FuelPHP 提供了一个选项，可以将代码组织成一个称为包的单元。包可以包含 Web 应用程序所需的一个或多个功能。例如，可以将数据库组件(如 ORM、电子邮件等)组织成一个包并在需要时使用。
包与模块的不同之处在于包不包含任何网页或部分网页。该包可用于 FuelPHP 以及任何其他 PHP 框架。
工作流
FuelPHP 的工作流简单易懂。如下图所示。
用户向应用程序发送请求。
控制器接收请求并通过与模型交互来收集信息，模型又与数据库交互。
控制器通过向其他控制器发送子请求与其他控制器交互来收集信息。
控制器将检索到的模型发送到视图，视图又生成演示文稿并将其作为响应发送到客户端。
在某些情况下，控制器可能会将控制权传递给演示者。在这种情况下，演示者从模型中收集信息并将其发送给客户端。在这里，演示者不执行任何业务逻辑，除了从数据库中检索模型。
FuelPHP - 简单的 Web 应用程序
在本章中，我们将了解如何在 FuelPHP 框架中创建一个简单的应用程序。如前所述，您知道如何在 Fuel 中创建一个新项目。我们可以以员工详细信息为例。
让我们首先使用以下命令创建一个名为 Employee 的项目。
oil create employee
执行命令后，将创建一个 employee 项目，其文件结构如下: −
employee ├── CHANGELOG.md ├── composer.json ├── composer.lock ├── composer.phar ├── CONTRIBUTING.md ├── fuel │ ├── app │ │ ├── bootstrap.php │ │ ├── cache │ │ ├── classes │ │ ├── config │ │ ├── lang │ │ ├── logs │ │ ├── migrations │ │ ├── modules │ │ ├── tasks │ │ ├── tests │ │ ├── themes │ │ ├── tmp │ │ ├── vendor │ │ └── views │ ├── core │ │ ├── base56.php │ │ ├── base.php │ │ ├── bootstrap.php │ │ ├── bootstrap_phpunit.php │ │ ├── classes │ │ ├── composer.json │ │ ├── config │ │ ├── CONTRIBUTING.md │ │ ├── lang │ │ ├── phpunit.xml │ │ ├── tasks │ │ ├── tests │ │ ├── vendor │ │ └── views │ ├── packages │ │ ├── auth │ │ ├── email │ │ ├── oil │ │ ├── orm │ │ └── parser │ └── vendor │ ├── autoload.php │ ├── composer │ ├── fuelphp │ ├── michelf │ ├── monolog │ ├── phpseclib │ └── psr ├── LICENSE.md ├── oil ├── public │ ├── assets │ │ ├── css │ │ ├── fonts │ │ ├── img │ │ └── js │ ├── favicon.ico │ ├── index.php │ └── web.config ├── README.md └── TESTING.md 42 directories, 21 files
应用程序结构
FuelPHP 框架提供了组织良好的应用程序结构。让我们检查一下应用程序的一些重要文件和文件夹。
fuel − 包含所有 PHP 文件。
public − 包含所有可通过浏览器直接访问的资产，如 JavaScript、CSS、图像等。
oil − 用于运行命令行任务(如生成代码或在应用程序内进行交互式调试)的可执行文件。它是可选的。
fuel/app/ − 包含所有特定于应用程序的 PHP 文件。它包含模型、视图和控制器。
fuel/core/ −这是 Fuel 框架本身所在的位置。
fuel/packages/ − 包含所有 fuel 包。默认情况下，fuel 将包含三个包:oil、auth 和 orm。除非您需要，否则不会加载这些包。
fuel/app/config/ − 包含所有与应用程序相关的配置文件。主应用程序配置文件 config.php 文件位于此处。
fuel/app/classes/ − 包含所有特定于应用程序的基于 MVC 的 PHP 文件。它包含控制器、模型、辅助类、库等。
fuel/app/classes/controller/ − 控制器放在这里。
fuel/app/classes/model/ −模型放在这里。
fuel/app/views/ − 包含视图文件。视图没有特定的命名约定。
添加控制器
如前所述，FuelPHP 基于模型-视图-控制器 (MVC) 开发模式。MVC 是一种将应用程序逻辑与表示分离的软件方法。在 MVC 模式中，控制器起着重要作用，应用程序中的每个网页都需要由控制器处理。默认情况下，控制器位于 fuel/app/classes/controller/ 文件夹中。您可以在此处创建自己的控制器类。
移动到 fuel/app/classes/controller/ 位置并创建 employee.php 文件。要创建新的控制器，只需扩展 FuelPHP 提供的 Controller 类，定义如下。
employee.php
<?php
class Controller_Employee extends Controller {
public function action_home() {
// 主页的功能
echo "FuelPHP-Employee application!";
}
}
现在，我们创建了一个员工控制器并添加了一个公共方法 action_home，该方法打印一个简单的文本。
路由
路由将网页 URI 解析为特定的控制器和操作。FuelPHP 应用程序中的每个网页在实际执行控制器之前都应经过路由。默认情况下，可以使用以下 URI 模式解析每个控制器。
<controller>/<action>
其中，
controller 是控制器的名称减去命名空间，employee
action 是方法的名称减去 action_ 关键字，home
可以通过 http://localhost:8080/employee/home 访问新创建的控制器，它将产生以下结果。
结果
FuelPHP - 配置
在本章中，我们将了解如何配置 FuelPHP 应用程序。默认情况下，配置文件存储在 fuel/app/config 文件夹中。应用程序的主要配置是 fuel/app/config/config.php。配置使用 PHP 的关联数组指定。
概述
默认情况下，所有默认配置文件都定义在 fuel/core/config 文件夹中。要覆盖默认配置，请在 /fuel/app/config/config.php 文件中添加相应的键并修改值。我们可以使用"点符号"来简化多维数组。例如，以下配置具有相同的用途(加载指定的包)。
array("always_load" => array("packages" => array( ... ) ) );
always_load.packages = array( ... );
配置可以按目的分组，并使用不同的文件指定，例如 db.php 用于数据库配置，package.php 用于包管理等。
配置格式类型
FuelPHP 非常灵活，提供不同的格式来指定配置。默认配置格式是使用 php 数组的 PHP。其他选项是 −
INI − 许多软件(包括 PHP 语言本身)都支持简单的基于文本的配置。
[group] key = value
YAML − 易于理解、基于缩进且人性化易读的配置管理。
group: key: value
JSON − 易于理解且开发人员最常用的文件格式。
{
"group" :
{
"key": "value"
}
}
Memcached − 将配置存储在 memcached 服务器中。可以使用 config.memcached 条目在主配置文件 fuel/app/config/config.php 中指定 memcached 服务器详细信息。
DB − 将配置存储在 RDBMS 系统中。配置表的表结构如下。
CREATE TABLE IF NOT EXISTS `config` ( `identifier` char(100) NOT NULL, `config` longtext NOT NULL, `hash` char(13) NOT NULL, PRIMARY KEY (`identifier`) )
可以使用 config.database 和 config.table_name 条目在配置文件中指定数据库和表的详细信息。
环境
环境通过加载不同的配置使 FuelPHP 能够在不同的模式下工作。FuelPHP 支持以下环境。
开发 − \Fuel::DEVELOPMENT 设置开发模式
生产 − \Fuel::PRODUCTION 设置生产模式
测试 − \Fuel::TEST 设置测试模式
暂存 − \Fuel::STAGING 设置暂存模式
FuelPHP 还支持创建新环境。这将使每个开发人员都有自己的配置设置，他们可以在编码和测试应用程序时启用它。只需创建一个具有环境名称的文件夹(例如:test)并将配置文件放在新创建的文件夹中，即可添加特定环境的配置，如下所示。
. ├── config.php
├── db.php
├── development
│ └── db.php
├── production
│ └── db.php
├── routes.php
├── staging
│ └── db.php
└── test
└── db.php
4 directories, 7 files
设置您的环境
有三种方法可以设置您的环境。
选项 1 − 使用 Web 服务器的环境变量设置环境。在 Apache Web 服务器的 httpd.conf 文件中的虚拟主机部分添加以下代码。也可以在 .htaccess 文件中添加它。
SetEnv FUEL_ENV production
选项 2 −使用 FuelPHP 引导文件 /fuel/app/bootstrap.php 设置环境
Fuel::$env = (isset($_SERVER['FUEL_ENV']
选项 3 − 使用 Oil 设置环境
$ env FUEL_ENV = production php oil -v
它产生以下结果。
Fuel: 1.8 以"生产"模式运行
FuelPHP - 控制器
控制器负责处理进入 FuelPHP 应用程序的每个请求。根据 FuelPHP，控制器位于 fuel/app/classes/controller/。让我们首先创建一个员工控制器。
employee.php
<?php
class Controller_Employee extends Controller {
public function action_home() {
echo "FuelPHP-Employee application!";
}
public function action_index() {
echo "This is the index method of employee controller";
}
}
控制器方法
控制器使用其 action_ 方法之一来处理 Web 请求。我们可以根据应用程序的要求创建任意数量的 action_ 方法。默认的 action_ 方法是 action_index。action_index 方法可以通过以下任何 URL 调用。
http://localhost:8080/employee/index http://localhost:8080/employee/
结果
让我们在 employee 应用程序中创建一个新的 action 方法 action_show。
<?php
class Controller_Employee extends Controller {
public function action_home() {
echo "FuelPHP-Employee application!";
}
public function action_index() {
echo "This is the index method of employee controller";
}
public function action_show() {
echo "This is the show method of employee controller";
}
}
action_show 方法可使用以下 URL 调用。
http://localhost:8080/home/show
结果
before( ) 方法
我们可以在控制器中创建一个方法 before。此方法将在每次 action_ 方法调用之前执行。如果该方法不存在，则不会调用该方法。此方法可帮助我们编写常见操作，例如登录检查、默认数据获取等。
让我们创建一个 before 方法并打印一条简单的文本消息。
public function before() {
echo "This message comes from <em>before()</em> method</br>";
}
带有 before 操作的索引页面
显示带有 before 操作的页面
after( ) 方法
after() 方法类似于 before() 方法，但在调用 action_ 方法后执行。after() 方法将 response 作为输入并返回 response 对象。
public function after($response) {
if ( ! $response instanceof Response) {
$response = \Response::forge($response, $this->response_status);
}
return $response;
}
如果输入为 NULL 或不是响应对象，则使用 Response 的 forge 方法创建一个新的 Response 对象并返回它。我们将在后续章节中详细学习 Response 类。
扩展控制器
我们可以从另一个控制器扩展一个控制器。以下是基本语法。
class Controller_Employee extends Controller_Welcome {
// 控制器方法
}
这将有助于共享方法。
生成控制器
Fuel 可以选择使用 Oil 命令生成控制器。以下是语法。
语法
oil g controller <controller-name>
示例
oil g 控制器示例
执行上述命令后，您将看到以下响应。
结果
创建视图:/path/to/project/fuel/app/views/template.php 创建视图:/path/to/project/fuel/app/views/sample/index.php 创建控制器:/path/to/project/fuel/app/classes/controller/sample.php
控制器类型
FuelPHP 为各种目的提供了不同类型的控制器。它们如下 −
- 基本控制器
- 模板控制器
- Rest 控制器
- 混合控制器
基本控制器
Controller 是 FuelPHP 中所有不同类型控制器的基本控制器。它提供了处理 Web 请求所需的所有基本功能。它支持请求、响应、会话等。除非另有说明，否则我们将在所有示例中使用它。
模板控制器
模板控制器是基本控制器的扩展。它具有模板支持、预定义的 before() 和 after() 方法。基本上，它可用于将您的视图包装在带有页眉、页脚、侧边栏等的布局中。要创建模板控制器，我们需要扩展 Controller_Template 类。默认情况下，扩展 Controller_Template 的类的所有方法都需要使用该模板。
其定义如下。
class Controller_Employee extends Controller_Template {
public function action_index() {
// add methods
}
}
我们将在"视图"一章中进一步讨论模板控制器。
Rest 控制器
Rest 控制器是基本控制器的扩展。它具有对 REST API 编程的预定义支持。这将使您能够轻松构建 API。
要创建 rest 控制器，您需要扩展 Controller_Rest 类。它定义如下。
class Controller_Employee extends Controller_Rest {
public function action_index() {
// add methods
}
}
我们将在 Ajax 章节中讨论更多关于 rest 控制器的内容。
混合控制器
混合控制器在单个基础控制器中执行 REST 控制器和模板控制器的功能。
FuelPHP - 路由
路由将请求 URI 映射到特定控制器的方法。在本章中，我们将详细讨论 FuelPHP 中的 路由 概念。
配置
Routes 配置文件位于 fuel/app/config/routes.php。默认的 routes.php 文件定义如下 −
<?php
return array (
'_root_' => 'welcome/index', // The default route
'_404_' => 'welcome/404', // The main 404 route
'hello(/:name)?' => array('welcome/hello', 'name' => 'hello'),
);
此处，_root_ 是预定义的默认路由，当使用根路径请求应用程序时将匹配该路由，例如 http://localhost:8080/。_root_ 的值是匹配时要解析的控制器和操作。welcome/index 解析为 Controller_Welcome 控制器和 action_index 操作方法。类似地，我们有以下保留路由。
root − 未指定 URI 时的默认路由。
403 − 当发现 HttpNoAccessException 时抛出。
404 −当页面未找到时返回。
500 − 当找到 HttpServerErrorException 时抛出。
简单路由
将路由与请求 URI 进行比较。如果找到匹配项，则将请求路由到 URI。简单路由描述如下，
return array ( 'about' => 'site/about', 'login' => 'employee/login', );
此处，about 匹配 http://localhost:8080/about 并解析控制器 Controller_Site 和操作方法 action_about
login 匹配 http://localhost:8080/login 并解析控制器 Controller_Login 和操作方法 action_login
高级路由
您可以将任何正则表达式包含到路由中。Fuel 支持以下高级路由功能 −
:any − 这会匹配 URI 中从该点开始的任何内容，但不匹配"nothing"
:everything − 类似于 :any，但也匹配"nothing"
:segment −这仅匹配 URI 中的 1 个段，但该段可以是任何内容
:num − 这匹配任何数字
:alpha − 这匹配任何字母字符，包括 UTF-8
:alnum − 这匹配任何字母数字字符，包括 UTF-8
例如，以下路由匹配 URI http://localhost:8080/hello/FuelPHP 并解析控制器 Controller_Welcome 和操作 action_hello
'hello(/:name)?' => array('welcome/hello', 'name' => 'hello'),
Controller_Welcome 中对应的动作方法如下，
public function action_hello() {
$this->name = Request::active()->param('name', 'World');
$message = "Hello, " . $this->name;
echo $message;
}
在这里，我们使用 Request 类从 URL 获取 name 参数。如果未找到 name，则使用 World 作为默认值。我们将在 Request 和 Response 章节中学习 Request 类。
结果
HTTP 方法操作
FuelPHP 支持路由以匹配 HTTP 方法前缀操作。以下是基本语法。
class Controller_Employee extends Controller {
public function get_index() {
// 当 HTTP 方法是 GET 时调用。
}
public function post_index(){
// 当 HTTP 方法是 POST 时调用。
}
}
我们可以根据配置文件中的 HTTP 动词将您的 URL 路由到控制器和操作，如下所示。
return array (
// Routes GET /employee to /employee/all and POST /employee to /employee/create
‘employee’ => array(array('GET', new Route(‘employee/all')), array('POST',
new Route(‘employee/create'))),
);
FuelPHP - 请求和响应
HTTP 请求和 HTTP 响应在任何 Web 应用程序中都发挥着重要作用。我们需要获取 http 请求的完整详细信息才能正确处理它。处理完成后，我们需要通过 http 响应将处理后的数据发送到客户端。
FuelPHP 提供了出色的 Request 和 Response 类，分别用于读取和写入 HTTP 请求和 HTTP 响应。让我们在本章中了解 Request 和 Response 类。
请求
在典型的 Web 应用程序中，应用程序需要解析当前请求的详细信息。Request 类提供了简单的方法来解析应用程序要处理的当前请求。 Request 还提供了通过充当 http 客户端来创建新请求的选项。
创建新请求使应用程序能够请求应用程序的其他部分或整个应用程序并显示结果。让我们在本章中学习如何解析传入的请求，并在 HMVC Request 章节中学习如何创建新请求。
解析请求
Request 类提供了三种方法来获取 http 请求的详细信息。它们如下，
active − 它是一个静态方法，它返回当前活动的 http 请求。
$currentRequest = Request::active();
param – 它返回指定参数的值。它包含两个参数。第一个参数是参数名称，第二个参数是要返回的值(如果当前 http 请求中没有该参数)。
$param = Request::active()->param('employee_name', 'none');
params – 它与 param 相同，只是它将所有参数作为数组返回。
$params = Request::active()->params();
示例
让我们创建一个简单的表单并使用请求类处理该表单。
步骤 1 −在员工控制器中创建一个新操作 action_request。
public function action_request() {
}
步骤 2 − 调用请求方法获取当前请求的所有参数。
public function action_request() {
$params = Request::active()->params();
}
步骤 3 − 转储获取的参数数组。
public function action_request() {
$params = Request::active()->params();
echo dump($params);
}
步骤 4 − 更改路由以包含路由配置文件 fuel/app/config/routes.php 中的参数>
'employee/request(/:name)?' => array('employee/request', 'name' => 'name'),
现在，请求新操作 http://localhost:8080/employee/request/Jon，它将显示以下响应。
Response
Response 类提供创建 http 响应的选项。默认情况下，在大多数情况下我们不需要直接使用响应类。相反，我们使用 View(我们将在下一章中学习)来创建 http 响应。View 对开发人员隐藏 http 响应，并使用底层 Response 类将响应发送到客户端。在高级情况下，我们直接使用 Response 类并创建完整的 http 响应。
创建响应
响应由标头和正文组成。主标头是 http 状态代码。Http 状态代码是 HTTP 协议中定义的用于描述响应的标准代码。例如，状态代码 200 表示请求成功。
Response 类提供三个参数来创建 http 响应，
$body − http 响应的主体
$status_code − http 响应的状态代码
$headers − 可选标头作为数组
$body = "Hi, FuelPHP"; $headers = array ( 'Content-Type' => 'text/html', ); $response = new Response($body, 200, $headers);
让我们在员工控制器中创建一个新的动作 action_response，如下所示。
public function action_response() {
$body = "Hi, FuelPHP";
$headers = array ('Content-Type' => 'text/html',);
$response = new Response($body, 200, $headers);
return $response;
}
结果
方法
Response 类提供了很多方法来操作 http 响应。它们如下，
forge − 它与上面看到的响应类构造函数相同。
return Response::forge("Hi, FuelPHP", 404);
redirect − 它提供重定向到 URL 而不是发送响应的选项。它包含以下参数，
a.url − 目标 URL b. method - 重定向方法。location(默认)和 refresh c。 redirect_code - http 状态代码。默认值为 302。
// 使用 URL
Response::redirect('http://some-domain/index', 'refresh');
// 或使用相对 URI
Response::redirect('employee/list');
redirect_back − 它类似于重定向方法，只是它会重定向到上一页。如果没有可用的后退页面，我们可以指定重定向页面。
// 如果没有后退页面，则转到员工列表页面
Response::redirect_back('/employee/list', 'refresh');
set_status −它提供了一个选项来设置 http 状态代码。
$response = new Response(); $response->set_status(404);
set_header − 它提供了一个选项来设置 http 标头。
$response = new Response();
$response->set_header('Content-Type', 'application/pdf');
// 使用第三个参数替换先前的值
$response->set_header('Content-Type', 'application/pdf', 'text/plain');
set_headers −它与 set_header 相同，只是它提供了使用数组设置多个标题的选项。
$response = new Response(); $response->set_headers (array 'Content-Type' => 'application/pdf', 'Pragma' => 'no-cache', ));
get_header − 它允许获取先前设置的标头详细信息。
$response = new Response();
$response->set_header('Pragma', 'no-cache');
// 返回 'no-cache'
$header = $response->get_header('Pragma');
// 返回 array('Pragma' => 'no-cache')
$header = $response->get_header();
body − 它提供了一个选项来设置 http 响应的主体。
$response = new Response();
$response->body('Hi, FuelPHP');
// 返回 'Hi, FuelPHP'
$body = $response->body();
send_headers − 它将标头发送到请求的客户端。FuelPHP 使用此方法将响应发送到客户端。通常，我们不需要使用此方法。
$response->send_headers();
send − 与 send_headers 相同，但标头可能在 http 响应中受到限制。
// 也发送标头 $response->send(true); // 仅发送正文 $response->send(false); $response->send();
FuelPHP - 视图
视图 是 MVC 应用程序的表示层。它将应用程序逻辑与表示逻辑分开。当控制器需要生成 HTML、CSS 或任何其他内容时，它会将任务转发给视图引擎。
FuelPHP 提供了一个简单而灵活的类 View，它具有视图引擎的所有必要功能。视图类支持视图文件的渲染。视图文件是一个嵌入了 PHP 指令的 HTML 页面。可以使用 View 类将视图文件的变量设置为 PHP 数组，并使用数组的键在视图文件中引用这些变量。让我们来看看 View 类的一些重要方法。
forge
用途 − 创建一个新的 View 对象
参数 − 以下是参数
$file − 视图文件相对于 views 文件夹的路径，fuel/app/views
$data − 值数组
$filter − 设置自动编码，默认为主配置文件中的设置
返回 − 视图的实例
例如，
$view = View::forge ('path/to/view', array(
'title' => "Show employee,
'employees' => $employees,
));
auto_filter
用途 − 设置是否对数据进行编码
参数 − 以下是参数
$filter − true / false
返回 − 当前视图对象
例如，
$view->auto_filter(); $view = $view->auto_filter(false);
set_filename
用途 −允许设置或更改视图文件。
参数 − 以下是参数 -
$file − 相对于视图文件夹的视图文件路径，fuel/app/views
返回 − 当前视图对象
例如，
$view = new View();
$view>set_filename('path/to/view');
set
用途 − 设置一个或多个变量的值
参数 −以下是参数
$key − 变量名称或值数组
$value − 值 / null
$filter − 编码设置，true / false
返回 − 当前视图对象
例如，
$view = new View();
$view->set(array('name' => 'Jon'));
set_global
set_global 与 set 类似，不同之处在于它适用于所有视图，并且所有视图都可以访问变量。这是一个静态方法。
View::set_global('name', 'Jon', false);
set_safe
用途 − 设置一个或多个变量的值，并启用安全编码。
参数 − 以下是参数 −
$key − 变量名称或值数组
$value −值 / null
返回 − 当前视图对象
例如，
$view = new View();
$view->set_safe(array('name' => 'Jon'), null);
get
用途 − 获取一个或多个变量的值
参数 − 以下是参数
$key − 变量名称
$default − 如果未找到键，则返回的默认值
返回 − 输入键的值
例如，
$view = new View();
$name = $view>get('name'); // name = 'Jon'
render
用途 − 通过将视图文件与本地和全局变量合并，将其渲染为字符串
参数 − 以下是参数 −
$file − 视图文件名
返回 − 渲染的视图文件为字符串
例如，
$html = View::forge()->render('/path/to/view');
创建视图
为了理解视图，让我们修改控制器 Controller_Employee 的操作方法 action_show。
employee.php
<?php
class Controller_Employee extends Controller {
public function action_show() {
return View::forge('employee/show');
}
}
现在在 views 目录中创建一个文件夹 employee，位于 fuel/app/views。然后，在 employee 文件夹中创建一个文件 show.php 并添加以下代码。
show.php
<h3> My first view </h3>
现在，请求 url http://localhost:8080/employee/show 并产生以下结果。
将数据传递给视图
我们可以使用前面讨论过的视图方法将数据传递给视图。以下是一个简单的示例。
employee.php
class Controller_Employee extends Controller {
public function action_show() {
$data = array(); //stores variables going to views
$data['name'] = ‘Jon’;
$data[‘job’] = ‘Designer’;
//将视图分配给浏览器输出
return View::forge('employee/show', $data);
}
}
现在，在 view 文件中添加更改。
show.php
<html>
<body>
Hello, <?php echo $name; ?>.
Your job is, <?php echo $job; ?>.
</body>
</html>
请求 URL 后，将显示姓名和职位，如下所示 −
View Filter
Views 使用输出编码来传递任何您想要的内容。如果您想传递未过滤的数据，我们可以使用 set 方法。
employee.php
class Controller_Employee extends Controller {
public function action_show() {
$view = \View::forge('employee/show');
$view->set('name', 'Jon', true);
$view->set('job', '<em>Designer</em>', false);
return $view;
}
}
请求 URL 后，它将以强调样式显示职位详细信息，如下所示。
嵌套视图
FuelPHP 支持嵌套视图。在嵌套视图中，一个视图可以包含一个或多个视图。要在另一个视图中设置视图，我们可以使用 render 方法，如下所示。
employee.php
class Controller_Employee extends Controller {
public function action_nestedview() {
//assign variables
$data = array();
$data['title'] = 'Home';
$data['name'] = 'Jon';
$data['job'] = 'Designer';
$views = array();
$views['head'] = View::forge('head', $data)->render();
$views['content'] = View::forge('employee/show', $data)->render();
return View::forge('layout', $views, false)->render();
}
}
fuel/app/views/layout.php
<html>
<head>
<?php echo $head; ?>
</head>
<body>
<?php echo $content; ?>
</body>
</html>
fuel/app/views/head.php
<title> <?php echo $title; ?> </title>
fuel/app/views/employee/show.php
Hello, <?php echo $name; ?>. Your job is, <?php echo $job; ?>.
请求 URL http://localhost:8080/employee/nestedview 并检查源视图后，它会给出以下代码。
<html>
<head>
<title>Home</title>
</head>
<body>
Hello, Jon.
Your job is, Designer.
</body>
</html>
模板控制器
FuelPHP 提供了一个控制器，Controller_Template，它具有内置布局概念。布局概念是使用 Controller 的 before() 和 after() 方法实现的。要使用模板控制器，我们需要使用 Controller_Template 而不是 Controller 来扩展控制器。使用 after() / before() 方法时，我们需要调用 parent::before 和 parent::after，否则模板会中断。
<?php
class Controller_Test extends Controller_Template {
public function before() {
parent::before();
// do stuff
}
public function after($response) {
$response = parent::after($response);
// do stuff
return $response;
}
}
template.php
这是 Fuel 中的默认模板文件。模板文件用于调用 JS、CSS、HTML 和调用视图部分。它位于 fuel/app/views/。模板用于将您的视图包装在带有页眉、页脚、侧边栏等的布局中。我们可以使用操作方法中的 $template 变量更改默认模板，如下所示。
fuel/app/classes/controller/test.php
<?php
class Controller_Test extends Controller_Template {
public $template = 'template_test';
public function action_index() {
$this->template->title = 'Example Page';
$this->template->content = View::forge('test/index');
}
}
fuel/app/views/template_test.php
<!DOCTYPE html>
<html>
<head>
<meta charset = "utf-8">
<title><?php echo $title; ?></title>
<?php echo Asset::css('bootstrap.css'); ?>
</head>
<body>
<div>
<?php echo $content; ?>
</div>
</body>
</html>
fuel/app/views/test/index.php
<h3>My Test page</h3>
现在，请求 URL http://localhost:8080/test 并产生以下结果。
结果
<!DOCTYPE html>
<html>
<head>
<meta charset = "utf-8">
<title>Example Page</title>
<link type = "text/css" rel = "stylesheet"
href = "http://localhost:8080/assets/css/bootstrap.css?1464964766" />
</head>
<body>
<div>
<h3>My Test page</h3>
</div>
</body>
</html>
生成视图页面
您可以使用 Fuel 的 Oil 控制台生成视图页面。以下是基本语法。
oil g controller <controller-name> <page1> <page2> ..
要生成带有主页和登录页面的管理控制器，请使用以下命令。
oil g controller admin home login
结果
创建视图:/path/to/app/fuel/app/views/admin/home.php 创建视图:/path/to/app/fuel/app/views/admin/login.php 创建控制器:/path/to/app/fuel/app/classes/controller/admin.php
FuelPHP - Presenters
FuelPHP 在控制器之后提供了一个附加层来生成视图。一旦控制器处理完输入并完成业务逻辑，它就会将控制权发送给 Presenter，后者负责处理额外的逻辑，例如从数据库获取数据、设置视图数据等，然后调用 View 对象。
我们可以使用 Presenter 类呈现视图，如下所示 −
fuel/app/classes/controller/employee.php
public Controller_Employee extends Controller {
public function action_welcome() {
return Presenter::forge('employee/hello');
}
}
Presenter 类的默认位置是 fuel/app/classes/presenter/。以下是一个简单的示例。
fuel/app/classes/presenter/employee/hello.php
<?php
class Presenter_Employee_Hello extends Presenter {
public function view() {
$this->name = Request::active()->param('name', 'World');
}
}
上述演示器类的视图文件解析为相对于 views 文件夹的 employee/hello.php，这与指定一致。
fuel/app/views/employee/hello.php
<h3>Hi, <?php echo $name; ?></h3>
最后，更改路由以匹配员工的欢迎操作，如下所示 −
fuel/app/config/routes.php
'employee/hello(/:name)?' => array('employee/welcome', 'name' => 'hello'),
现在，请求 URL，http://localhost:8080/employee/hello/Jon 呈现以下结果。
结果
FuelPHP - 模型和数据库
模型在 FuelPHP Web 框架中起着重要作用。它代表应用程序的业务实体。它们要么由客户提供，要么从后端数据库获取，根据业务规则进行操作并持久保存回数据库。在本章中，我们将了解模型以及它们如何与后端系统交互。
创建模型
在 FuelPHP 中，模型只是扩展内置 Model 类的普通 PHP 类。默认情况下，模型可能以 Model_ 为前缀，类似于控制器，应放置在 fuel/app/classes/model/ 文件夹中。让我们创建一个基本的员工模型并在继续进行时对其进行扩展。
fuel/app/classes/model/employee.php
<?php
namespace Model;
class Model_Employee extends \Model {
public static function fetchAll() {
// 从数据库获取员工的代码
}
}
访问模型
一旦定义了模型，就可以在任何控制器中自由使用它，只需将其包含在控制器中即可，如下所示。
use \Model\Employee;
class Controller_Employee extends Controller {
public function action_index() {
$employees = Employee::fetchAll();
}
}
数据库概述
FuelPHP 提供自己的数据库抽象层来从数据库获取数据。它提供基本和高级的基于 ORM 的工具。基本工具包由基于 DB、DBUtil 和 Query_Builer 的类组成。高级工具包是 Orm。Orm 工具包源自基本工具包，并捆绑为单独的包。
数据库配置
FuelPHP 将数据库设置与主配置文件分开，文件为 fuel/app/config/db.php。它支持每个环境的单独设置。目前，FuelPHP 支持 MySQL、MySQLi 和 PDO 驱动程序。示例设置如下 −
<?php
return array (
'development' => array (
'type' => 'mysqli',
'connection' => array (
'hostname' => 'localhost',
'port' => '3306',
'database' => 'tutorialspoint_fueldb',
'username' => 'root',
'password' => 'password',
'persistent' => false,
'compress' => false,
),
'identifier' => '`',
'table_prefix' => '',
'charset' => 'utf8',
'enable_cache' => true,
'profiling' => false,
'readonly' => false,
),
)
基于 DB 的工具包
DB 类是从应用程序访问数据库的最简单选项。它提供构建数据库查询、针对目标数据库执行查询以及最终获取结果的选项。DB 类与以下类交互并提供全面的数据库 API。
Database_Connection − 与数据库交互的单例和主类
Database_Query − 基础，执行 SQL 查询和获取结果的具体类
Database_Query_Builder − 基础，构建 SQL 查询的抽象类
Database_Query_Builder_Join −用于构建 SQL 连接的类
Database_Query_Builder_Where − 用于构建 SQL 查询条件的抽象类
Database_Query_Builder_Select − 用于构建 SQL 选择查询的具体类
Database_Query_Builder_Insert − 用于构建 SQL 插入查询的抽象类
Database_Query_Builder_Update − 用于构建 SQL 更新查询的抽象类
Database_Query_Builder_Delete −抽象类构建 SQL 删除查询
下图描述了类与类提供的方法之间的关系。
DB API
让我们在本节中了解 DB 类中可用的最重要的方法。
实例
用途 − 创建并返回新的 Database_Connection 实例。
参数 −
$db −配置文件中定义的数据库连接名称，可选。
返回 − 返回 Database_Connection 对象
例如，
$db = DB::instance();
$db = DB::instance('test');
query
用途 − 准备提供的 SQL 语句并返回 Database_Query 对象，该对象可用于插入、更新、删除或从数据库获取数据。
参数 −
$query − SQL 语句，可能包含占位符；
$type − SQL 类型，可选(DB::SELECT、DB::INSERT、DB::UPDATE 和 DB::DELETE)
返回 −返回 Database_Query 对象
例如，
$query = DB::query('SELECT * FROM 'employees'');
last_query
用途 − 获取最后执行的查询
参数 − 无
返回 − 返回最后执行的查询
例如，
$employees = DB::Select('Select * from 'employee'');
$sql = DB::last_query();
select
用途 − 生成查询的选择部分
参数 −
$columns − 数据库列名列表
返回 − 返回 Database_Query_Builder_Select 对象
例如，
$query = DB::select(); // 选择 *
$query = DB::select('id', 'name'); // 选择 id、name
select_array (DB)
它与 select 类似，只是我们可以将列作为数组发送。
$query = DB::select_array(array('id', 'name')); // 选择 id、name
insert
用途 −生成查询的插入部分
参数 −
$table_name − 数据库表的名称；
$columns − 表列的数组
返回 − 返回 Database_Query_Builder_Insert 对象
例如，
$query = DB::insert('employee'); // 插入到 employee 中
$query = DB::insert('employee', array('id', 'name')); // 插入员工(id，姓名)
update
用途 − 生成查询的更新部分
参数 −
$table_name − 数据库表的名称
返回 − 返回 Database_Query_Builder_Update 对象
例如，
$query = DB::update('employee'); // 更新 `employee`
delete
用途 − 生成查询的删除部分
参数 −
$table_name −数据库表的名称
返回 − 返回 Database_Query_Builder_Delete 对象
例如
$query = DB::delete('employee'); // 从"employee"中删除
Query API
Database_Query 提供了一个选项来设置数据库连接、执行查询并将结果作为关联数组或对象获取。让我们看看 Database_Query 类提供的方法。
set_connection
用途 − 设置要执行查询的数据库(数据库连接详细信息)
参数 − $db - 数据库连接名称
返回 − 返回 Database_Query 对象
例如，
$query = DB::query('DELETE * FROM employee', DB::DELETE);
$query->set_connection('2nd-db');
param
用途 − 设置 Query 对象中定义的参数的值
参数 −
$param − 参数名称;
$value − 参数的值
返回 − 返回 Database_Query 对象
例如，
// set some variables
$table = 'employee';
$id = 1;
$name = 'Jon';
// don't use
$query = DB::query('SELECT * FROM '.$table.'. WHERE id = '.$id.' AND name = "'.$name.'"');
// but use
$query = DB::query('SELECT * FROM :tablename WHERE id = :id AND name = :name');
$query->param('tablename', 'employee');
$query->param('id', $id);
$query->param('name', $name);
类似方法
parameters 是一个类似的对象，只不过它提供了一次提供多个值的选项。
$query->parameters (array( 'tablename' => $table, 'id' => $id, 'name' => $name });
bind
用途 − 将变量设置为 Query 对象中定义的参数
参数 −
$param − 参数名称
$var − 要将参数绑定到的变量
返回 − 返回 Database_Query 对象
例如，
// 绑定查询参数
$table = 'employee';
$query = DB::query('DELETE * FROM :tablename', DB::DELETE);
$query->bind('tablename', $table);
// 更新变量
$table = 'employee_salary';
// DELETE * FROM `employee_salary`;
$sql = $query->compile();
compile
用途 − 将定义的查询对象编译为 SQL 查询
参数 −
$db − 连接字符串，可选
返回 −
例如，
// 为查询参数分配一个值
$table = 'employee';
$query = DB::query('DELETE * FROM :tablename', DB::DELETE);
$query->param('tablename', $table);
// 编译查询，返回:DELETE * FROM employee
$sql = $query->compile();
execute
用途 − 执行Query对象中定义的查询并返回结果
参数 −
$db − 数据库连接名称
返回 − 返回结果
例如，
// 为查询参数分配一个值
$table = 'employee';
$query = DB::query('DELETE * FROM :tablename', DB::DELETE);
$query->param('tablename', $table);
// 执行查询
$query->execute();
as_assoc
用途 − 将返回类型设置为关联数组而不是对象
参数 − 无
返回 − 返回当前对象
例如，
$query = DB::query('SELECT * FROM employee', DB::SELECT);
$result = $query->as_assoc()->execute();
foreach ($result as $row) {
echo $row['id'];
}
as_object
用途 − 将返回类型设置为对象而不是关联数组
参数 − 无
返回 − 返回当前对象
例如，
$query = DB::query('SELECT * FROM employee', DB::SELECT);
$result = $query->as_object()->execute();
foreach ($result as $row) {
echo $row->id;
}
// 让 ORM 模型对象返回
$result = $query->as_object('Model_Employee')->execute();
查询生成器 API
基于查询生成器 (Query_Builder) 的类提供动态构建 SQL 查询的选项。它有四个类，每个类用于选择 (Query_Builder_Select)、插入 (Query_Builder_Insert)、更新 (Query_Builder_Update) 和删除 (Query_Builder_Delete) 查询。这些类派生自 Query_Builder_Where 类(生成条件的选项)，而该类本身又派生自 Query_Builder，是所有类的基础。
让我们看看 Query_Builder 类提供的方法。
select
用途 − 生成选择查询的列。
参数 −
$columns − 列的列表，可选
返回 −返回当前实例
例如，
$query = DB::select('name') // 选择 `name`
$query = DB::select(array('first_name', 'name')) // 选择 `first_name` 作为 `name`
from
用途 − 生成选择查询的表详细信息
参数 −
$tables − 表列表
返回 − 返回当前实例
例如，
$query = DB::select('name')->from('employee') // 从 `employee` 中选择 `name`
where
用途 − 生成 select、insert 和 update 查询的条件
参数 −
$column − 列名或数组 ($column, $alias);
$op − 逻辑运算符，=、!=、IN、BETWEEN 和 LIKE，可选；
$value − 列值
返回 −返回当前实例
例如，
$query = DB::select('name')->from('employee')
$query = $query->where('name', '=', 'Jon');
// select `name` from `employee` where `name` = `Jon`;
类似方法
类似方法是 where_open()、and_where_open()、or_where_open()、where_close()、and_where_close()、or_where_close()。它们与 where() 方法类似，只是它们在条件周围添加了额外的关键字和括号。以下是示例代码。
$query = DB::select('*')->from('employee');
$query->where('email', 'like', '%@gmail.com');
$query->or_where_open();
$query->where('name', 'Jon');
$query->and_where('surname', 'Peter');
$query->or_where_close();
// SELECT * FROM `employee` WHERE `email` LIKE "%gmail.com" OR
(`name` = "Jon" AND `surname` = "Peter")
join
用途 − 生成选择查询的表连接
参数 −
$table − 表名或数组 ($table, $alias);
$type − 连接类型 (LEFT、RIGHT、INNER 等)
返回 −返回当前实例
示例
$query = DB::select('name')->from('employee')->join('employee_salary')
// 从 `employee` 中选择 `name` JOIN `employee_salary`
on
用途 − 生成选择查询中的连接条件
参数 −
$c1 − 表名或数组中带有别名的表名；
$op − 逻辑运算符；
$c2 − 表名或数组中带有别名的表名
返回 −返回当前实例
例如，
$query = DB::select('name')->from('employee')->join('employee_salary')
$query = $query->on('employee.employee_id', '=', 'employee_salary.employee_id')
// select `name` from `employee` JOIN `employee_salary` on
// `employee.employee_id` = `employee_salary.employee_id`
类似方法
相关方法是 and_on() 和 or_on()。它们与 on() 类似，只是它们在连接周围添加了额外的关键字和括号。
group_by
用途 − 生成分组查询
参数 − $columns − 用于对结果进行分组的列名称
返回 − 返回当前实例
例如，
$query = DB::select('name')->from('employee')
$query = $query->group_by('name');
// select `name` from `employee` group by `name`
having
用途 − 生成 SQL 查询的 group by 条件
参数 − $column − 列名或数组 ($column, $alias ); $op − 逻辑运算符，=, !=, IN, BETWEEN 和 LIKE，可选； $value − 列值
返回 − 返回当前实例
示例
$query = DB::select('name')->from('employee')
$query = $query->group_by('name');
$query = $query->having('name', '!=', 'Jon');
// 从 `employee` 组中按 `name` 选择 `name` having `name` != `Jon`
类似方法
类似方法是 having_open()、and_having_open()、or_having_open()、having_close()、and_having_close() 和 or_having_close()。它们与 having() 方法类似，只是在条件周围添加了额外的关键字和括号。
reset
用途 − 重置查询
参数 − 无
返回 −返回当前实例
例如，
$query = DB::select('name')->from('employee')
$query->reset()
$query = DB::select('name')->from('employee_salary')
// 从 `employee_salary` 中选择 `name`
DBUtil 类
DBUtil 类提供了管理和执行常规数据库操作的选项。一些重要方法如下 −
- set_connection - 设置默认连接
DBUtil::set_connection('new_database');
- create_database - 创建数据库。
DBUtil::create_database('my_database');
- drop_database - 删除数据库。
DBUtil::drop_database('my_database');
- table_exists - 检查给定表是否存在。
if(DBUtil::table_exists('my_table')) {
// 表存在
} else {
// 表不存在，创建它!
}
- drop_table - 删除一个表。
DBUtil::drop_table('my_table');
- create_table - 创建一个表。
\DBUtil::create_table (
'users',
array (
'id' => array('type' => 'int', 'auto_increment' => true),
'name' => array('type' => 'text'),
),
);
Orm 工具包
FuelPHP 使用基于流行的 Active record 模式 的 ORM 概念提供高级数据库层。该工具包包含在应用程序中，但默认情况下未配置。它捆绑为一个包，包名称为 orm。我们可以在主配置文件 fuel/app/config/config.php 中添加以下配置来加载 orm 工具包。
'always_load' => array (
'packages' => array (
'orm',
),
),
创建模型
Orm 提供了基础模型类 Orm\Model。我们需要使用 orm 模型扩展我们的模型才能使用 ORM 功能。以下是示例代码。
class Model_Employee extends Orm\Model {}
配置
Orm 提供了一组设置来配置模型以使用 ORM 功能。它们如下 −
connection − 在模型中设置静态 _connection 属性以指定连接名称。
class Model_Employee extends Orm\Model {
protected static $_connection = "production";
}
表名 −在模型中设置一个静态的_table_name属性，指定后端表的表名。
class Model_Employee extends Orm\Model {
protected static $_table_name = 'employee';
}
primary key − 在模型中设置一个静态的_primary_key属性，指定后端表的主键。
class Model_Employee extends Orm\Model {
protected static $_primary_key = array('id');
}
Columns − 在模型中设置一个静态的_properties属性，指定后端表的列。支持data_type、label、validation、form elememts等。
class Model_Employee extends Orm\Model {
protected static $_properties = array (
'id',
'name' => array (
'data_type' => 'varchar',
'label' => 'Employee Name',
'validation' => array (
'required',
'min_length' => array(3),
'max_length' > array(80)
),
'form' => array (
'type' => 'text'
),
),
'age' => array (
'data_type' => 'int',
'label' => 'Employee Age',
'validation' => array (
'required',
),
'form' => array (
'type' => 'text'
),
),
);
}
条件 − 设置静态 _conditions 属性来设置条件和排序选项。
class Model_Employee extends Orm\Model {
protected static $_conditions = array (
'order_by' => array('id' => 'desc'),
'where' => array (
array('is_active', > true),
),
);
}
Observers(观察者) − Orm 提供基于观察者的事件系统，用于向特定事件添加行为。要添加行为，首先在模型中设置 _observers 属性。然后，将行为定义为类，并将其与事件一起设置在 _observers 属性中。如果未指定事件，则将为所有事件调用该行为。我们也可以指定多个行为。
class Model_Employee {
protected static $_observers = array (
'example', // 将针对所有事件调用 Observer_Example 类
'Orm\Observer_CreatedOn' => array (
'events' => array('before_insert'),
// 只会在 before_insert 事件中调用 Orm\Observer_CreatedOn
)
);
}
Create
一旦我们配置了模型，我们就可以立即开始使用这些方法。 Orm 提供了一个 save 方法来将对象保存到数据库中。我们可以使用配置的属性设置数据，如下所示 −
// 选项 1
$new = new Model_Employee();
$new->name = 'Jon';
$new->save();
// 选项 2，使用 forge 而不是 new
$new = Model_Employee::forge();
$new->name = 'Jon';
$new->save();
// 选项 3，使用数组作为属性
$props = array('name' => 'Jon');
$new = Model_Employee::forge($props);
$new>save();
Read
Orm 提供了一种方法 find，用于从数据库中获取数据并绑定到对象中。 find 方法的工作方式取决于输入参数。 让我们看看不同的选项 −
按主键 − 指定主键通过匹配配置表的主键返回记录。
$employee = Model_Employee::find(1);
第一条/最后一条记录 − 指定'first'或'last'将分别获取第一条记录或最后一条记录。 我们也可以传递 order by 选项。
$entry = Model_Employee::find('first');
$entry = Model_Article::find('last', array('order_by' => 'id'));
全部 − 指定"全部"将从配置的表中获取所有记录。我们可以指定按选项排序以及条件。
$entry = Model_Employee::find('all');
$entry = Model_Article::find ('all', array (
'where' => array (
array ('name', 'Jon'),
),
'order_by' => array ('id' => 'desc'),
));
我们可以使用基本数据库工具包的查询 API 以及模型来实现高级搜索选项，如下所示。
$query = Model_Employee::query()->where('category_id', 1)->order_by('date', 'desc');
$number_of_employees = $query->count();
$latest_employee = $query->max('id');
$young_employee = $query->min('age');
$newest_employee = $query->get_one();
$employees = $query->limit(15)->get();
Update
更新模型与创建模型相同，不同之处在于，不是创建新模型，而是使用 find 方法获取要更新的模型，更新属性，然后调用 save 方法，如下所示。
$entry = Model_Employee:find(4); $entry->name = 'Peter'; $entry->save();
Delete
Orm 提供了一个 delete 方法来删除模型。只需获取对象并调用 delete 方法即可。
$entry = Model_Employee:find(4); $entry->delete();
工作示例
让我们在本章中创建一个工作示例来了解模型和数据库。
创建数据库
使用以下命令在 MySQL 服务器中创建一个新数据库。
create database tutorialspoint_fueldb
然后，使用以下命令在数据库中创建一个表。
create table employee(id int primary key, name varchar(20), age int not null);
配置数据库
让我们使用数据库配置文件 *fuel/app/config/db.php 配置数据库。添加以下更改以连接 MySQL 服务器。
<?php
return array (
'development' => array (
'type' => 'mysqli',
'connection' => array (
'hostname' => 'localhost',
'port' => '3306',
'database' => 'tutorialspoint_fueldb',
'username' => 'root',
'password' => 'pass',
'persistent' => false,
'compress' => false,
),
'identifier' => '`',
'table_prefix' => '',
'charset' => 'utf8',
'enable_cache' => true,
'profiling' => false,
'readonly' => false,
),
'production' => array (
'type' => 'mysqli',
'connection' => array (
'hostname' => 'localhost',
'port' => '3306',
'database' => 'tutorialspoint_fueldb',
'username' => 'root',
'password' => 'pass',
'persistent' => false,
'compress' => false,
),
'identifier' => '`',
'table_prefix' => '',
'charset' => 'utf8',
'enable_cache' => true,
'profiling' => false,
'readonly' => false,
),
);
包含 ORM 包
更新主配置文件 fuel/app/config/config.php，通过添加以下配置来包含 ORM 包。
'always_load' => array (
'packages' => array (
'orm'
),
),
现在，您的应用程序中已启用 ORM
创建 Employee 模型
在模型文件夹 "fuel/app/classes/model" 下创建一个新模型 Employee。其定义如下。
Employee.php
<?php
class Model_Employee extends Orm\Model {
protected static $_connection = 'production';
protected static $_table_name = 'employee';
protected static $_primary_key = array('id');
protected static $_properties = array (
'id',
'name' => array (
'data_type' => 'varchar',
'label' => 'Employee Name',
'form' => array (
'type' => 'text'
),
),
'age' => array (
'data_type' => 'int',
'label' => 'Employee Age',
'form' => array (
'type' => 'text'
),
),
);
}
创建操作
在位于 fuel/app/classes/controller/employee.php 的员工控制器中创建新操作 action_model，如下所示。
class Controller_Employee extends Controller {
public function action_model() {
// 基于 db 的 sql 命令删除所有员工
$query = db::query('delete from `employee`');
$query->execute('production');
// 基于 orm 的查询添加新员工
$model = new model_employee();
$model->name = "john";
$model->age = 25;
$model->save();
$model = new model_employee();
$model->name = "peter";
$model->age = 20;
$model->save();
// 基于 orm 的查询获取所有员工数据
$data = array();
$data['emps'] = model_employee::find('all');
return response::forge(view::forge('employee/model', $data));
}
}
创建视图
现在，创建一个位于"fuel/app/views/employee"的视图文件model.php。在文件中添加以下更改。
<ul>
<?php
foreach($emps as $emp) {
?>
<li><?php echo $emp['name']; ?></li>
<?php
}
?>
</ul>
现在，请求 URL，http://localhost:8080/employee/model，它将产生以下结果。
结果
FuelPHP - 表单编程
FuelPHP 提供三个类，Form Fieldset，和Input，用于执行表单编程。
Form 类提供了一个选项来创建所有 HTML 表单元素。
Fieldset 类提供了一个选项来通过更高级的方法创建 html 元素，集成模型和验证。
Input 类提供了一个选项来解析通过 html 表单以及 http 提交的数据参数、服务器变量和用户代理。
在本章中，让我们学习 FuelPHP 中的表单编程。
表单
如前所述，Form 类提供了创建 html 表单元素的方法，重要方法如下 −
open()
open() 用于创建新表单。它提供以下两个参数 −
$attributes − 表单标签的属性作为数组或只是操作 URL 作为字符串。
$hidden − 隐藏字段名称及其值的数组。
echo Form::open('/employee/add');
echo Form::open(array('action' => '/employee/add', 'method' => 'post'));
close()
close() 只是关闭表单。
echo Form::close();
input()
input() 创建 html 输入元素。它具有以下三个参数，
$field − 输入元素的名称
$value − 输入元素的值
$attributes − 输入元素的属性作为数组
echo Form::input('name', 'jon', array('style' => 'border: 20px;'));
label 元素
label 创建 html label 元素。它具有以下三个参数，
$label − 要显示的标签
$id − 关联的表单元素 id
$attributes − 标签元素的属性作为数组
echo Form::label('Employee Name', 'employee_name');
hidden
hidden 与输入法类似，不同之处在于它将输入元素的类型设置为 hidden。
password
password 与输入法类似，不同之处在于它将输入元素的类型设置为 password。
radio
radio 与输入法类似，不同之处在于它将输入元素的类型设置为 radio。它有以下四个参数，
$field − 输入元素的名称
$value − 输入元素的值
$checked −该项目是否被选中(true / false)
$attributes − 输入元素的属性作为数组
echo Form::label('Male', 'gender');
echo Form::radio('gender', 'Male', true);
echo Form::label('Female', 'gender');
echo Form::radio('gender', 'Female');
checkbox
checkbox 与 input 方法类似，只不过它将输入元素的类型设置为复选框。它有以下四个参数，
$field − 输入元素的名称
$value − 输入元素的值
$checked − 该项目是否被选中(true / false)
$attributes − 输入元素的属性作为数组
echo Form::label('Male', 'gender');
echo Form::checkbox('gender', 'Male', true);
echo Form::label('Female', 'gender');
echo Form::checkbox('gender', 'Female');
file
file 与输入法类似，不同之处在于它将输入元素的类型设置为文件。
textarea
textarea 创建 html textarea 元素。它具有以下三个参数，
$field − textarea 元素的名称
$value − textarea 元素的值
$attributes − textarea 元素的属性作为数组
echo Form::textarea ('description', 'original data (value)', array ('rows' => 6,
'cols' => 8));
select
select 创建一个 HTML select 元素。它具有以下四个参数 −
$field − select 元素的名称
$values − 初始选择值
$options − 选项作为数组。可以使用嵌套数组对选项进行分组
$attributes − 输入元素的属性作为数组
echo Form::select (
'country',
'none',
array (
'none' => 'None',
'asia' => array (
'in' > 'India',
'cn' => 'China'
),
'us' => 'United States'
)
);
submit
submit 与输入法类似，只不过它设置了要提交的输入元素的类型。
button
button 创建 html 按钮元素。它具有以下三个参数，
$field − 按钮元素的名称
$value − 按钮元素的值
$attributes − 按钮元素的属性作为数组
echo Form::button('emp_submit', 'Submit');
reset
reset 与输入法类似，不同之处在于它将输入元素的类型设置为重置。
fieldset_open
fieldset_open 创建 html 字段集和图例元素。它具有以下两个参数 −
attributes − fieldset 元素的属性作为数组
legend − 要创建的图例的名称
// returns <fieldset class = "example-class" id = "example-id"> <legend> Custom Legend </legend> echo Form::fieldset_open (array ( 'class' => 'example-class', 'id' => 'exampleid', 'legend' => 'Custom Legend' ));
fieldset_close
fieldset_close 创建 HTML 字段集关闭标记。
// 返回 </fieldset> echo Form::fieldset_close();
Input 类
Input 类提供读取所有请求数据以及表单详细信息的方法。一些重要方法如下 −
uri
uri 返回请求的当前 URI
// 请求:http://localhost:8080/employee/welcome echo Input::uri(); // 返回 /employee/welcome
method
method 返回请求中使用的 HTTP 方法
echo Input::method() // "POST"
get
get 允许读取 $_GET 变量。它具有以下两个参数，
$index − $_GET 数组的索引
$default − 如果未找到索引，则为默认值。
echo Input::get('age', '20'); // 返回 $_GET['age']
post
post 允许读取 $_POST 变量。它具有以下两个参数，
$index − $_POST 数组的索引
$default − 如果未找到索引，则为默认值
echo Input::get('age', '20'); // 返回 $_POST['age']
param
param 允许从 $_GET、$_POST、$_PUT 或 $_DELETE 变量中获取项目。它具有以下两个参数，
$index − 数组的索引
$default − 如果未找到索引，则为默认值
如果没有指定参数，它将返回所有项目。
echo Input::param('age', '20'); // 返回 $_POST['age']
file
file 允许读取 $_FILE 变量。它具有以下两个参数，
$index − $_POST 数组的索引
$default −如果未找到索引，则为默认值
echo Input::file();
is_ajax
如果请求是通过 AJAX 发出的，则
is_ajax 返回 true。
echo Input::is_ajax() // 返回 false
protocol
protocol 返回请求中使用的 HTTP 协议。
echo Input::protocol() // 返回"HTTP"
ip
ip 返回发出请求的 IP 地址。
echo Input::ip() // 返回"84.45.34.24"(公共 IP 地址)
real_ip
real_ip 尝试返回实际发出请求的 IP 地址(如果客户端位于代理后面)。
echo Input::real_ip() // 返回"10.76.12.1"(本地私有 IP 地址)
server
server 允许读取 $_SERVER 变量。它具有以下两个参数，
$index − $_POST 数组的索引
$default − 如果未找到索引，则为默认值。
echo Input::server('HTTP_HOST'); // 返回 localhost:8080
referrer
referrer 从 $_SERVER 变量返回 referrer。这是获取当前请求的 http referrer 的快捷方法。
user_agent
user_agent 从 $_SERVER 变量返回用户代理。这是获取当前请求的 http 用户代理的快捷方法。
query_string
query_string 从 $_SERVER 变量返回查询字符串。这是获取当前请求的查询字符串的快捷方法。
headers
headers 返回特定或所有标头。它具有以下两个参数 −
$index − HTTP 标头的名称
$default − 如果未找到索引，则为默认值。
echo Input::headers('Content-Type'); // 返回"text/html"
extension
extension 返回当前请求的 URI 扩展。
// 示例 URL:http://localhost/test/ echo Input::extension(); // NULL // 示例 URL:http://localhost/test.html echo Input::extension(); // 'html'
工作示例
让我们使用 Form 和 Input 类创建一个简单的表单来添加新员工。
创建表单
在员工控制器中创建新操作 get_add，如下所示。
public function get_add() {
return Response::forge(View::forge('employee/add'));
}
现在，为操作添加视图 fuel/app/views/employee/add.php 如下所示。
<!DOCTYPE html>
<html lang = "en">
<head>
<title>Employee :: add page</title>
<meta charset = "utf-8">
<meta name = "viewport" content = "width = device-width, initial-scale = 1">
<?php echo Asset::css('bootstrap.css'); ?>
</head>
<body>
<div class = "container">
<?php
echo Form::open(array('action' => 'employee/add', 'method' => 'post'));
?>
<div class = "form-group">
<?php
echo Form::label('Employee name:', 'name');
echo Form::input('name', '', array('class' => 'form-control'));
?>
</div>
<div class = "form-group">
<?php
echo Form::label('Employee age:', 'age');
echo Form::input('age', '', array('class' => 'form-control'));
?>
</div>
<?php echo Form::button('frmbutton', 'Submit', array(
'class' => 'btn btn-default'));
?>
<?php
echo Form::close();
?>
</div>
</body>
</html>
这里，我们使用了 bootstrap 来设计表单。FuelPHP 为 bootstrap 组件提供了全面支持。现在，请求页面 http://localhost:8080/employee/add 将显示以下表单。
处理表单
创建新操作 post_add 来处理表单，并将用户输入的员工数据添加到员工控制器中的数据库中，如下所示。
public function post_add() {
$name = Input::post('name');
$age = Input::post('age');
$model = new model_employee();
$model->name = $name;
$model->age = $age;
$model->save();
Response::redirect('employee/list');
}
在这里，我们被重定向到员工列表页面，一旦用户输入的数据被保存到数据库中。接下来，我们将创建员工列表页面。
列出员工
创建新操作 action_list 以列出数据库中的员工，如下所示。
public function action_list() {
$data = array();
$data['emps'] = model_employee::find('all');
return Response::forge(view::forge('employee/list', $data));
}
为上述操作创建新视图 fuel/app/views/employee/list，如下所示。
<ul>
<?php
foreach($emps as $emp) {
?>
<li><?php echo $emp['name']; ?></li>
<?php
}
?>
</ul>
检查表单
现在，请求 URL，http://localhost:8080/employee/add，输入一些员工数据(如以下屏幕截图所示)，然后提交表单。
然后，它会显示数据库中可用的所有员工(包括新添加的员工)，如下所示 −
FuelPHP - 验证
验证是 Web 应用程序中最常见且重复性最高的任务之一。用户在表单中输入所需数据并提交。然后，Web 应用程序需要在处理数据之前验证数据。例如，用户输入员工数据，post_action 需要在将其保存到数据库之前进行验证。FuelPHP 为此提供了一个非常简单的类 Validation。
在 FuelPHP 中，验证的概念非常简单，它通过 Validation 类提供各种方法来正确验证表单。以下是验证的工作流程，
步骤 1 − 使用 forge 方法创建新的 Validation 对象。
$val = Validation::forge();
步骤 2 − 使用 add 方法添加需要验证的字段。
$val->add('name', 'Employee name');
步骤 3 −使用 add_rule 方法设置添加字段的验证规则。
$val->add('name', 'Employee name')->add_rule('required');
$val->add('age', 'Employee age')->add_rule('required')
->add_rule('numeric_min', 20)
->add_rule('numeric_max', 30);
步骤 4 − 调用 run 方法来验证数据。
// 只对帖子运行验证
if ($val->run()) {
// success
} else {
// falier
}
步骤 5 − 使用validated和error分别获取有效和无效字段。
$vars = $val->validated(); $vars = $val->error();
规则
FuelPHP包含很多验证规则，也提供了创建新规则的选项。Validation类支持的规则如下，
required − 需要输入的值
required_with − 将另一个字段设置为伴随字段。如果设置了该字段，则伴随字段也需要设置
match_value −设置要与字段值匹配的值
match_pattern − 将要与字段值匹配的值设置为正则表达式
match_field − 将另一个字段的值设置为要与字段值匹配的值
match_collection − 将要与字段值匹配的值设置为集合
min_length − 设置字段值的最小长度
max_length − 设置字段值的最大长度
exact_length −设置字段值的精确长度
valid_date − 将字段的值设置为有效日期
valid_email − 将字段的值设置为有效的电子邮件
valid_emails − 将字段的值设置为有效的电子邮件，以逗号分隔
valid_url − 将字段的值设置为有效的 URL
valid_ip − 将字段的值设置为有效的 IP
numeric_min − 设置字段值的最小值
numeric_max −设置字段值的最大值
numeric_between − 设置字段值的最小值和最大值
valid_string −类似于正则表达式，但更简单
$val->add('username', '用户名')->add_rule('valid_string', array('alpha, dots');
这里，alpha 表示字母，dot 表示 (.)。有效字符串只有包含字母和 (.) 的字符串。其他选项包括大写、小写、特殊字符、数字、空格等。
工作示例
我们可以更新添加员工功能以包含验证。只需按如下方式更新员工控制器的 post_add 方法即可。
public function post_add() {
$val = Validation::forge();
$val->add('name', 'Employee name')->add_rule('required');
$val->add('age', 'Employee age')->add_rule('required')
->add_rule('numeric_min', 20)
->add_rule('numeric_max', 30);
if ($val->run()) {
$name = Input::post('name');
$age = Input::post('age');
$model = new model_employee();
$model->name = $name;
$model->age = $age;
$model->save();
Response::redirect('employee/list');
} else {
Response::redirect('employee/add');
}
}
在这里，我们指定了 name 和 age 作为必填字段。age 需要在 20 到 30 之间。如果两个规则都有效，则将保存员工数据并重定向到员工列表页面。否则，员工数据将被拒绝并重定向到添加员工页面。
FuelPHP - 高级表单编程
FuelPHP 通过 Fieldset 和 Fieldset_Field 类提供高级表单编程。Fieldset 提供了一种面向对象的方式来创建表单。它完全支持模型。它还内置了对客户端和服务器端验证的支持。要创建一个完整的表单，只需创建一个具有适当表单和验证设置的模型即可。让我们在本章中了解 Fieldset 类以及如何使用它创建表单。
Fieldset
Fieldset 是 Fieldset_Field 对象的集合。 Fieldset_Field 定义表单的单独条目，例如 firstname、lastname 等，以及验证。Fieldset 类具有添加/编辑/删除字段的方法。它具有识别模型中定义的字段并从给定模型创建字段的选项。Fieldset 在后台使用 Form 和 Validation 类来完成实际工作。让我们看看 Fieldset 类的一些重要方法。
forge
forge 创建一个新的 Fieldset 实例。它具有以下两个参数 −
$name − 字段集的标识符
$config − 配置数组。可能的选项是 validation_instance 和 form_instance。 validation_instance 可以有 Validation 对象，而 form_instance 可以有 Form 对象。
$employee_form = Fieldset::forge('employee');
instance
instance 通过标识符返回先前创建的 Fieldset 实例。
$employee_form = Fieldset::instance('employee');
get_name
获取 fieldset 实例的标识符。
$employee_form = Fieldset::forge('employee');
$name = $employee_form->get_name();
add
add 创建一个新的 Fieldset_Field 实例并将其添加到当前字段集。它包含以下四个参数，
$name − 字段的名称
$label − 字段的标签
$attributes − HTML 标签属性
$rules − 验证规则
$employee_field = $employee_form-> add (
'employee_lastname',
'Lastname',
array ('class' => 'pretty_input')
);
// 使用验证规则
$employee_form->add (
'email', 'E-mail',
array('type' => 'email', 'class' => 'pretty_input'),
array('required', 'valid_email')
);
add_before
add_before 与 add 类似，但它有一个额外的参数来指定将在其前添加新创建的字段的字段。
$employee_form->add_before (
'employee_firstname',
'Firstname',
array ('class' => 'pretty_input'),
array(),
'employee_lastname'
);
delete
delete 从字段集中删除指定字段。
$employee_form->delete('employee_firstname');
field
field 从字段集中获取所有字段或指定字段。
$fields = $employee_form->field();
$lastname_field = $employee_form->field('employee_lastname');
build
build 是 $this->form()->build() 的别名。生成表单的 HTML 标记。
$employee_form->build(Uri::create('employee/add'));
enable
enable 重新启用之前已禁用的字段。
$employee_form->enable('employee_firstname');
disable
disable 允许禁用字段集中的字段构建。
$employee_form->disable('employee_firstname');
form
form 返回当前字段集的 Form 实例。
$form = employee_form->form();
add_model
add_model 将模型的字段添加到字段集中。它具有以下三个参数，
$class − 类名
$instance − 用于用值填充字段的类的实例
$method − 类中方法的名称。此方法用于将字段添加到字段集中。Orm\Model 具有所需的方法。默认方法名称为 set_form_fields。
$employee_form = Fieldset::forge('employee');
$employee_form->add_model('Model_Employee');
populate
populate 使用模型实例设置 fieldset 中字段的初始值。
$emp = new Model_Employee(); $emp->name = "Jon"; $employee_form->populate($emp);
repopulate
repopulate 与 populate 相同，只不过它会重新填充字段集中的字段。
validation
validation 获取当前字段集的验证实例。
$validation = $employee_form->validation();
validated
$this->validation()->validated() 的别名。
input
$this->validation()->input() 的别名。
error
$this->validation()->error() 的别名。
show_errors
$this->validation()->show_errors() 的别名。
工作示例
让我们使用 Fieldset 类创建一个高级表单，以在我们的示例员工应用程序中添加新员工。
更新模型
使用必要的验证规则更新员工模型，并按如下方式添加验证观察者。
<?php
class Model_Employee extends Orm\Model {
protected static $_connection = 'production';
protected static $_table_name = 'employee';
protected static $_primary_key = array('id');
protected static $_properties = array (
'id',
'name' => array (
'data_type' => 'varchar',
'label' => 'Employee Name',
'validation' => array (
'required',
'min_length' => array(3),
'max_length' => array(80)
),
'form' => array (
'type' => 'text'
),
),
'age' => array (
'data_type' => 'int',
'label' => 'Employee Age',
'validation' => array (
'required',
),
'form' => array ('type' => 'text' ),
),
);
// 只需添加观察者，并定义所需的事件
protected static $_observers = array('Orm\Observer_Validation' => array (
'events' => array('before_save')));
}
在这里，我们定义了姓名和年龄字段的验证规则，并添加了一个新的观察者，在将模型保存到数据库之前执行服务器端验证。相同的验证规则也将在表单中创建必要的输入验证属性。
创建表单
在员工控制器中创建新操作 action_advancedform，如下所示。
public function action_advancedform() {
// 创建新的字段集并添加员工模型
$fieldset = Fieldset::forge('employee')->add_model('Model_Employee');
// 从字段集获取表单
$form = $fieldset->form();
// 向表单添加提交按钮
$form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit'));
// 构建表单并将当前页面设置为操作
$formHtml = $fieldset->build(Uri::create('employee/advancedform'));
// 在数据中设置表单
$data = array();
$data['form'] = $formHtml;
return Response::forge(View::forge('employee/advancedform', $data, false));
}
这里，我们使用 fieldset 创建了表单，并将表单发送到视图。接下来，为操作添加视图 fuel/app/views/employee/advancedform.php，如下所示。
<!DOCTYPE html>
<html lang = "en">
<head>
<title>Employee :: add page</title>
<meta charset = "utf-8">
<meta name = "viewport" content = "width = device-width, initial-scale = 1">
<?php echo Asset::css('bootstrap.css'); ?>
<style>
table {
width: 90%;
}
table tr {
width: 90%
}
table tr td {
width: 50%
}
input[type = text], select {
width: 100%;
padding: 12px 20px;
margin: 8px 0;
display: inline-block;
border: 1px solid #ccc;
border-radius: 4px;
box-sizing: border-box;
}
input[type = submit] {
width: 100%;
background-color: #3c3c3c;
color: white;
padding: 14px 20px;
margin: 8px 0;
border: none;
border-radius: 4px;
cursor: pointer;
}
div {
border-radius: 5px;
background-color: #f2f2f2;
padding: 20px;
}
</style>
</head>
<body>
<div class = "container">
<?php
if(isset($errors)) {
echo $errors;
}
echo $form;
?>
</div>
</body>
</html>
现在，请求页面 http://localhost:8080/employee/add 将显示以下表单。
处理表单
更新操作方法 action_advancedform 以处理表单并将用户输入的员工数据添加到员工控制器中的数据库中，如下所示。
public function action_advancedform() {
// 创建新的字段集并添加员工模型
$fieldset = Fieldset::forge('employee')->add_model('Model_Employee');
// 从字段集获取表单
$form = $fieldset->form();
// 向表单添加提交按钮
$form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit'));
// 构建表单并将当前页面设置为操作
$formHtml = $fieldset->build(Uri::create('employee/advancedform'));
if (Input::param() != array()) {
try {
$article = Model_Employee::forge();
$article->name = Input::param('name');
$article->url = Input::param('age');
$article->save();
Response::redirect('employee/list');
}
catch (Orm\ValidationFailed $e) {
$view = View::forge('employee/advancedform');
$view->set('form', $formHtml, false);
$view->set('errors', $e->getMessage(), false);
}
}
return Response::forge($view);
}
在这里，一旦用户输入的数据经过验证并保存到数据库中，我们就被重定向到员工列表页面。否则，我们将再次显示该表单。
创建表单
现在，请求 URL，http://localhost:8080/employee/add，输入一些员工数据并提交表单。如果未提供数据，则表单将提示用户输入数据，如以下屏幕截图所示。
如果用户绕过客户端验证，则服务器将验证表单并显示错误，如以下屏幕截图所示。
如果数据通过了客户端和服务器端验证，则员工数据将保存到数据库中，页面将重定向到列表页面。
FuelPHP - 文件上传
文件上传是表单编程中最常用的功能之一。FuelPHP 提供了一个特殊的类 Upload 来处理文件上传。本章让我们学习如何使用 Upload 类上传文件。
配置
可以使用单独的配置文件 fuel/app/config/upload.php 配置 Upload 类。重要的配置条目如下 −
max_size − 设置要上传文件的最大大小。"0"表示上传大小不受限制
ext_whitelist − 设置允许的文件扩展名
ext_blacklist − 设置不允许的文件扩展名
type_whitelist − 设置允许的文件类型。例如，mime 类型为"text/plain"，则为"text"
type_blacklist − 设置不允许的文件类型
mime_whitelist − 设置允许的 mime 文件类型。例如，"text/plain"
mime_blacklist − 设置不允许的 mime 文件类型
prefix − 将上传的文件保存到服务器时，文件名中的前缀字符串
suffix − 将上传的文件保存到服务器时，文件名中的后缀字符串
extension −需要设置的上传文件扩展名
create_path − 如果文件路径不可用，是否创建
overwrite − 保存上传文件时是否覆盖现有文件
auto_rename − 保存上传文件时是否通过添加序列号重命名文件
randomize − 是否创建一个随机的32个字符的名称来保存上传的文件
Upload 方法
Upload 类提供处理和保存用户上传文件的选项。每个处理过的文件(保存前)在结果数组中都会有以下信息。
field −表单字段的名称
name − 已上传文件的名称
type − 浏览器定义的文件类型
mimetype − Upload 类定义的文件类型
file − 已上传文件临时位置的完全限定名称
filename − 已上传文件的文件名
extension − 已上传文件的扩展名
size − 已上传文件的大小(以字节为单位)
errors −包含错误代码和消息的错误数组
error − 是否设置数组错误，其中包含上传失败的原因(以防上传失败)
一旦文件保存在服务器中，结果数组也将包含以下信息。
saved_to − 上传文件的完全限定路径
saved_as − 保存的文件的名称
errors −更新的错误数组
现在，让我们看看 Upload 类的方法。
is_valid
如果用户上传了任何有效文件，is_valid 将返回 true。
// 我们是否有任何已上传的文件需要保存?
if (Upload::is_valid()) {
// process
}
get_files
get_files 将所有上传的文件作为多维数组返回。如果指定了表单文件输入的索引/名称，则它将仅返回与指定文件输入相关的上传文件。
foreach(Upload::get_files() as $file) {
// 对文件信息进行一些处理
}
if ( Upload::get_files(0)) {
// do something
}
get_errors
如果上传一个或多个文件失败，get_errors 将返回错误数组。如果指定了表单文件输入名称的索引/名称，则它将仅返回与指定文件输入相关的错误。
foreach(Upload::get_errors() as $file) {
// 对文件信息进行一些处理
}
if (Upload::get_errors('myimage')) {
// do something
}
Process
process 指的是收集有关上传文件的信息的实际过程。我们可以使用数组提供新的自定义配置。如果未指定任何配置，则它将使用 fuel/app/config/upload.php 中定义的配置
Upload::process (array( 'auto_rename' => false, 'overwrite' => true ));
save
save 保存是指将所有经过验证的文件保存在适当位置的实际过程。我们可以指定索引以仅保存该特定条目。
Upload::save(); Upload::save(0); Upload::save(0, 3);
工作示例
让我们在员工示例中创建一个新的控制器 Controller_Upload 来测试上传功能。
步骤 1 − 创建一个文件 fuel/app/classes/controller/upload.php。创建上传控制器。
<?php
class Controller_Upload extends Controller {
}
步骤 2 − 创建一个新的动作 get_upload。
<?php
class Controller_Upload extends Controller {
public function get_index() {
return \View::forge("upload/index");
}
}
步骤 3 − 为所创建的操作创建一个新视图。
<!DOCTYPE html>
<html>
<body>
<form action = "/upload/index" method = "post" enctype = "multipart/form-data">
Select image to upload:
<input type = "file" name = "fileToUpload" id = "fileToUpload">
<input type = "submit" value = "Upload Image" name = "submit">
</form>
</body>
</html>
步骤 4 −创建一个新的动作post_action来处理上传的文件。
<?php
class Controller_Upload extends Controller {
public function get_index() {
return \View::forge("upload/index");
}
public function post_index(){
$config = array(
'path' => DOCROOT.'files',
'randomize' => true,
'ext_whitelist' => array('img', 'jpg', 'jpeg', 'gif', 'png'),
);
Upload::process($config);
// if there are any valid files
if (Upload::is_valid()) {
Upload::save();
echo "success";
} else {
// and process any errors
foreach (Upload::get_errors() as $file) {
echo var_dump($file);
}
}
}
}
最后，通过请求 URL http://localhost:8080/upload/index 运行应用程序并尝试上传文件。
结果
FuelPHP - Ajax
AJAX 是 Web 编程中的一项现代技术。它提供了在网页中异步发送和接收数据的选项，而无需刷新页面。让我们在本章中了解 FuelPHP AJAX 编程。
FuelPHP 框架提供了识别请求类型是否为 AJAX 的选项。输入类有一个方法 is_ajax() 用于此目的。如果发出 AJAX 请求，Input::is_ajax 方法返回 true，否则返回 false。
此方法用于在服务器端正确处理 AJAX 请求。
if (Input::is_ajax()) {
// Ajax 请求
} else {
// 正常请求
}
我们可以使用 json_encode 返回 JSON 响应。我们可以结合这两种方法来创建一个简单干净的基于 AJAX 的 Web 应用程序。
工作示例
让我们在员工应用程序中添加一个新页面 ajax/index，并尝试异步获取员工信息。
步骤 1 −在 fuel/app/classes/controller/ajax.php 创建一个新的控制器 Controller_Ajax。
<?php
class Controller_Ajax extends Controller {
}
步骤 2 − 创建一个新的动作 action_index，如下所示。
<?php
class Controller_Ajax extends Controller {
public function action_index() {
$emps = model_employee::find('all');
$data = array();
$i = 0;
foreach($emps as $emp) {
$data[$i] = array();
$data[$i]['name'] = $emp['name'];
$data[$i]['age'] = $emp['age'];
$i = $i + 1;
}
if(\Input::is_ajax()) {
echo json_encode($data);
} else {
return \View::forge("ajax/index");
}
}
}
此处，如果请求是 AJAX，我们将获取学生信息，将其编码为 JSON，然后返回。否则，我们只呈现相应的视图。
步骤 3 − 创建相应的视图文件 fuel/app/views/ajax/index.php，如下所示。
<html>
<head>
<script language = "javascript" src = "/assets/js/jquery-3.2.1.min.js"></script>
<style>
.table { border-collapse: collapse; }
.table th, td {
border-bottom: 1px solid #ddd;
width: 250px;
text-align: left;
align: left;
}
</style>
</head>
<body>
<a id = "loademployee" href = "#">Load employee information</a>
</br>
</br>
<table class = "table">
<tbody id = "employee">
</tbody>
</table>
<script language = "javascript">
$(document).ready(function() {
$("#loademployee").on("click", function(event) {
$.ajax ({
url: '/ajax/index',
type: 'POST',
dataType: 'json',
async: true,
success: function(data, status) {
var e = $('<tr><th>Name</th><th>Age</th></tr>');
$('#employee').html('');
$('#employee').append(e);
for(i = 0; i < data.length; i++) {
employee = data[i];
var e = $('<tr><td id = "name"></td><td id = "age"></td></tr>');
$('#name', e).html(employee['name']);
$('#age', e).html(employee['age']);
$('#employee').append(e);
}
},
error : function(xhr, textStatus, errorThrown) {
alert('Ajax request failed.');
}
});
});
});
</script>
</body>
</html>
在这里，我们创建了一个锚标记 (id: loademployee)，以使用 AJAX 调用加载员工信息。AJAX 调用使用 JQuery 完成。当用户单击 loademployee 标记时，将激活附加到该标记的事件。然后，它将使用 AJAX 调用获取员工信息并动态生成所需的 HTML 代码。
步骤 4 − 运行应用程序。
最后，运行应用程序 http://localhost:8000/ajax/index 并单击"加载员工信息"锚选项卡。
结果
FuelPHP - HMVC 请求
FuelPHP 提供了一个出色的功能，可以使用 Request 类在同一应用程序内请求操作。这称为 HMVC 请求。它允许重用控制器逻辑。
创建 HMVC 请求
创建 HMVC 请求非常简单，只需使用所需的 URL 创建请求对象并调用如下的执行方法即可。
$list = Request::forge('employee/list/')->execute();
echo $list;
$employee = Request::forge('employee/show/1')->execute(array('id' => '1'));
echo $employee;
工作示例
让我们创建一个新的控制器 Controller_HMVC 来测试 HMVC 功能。创建一个文件 fuel/app/classes/controller/hmvc.php 并放置以下代码。
<?php
class Controller_HMVC extends Controller {
public function action_index() {
echo Request::forge('employee/list')->execute();
}
}
在这里，我们刚刚通过 HMVC 请求调用了员工/列表页面并显示了结果。
结果
FuelPHP - 主题
主题用于为应用程序启用多种外观。它为用户/开发人员提供了更改应用程序外观的选项，而不会干扰应用程序的功能。一个应用程序可以有一个或多个主题。每个主题都位于自己的文件夹中。让我们在本章中学习如何创建主题。
主题配置
FuelPHP 为主题提供了一个单独的配置文件，fuel/app/config/themes.php。所有主题相关设置都在此文件中配置。一些主要主题设置如下 −
active − 活动主题的名称
fallback − 如果未找到活动主题，则为后备主题的名称
paths − 搜索和查找主题的路径数组
assets_folder − 通常，资产需要位于 DOCPATH 内，以便可以通过 Web 访问。它指的是 DOCPATH 内主题的资产文件夹
view_ext − 主题视图文件的扩展名
info_file_name −包含主题扩展信息的文件
require_info_file − 是否需要主题信息文件，info_file_name
use_modules − 是否使用当前模块
主题文件的简单配置如下。
<?php
return array (
'active' => 'tpthemes',
'fallback' => 'tpthemes',
'paths' => array (
APPPATH.'themes',
),
'assets_folder' => 'assets',
'view_ext' => '.html',
'require_info_file' => false,
'info_file_name' => 'themeinfo.php',
'use_modules' => false,
);
这里我们设置了，
- 活动主题和后备主题的名称为 tpthemes
- 主题文件夹的路径为 fuel/app/themes/
- 资产文件夹的路径为 /public/assets/tpthemes/
主题类
配置完成后，我们可以使用 FuelPHP 提供的类 Theme 来实现主题的功能。让我们在本章中了解 Theme 类中可用的方法。
instance
instance 方法可以创建一个新主题。它有以下两个参数，
$name − 主题名称(可选)
$config −主题配置数组(与配置部分中看到的相同)
两个参数都是可选的。如果未指定任何参数，它会尝试从配置文件中获取默认主题。如果指定了主题名称，它会尝试从配置文件中获取其他设置。如果还指定了配置，那么它将使用用户指定的设置，而不是配置文件中的设置。
$theme = \Theme::instance();
$theme = \Theme::instance('tpthemes');
$theme = \Theme::instance ('mytheme', array (
'active' => 'mytheme', 'view_ext' => '.php'));
forge
forge 与 instance 类似，只不过它只有配置数组。
$theme = \Theme::forge (array( 'active' => 'tpthemes', 'fallback' => 'tpthemes', 'view_ext' => '.php', ));
view
view 方法在后台使用 View::forge()。两个 API 类似，只是 view 方法在主题文件夹 fuel/app/themes/tpthemes/ 中搜索视图文件，而不是 fuel/app/views/ 文件夹。
$theme = \Theme::instance();
$view = $theme->view('template/index');
// *fuel/app/themes/tpthemes/template/index.php
presenter
presenter 方法在后台使用 Presenter::forge()。这两个 API 类似，只是 presenter 方法在主题文件夹 fuel/app/themes/tpthemes/ 中搜索视图文件，而不是 fuel/app/views/ 文件夹。
$theme = \Theme::instance();
$presenter = $theme->presenter('template/index');
asset_path
asset_path 方法返回相对于当前选定主题的请求资产的路径。
$theme = \Theme::instance();
// public/assets/tpthemes/css/style.css
$style = \Html::css($theme->asset_path('css/style.css'));
add_path
add_path 方法允许在运行时添加主题路径。
$theme = \Theme::instance(); $theme->add_path(DOCROOT.'newthemes');
add_paths
add_paths 方法允许在运行时添加多个主题路径。
$theme = \Theme::instance(); $theme->add_path(DOCROOT.'newthemes');
active
active 方法允许设置活动主题。
$theme = \Theme::instance();
$active = $theme->active('newtheme');
fallback
fallback 方法允许设置后备主题。
$theme = \Theme::instance();
$fallback = $theme->fallback('custom');
get_template
get_template 方法将返回当前加载的主题模板的 View 实例。
$theme = \Theme::instance();
$theme->get_template()->set('body', '主题可以改变应用的外观和感觉');
set_template
set_template 方法允许为页面设置主题模板。
$theme = \Theme::instance();
$theme->set_template('layouts/index')->set('body', 'set theme template');
find
如果找到主题的路径，find 返回 true，否则返回 false。
$theme = \Theme::instance();
$path = $theme->find('newtheme')
all
all 方法返回所有主题路径中的所有主题的数组。
$theme = \Theme::instance(); $themes = $theme->all();
get_info
get_info 方法从主题信息数组中返回特定变量。如果未指定主题，则使用活动主题的信息数组。
$theme = \Theme::instance();
$var = $theme->get_info('color', 'green', 'newtheme');
这里，获取颜色的方法在'newtheme'中定义。如果未定义，则将使用'green'作为默认颜色。
set_info
set_info 方法在活动或后备主题中设置变量。
$theme->set_info('color', 'green', 'fallback');
set_partial
set_partial 方法允许为页面模板的命名部分设置视图部分。通常，它是通过 HMVC 调用完成的。
$theme = \Theme::instance();
$theme->set_template('layouts/homepage');
$theme->set_partial('navbar', 'homepage/navbar');
get_partial
get_partial 方法允许获取页面模板中命名部分中先前设置的局部视图实例。
$theme = \Theme::instance();
$theme->set_partial('sidebar', 'partials/menu');
$theme->get_partial('sidebar', 'partials/menu')->set('class', 'menu green');
工作示例
让我们在员工应用程序中添加主题支持。
步骤 1 − 添加新的主题配置文件 fuel/app/config/theme.php，内容如下。
<?php
return array (
'active' => 'tpthemes',
'fallback' => 'tpthemes',
'paths' => array (APPPATH.'themes', ),
'assets_folder' => 'assets',
'view_ext' => '.html',
'require_info_file' => false,
'info_file_name' => 'themeinfo.php',
'use_modules' => false,
);
步骤 2 − 为主题 tpthemes 添加新的资源文件夹 public/assets/tpthemes/css。
cd /go/to/app/root/path mkdir -p public/assets/tpthemes/css
步骤 3 − 下载最新的 bootstrap 并将 bootstrap.min.css 放在 public/assets/tpthemes/css 下
步骤 4 − 在 fuel/app/themes 文件夹下添加新文件夹 tpthemes。
cd /go/to/app/root/path mkdir -p fuel/app/themes/tpthemes
步骤 5 −在fuel/app/themes/tpthemes/layout/下添加新的布局模板bootstrap.html，并添加如下代码。
<!DOCTYPE html>
<html lang = "en">
<head>
<title>Theme example</title>
<meta charset = "utf-8">
<meta name = "viewport" content = "width = device-width, initial-scale = 1">
<!-- Bootstrap core CSS -->
<?php echo \Theme::instance()->asset->css('bootstrap.min.css'); ?>
</head>
<body>
<?php echo $header; ?>
<div class = "container">
<div class = "row">
<div class = "col-sm-12">
<?php echo $content; ?>
</div>
</div>
</div>
</body>
</html>
这里我们使用了主题实例和资源方法来获取引导文件的路径。我们定义了两个变量，header 和 content。header 被定义用来动态设置 header 详细信息。content 被定义用来动态设置页面的实际内容。
步骤 6 − 在 fuel/app/themes/tpthemes/partials 中添加新的 header 模板 header.php，如下所示。
<div class = "jumbotron text-center"> <h1>Theme support in fuelphp</h1> <p>bootstrap based template</p> </div>
步骤 7 − 在 fuel/app/classes/controller/themesample.php 创建一个新控制器 ThemeSample，并在 action_index 创建一个新控制器 action，如下所示。
<?php
class Controller_ThemeSample extends \Controller {
public function before() {
$this->theme = \Theme::instance();
$this->theme->set_template('layouts/bootstrap');
$header = $this->theme->view('partials/header');
$this->theme->get_template()->set('header', $header);
}
public function action_index() {
$content = $this->theme
->view('themesample/index')
->set('message', 'This data comes from action page');
$this->theme
->get_template()
->set('content', $content);
}
public function after($response) {
if (empty($response) or ! $response instanceof Response) {
$response = \Response::forge(\Theme::instance()->render());
}
return parent::after($response);
}
}
在这里，我们使用 before 和 after 方法，使用 Theme 类的方法对主题进行初始化。使用的一些方法包括 instance、get_template、set_template 和 view。
步骤 8 − 最后，在 fuel/app/themes/tpthemes/themesample 中添加索引操作的视图 index.php，如下所示。
<p>The data comes from *fuel/app/themes/tpthemes/themesample/index.html* file.</p> <p> <?php echo $message; ?> </p>
在这里，我们定义了一个变量，message，需要在控制器中动态设置。
我们创建了一个新的主题，tpthemes，并在ThemeSample控制器中使用它。现在让我们通过请求 URL http://localhost:8080/themesample/index 来检查结果。结果如下。
FuelPHP - 模块
模块是编写可重复使用的 Web 功能(如博客、相册、聊天等)的好方法。模块不会干扰 Web 应用程序中的其他代码。它位于自己的文件夹中，并默默提供其功能。模块只是相同的控制器、模型和视图，只是它们被分组、配置并放置在特殊文件夹中。通常，模块通常位于位于 fuel/app/modules 的应用程序子目录中，名为 modules。
模块配置
我们可以在主应用程序配置文件 fuel/app/config/config.php 中定义模块路径，如下所示。
'module_paths' => array (
path/to.'modules'.DS, // 应用程序模块的路径
path/to.'..'.DS.'globalmods'.DS // 全局模块的路径
),
模块命名空间
在 FuelPHP 中，每个模块都有自己的 PHP 命名空间。设置单独的命名空间可解决名称冲突问题。例如，可以在命名空间 EmployeeModule 下设置员工模块，如下所示。
<?php
namespace Employeemodule;
class Controller_Employee {
//code here
}
模块名称必须与模块文件夹名称相同。
模块结构
我们可以通过创建配置中定义的文件夹名称来创建模块。文件夹名称决定了模块的名称，以及模块中类的命名空间的名称。
模块的结构如下。 −
- classes
- controller
- model
- view
- config
- lang
- tasks
- views
模块可以有自己的配置文件。它在路由设置中非常有用，并且不会干扰应用程序的原始配置。另一个重要的概念是，可以通过在 always_load 配置部分中加载模块来重用模块类，如下所示。
'always_load => array (
'modules' => array('employeemodule'),
),
此外，模块可以立即加载和使用，而无需进行配置，如下所示。
Module::load('employeemodule');
\Employeemodule\Myclass::mymethod('params');
FuelPHP - 包
包在代码重用方面与模块类似，但在以下方面有所不同:
- 它不映射到 Web URL
- 它无法通过 HMVC 请求访问
简而言之，包不是博客、相册等直接的 Web 功能。相反，它是一个将电子邮件处理、文档创建、图表创建、身份验证等组合在一起的功能库，有助于更快地开发 Web 应用程序。
创建包
要创建包，首先我们需要按如下方式安排我们的源代码。
/fuel
/packages
/package (root directory of package)
/bootstrap.php
/classes
/our.php
/classes.php
/here.php
/config
/config.php
/and_so_on
包的结构有两个包特定的文件，config.php 和 bootstrap.php 文件。配置文件的目的是将包的配置分组到包文件夹本身下，而不会干扰主应用程序。引导文件的目的是设置命名空间，以便自动加载器正确加载它。
设置命名空间的一些方法如下，
Autoloader::add_namespace('Mypackage', __DIR__.'/classes/');
Autoloader::add_core_namespace('Mypackage');
Autoloader::add_core_namespace('Mypackage', true);
Autoloader::add_classes (array(
'Mypackage\Classname' => __DIR__.'/classes/classname.php',
'Mypackage\Anotherclass' => __DIR__.'/classes/anotherclass.php',
));
一旦引导文件正确配置，并且包加载到应用程序中，我们就可以按如下方式使用它。
$instance = new Myclass; $instance = new Mynamespace\Myclass;
安装包
包通常放在 fuel/packages 目录下。默认情况下，安装以下包，
auth − 身份验证包
email − 电子邮件包
oil − Fuel 的命令，oil 包
orm − ORM 包
parser − Markdown 解析器包
要安装新包，以下是两个选项，
选项 1 − 手动安装 - 下载并安装
要手动安装包，首先从作者的网站下载包。解压并将其放在 fuel/packages/ 文件夹下。
选项 2 − 使用 oil 命令的自动方法
FuelPHP 提供了一种自动安装托管在 github 中的包的方法。使用以下命令安装包 mytestpackage。
php oil package install mytestpackage
它使用 git 客户端克隆包源代码并将其移动到 fuel/packages 文件夹。如果 git 客户端不可用，那么我们可以使用 –direct 命令参数来指示命令下载并安装包，如下所示。
php oil package install mytestpackage --direct
使用包
一旦将包加载到应用程序中，就可以在应用程序中使用包。有两种方法可以将包加载到应用程序中。
选项 1 − 通过 Package 类
FuelPHP 提供了一个类 Package，分别通过 load、unload 和 loaded 方法加载、卸载和检查包的可用性。load 方法有两个参数。第一个参数 $package 是包的名称，第二个参数 path 是包的路径。如果包安装在 fuel/packages 文件夹中，则第二个参数是可选的。
// 加载 orm 包
Package::load('orm');
// 从特定目录加载解析器包
Package::load('parser', '/path/to/packages/dir/');
// 加载不存在的包
Package::load('awesome'); // 抛出 PackageNotFoundException
选项 2 − 通过配置文件
要永久加载包，只需在主配置文件 fuel/app/config/config.php 中的 always_load 配置条目下添加包。要加载电子邮件包，请使用以下语法。
'always_load' => array (
'packages' => array (
'email',
),
),
将包加载到应用程序中后，我们可以按如下方式使用它。
$instance = new Myclass; $instance = new Mynamespace\Myclass;
FuelPHP - Cookie 和 Session 管理
Cookie 提供客户端数据存储，它仅支持少量数据。通常，每个域为 2KB，具体取决于浏览器。Session 提供服务器端数据存储，它支持大量数据。让我们了解如何在 FuelPHP Web 应用程序中创建 cookie 和会话。
Cookies
FuelPHP 提供了一个 Cookie 类来创建 cookie 项。 Cookie 类用于创建、分配和删除 Cookie。
配置 Cookie
Cookie 类可以通过主应用程序配置文件进行全局配置，位于 fuel/app/config/config.php。其定义如下。
'cookie' => array (
//cookie 过期前的秒数
'expiration' => 0,
//限制 cookie 可用的路径
'path' => '/',
//限制 cookie 可用的域
'domain' => null,
//仅通过安全连接传输 cookie
'secure' => false,
//仅通过 HTTP 传输 cookie，禁用 Javascript 访问
'http_only' => false,
),
方法
Cookie 类提供创建、访问和删除 cookie 项的方法。它们如下 −
set()
set 方法用于创建 Cookie 变量。它包含以下参数，
$name − $_COOKIE 数组中的键。
$value − cookie 的值。
$expiration − cookie 应持续的秒数。
$path − 服务器上 cookie 可用的路径。
$domain −可以使用 cookie 的域。
$secure − 如果只想通过安全连接传输 cookie，请设置为 true。
$httponly − 仅允许通过 HTTP 传输 cookie，禁用 JavaScript 访问。
Cookie::set('theme', 'green');
get()
get 方法用于读取 Cookie 变量。它包含以下参数，
$name − $_COOKIE 数组中的键。
$value −如果 $_COOKIE 数组中没有该键，则返回该值。
Cookie::get('theme');
delete()
delete 方法用于删除 Cookie 变量。它包含以下参数，
$name − $_COOKIE 数组中的键。
$value − Cookie 的值。
$domain − Cookie 可用的域。
$secure −如果只想通过安全连接传输 cookie，请设置为 true。
$httponly − 仅允许通过 HTTP 传输 cookie，禁用 JavaScript 访问。
Cookie::delete('theme');
Session
FuelPHP 提供类 Session 来维护应用程序的状态。
配置 Session
Session 类可以通过特殊配置文件 fuel/core/config/session.php 进行配置。一些重要的配置条目如下 −
auto_initialize −自动初始化会话。
driver − 会话驱动程序的名称。会话使用驱动程序实现，可能的选项包括 cookie、db、memcached、redis 和 file。默认驱动程序为 cookie。
match_ip − 检查客户端 IP。
match_ua − 检查客户端用户代理。
expiration_time − 会话超时值(以秒为单位)。
rotation_time − 更新会话的时间。
Session 方法
Session 类提供了操作会话数据的方法。它们如下:
instance()
instance 方法返回一个默认或特定的实例，该实例通过名称标识。
$session = Session::instance(); // 默认实例
$session = Session::instance('myseesion'); // 特定实例
set()
set 方法用于分配 Session 变量。
Session::set('userid', $userid);
get()
get 方法允许您从会话中检索存储的变量。
$userid = Session::get('userid');
delete()
delete 方法允许您删除存储的会话变量。
Session::delete('userid');
create()
create 方法允许您创建新会话。如果会话已存在，则将销毁该会话并创建新会话。
Session::create();
destroy()
destroy 方法用于销毁现有会话。
Session::destroy();
read()
read 方法允许您读取会话。
Session::read();
write()
write 方法允许您写入会话。
Session::write();
key()
key 方法允许您检索会话密钥的元素。键的值是唯一的。
$session_id = Session::key('session_id');
FuelPHP - 事件
事件是程序识别的动作或事件，可以由程序本身处理。例如，我们可以定义一个名为 my_fuel_event 的动作或事件，然后在调用事件 my_fuel_event 时执行一些工作。FuelPHP 提供类 Event 来处理应用程序中的事件。
系统事件
FuelPHP 定义了一些事件，通过这些事件，我们可以在应用程序调用或触发定义的事件时执行一些工作。此帮助是在不更改 FuelPHP 的核心代码文件的情况下更改 FuelPHP 的行为。预定义事件如下 −
app_created − FuelPHP 框架初始化后，将触发此事件。
request_created − 伪造新的 Request 对象后，将触发此事件。
request_started − 请求执行请求时，将触发此事件。
controller_started − 此事件在调用控制器 before() 方法之前触发。
controller_finished − 调用控制器 after() 方法并收到响应后，将触发此事件。
response_created −伪造新的 Response 对象后将触发此事件。
request_finished − 请求执行完成并收到响应后将触发此事件。
shutdown − 处理完主请求并发送输出后将触发此事件。
我们可以在特殊配置文件 fuel/app/config/events.php 中处理事件，如下所示 −
<?php
return array (
'fuelphp' => array (
'app_created' => function() {
// FuelPHP 初始化后
},
'request_created' => function() {
// 请求伪造后
},
'request_started' => function() {
// 请求已请求
},
'controller_started' => function() {
// 控制器 before() 方法调用前
},
'controller_finished' => function() {
// 控制器 after() 方法调用后
},
'response_created' => function() {
// 响应伪造后
},
'request_finished' => function() {
// 请求已完成，且收到响应
},
'shutdown' => function() {
// 输出已发送
},
),
);
事件方法
事件类提供注册、取消注册和触发事件的方法。它们如下，
register()
注册方法允许文件注册一个对象，该对象将在调用触发器方法时运行。
$my_event_code = function() {
echo 'my event';
}
Event::register('my_event', $my_event_code);
unregister()
取消注册方法允许文件取消注册一个对象，该对象将在调用触发器方法时运行。
Event::unregister('my_event', $my_event_code);
trigger()
trigger 方法用于触发或激活通过 register 方法关联的回调。
Event::trigger('my_event');
has_events()
has_events 方法可用，因此您可以检查特定注册事件是否具有触发器。
Event::has_events('my_event');
forge()
forge 返回一个新的事件对象。
$event = Event::forge();
instance()
实例返回一个新的事件对象单例。
$event = Event::instance('event_instance');
FuelPHP - 电子邮件管理
电子邮件功能是 Web 框架中最需要的功能。FuelPHP 提供了一个优雅的电子邮件类，捆绑为一个包。它用于发送简单的纯文本电子邮件以及带有多个附件的高级富文本电子邮件。它支持以下功能 - 纯文本邮件、HTML 邮件、附件和内联附件。
配置
要在应用程序中启用电子邮件功能，我们只需在主配置文件 fuel/app/config/config.php 中加载下面指定的电子邮件包即可。
'always_load' => array (
'packages' => array (
'email',
),
),
另一个选项是加载电子邮件包，控制器本身如下。
\Package::load('email');
电子邮件设置可以在主配置文件中完成，一些重要选项如下，
driver − 电子邮件驱动程序，如 smtp
is_html − 是否以 HTML 内容发送邮件
priority − 电子邮件的优先级
smtp.host − SMTP 服务器主机
smtp.port − SMTP 服务器端口
smtp.username − SMTP 服务器用户名
smtp.password − SMTP 服务器密码
smtp.timeout − SMTP 超时
smtp.starttls − SMTP 服务器是否需要 STARTTLS 命令
电子邮件 API
以下是电子邮件和电子邮件驱动程序类提供的 API。
forge
目的:创建电子邮件驱动程序的实例。它根据收到的配置或输入创建驱动程序。电子邮件驱动程序提供创建和发送邮件的功能。一些可能的电子邮件驱动程序是 smtp、sendmail、mailgun 和 mandrill。
参数 − 无或配置详细信息数组
返回 − 返回 Email_Driver 对象
例如，
$email = \Email::forge(); $email = \Email::forge (array( 'driver' => 'smtp', ));
body
用途 − 设置邮件正文
参数 − $body - 邮件正文
返回 − 返回当前实例
例如，
$email = \Email::forge();
$email->body('Body message');
//或传递一个视图
$email->body(\View::forge('my/view', $data);
alt_body
用途 − 设置备用消息正文
参数 − $alt_body - 备用消息正文
返回 − 返回当前实例
例如，
$email = \Email::forge();
$email->alt_body('Body message');
//或传递一个视图
$email->alt_body(\View::forge('my/view', $data);
priority
用途 − 设置邮件的优先级
参数 −
$priority − 优先级的值。选项为 −
a. \Email::P_LOWEST * \Email::P_LOW * \Email::P_NORMAL * \Email::P_HIGH * \Email::P_HIGHEST
返回 −返回当前实例
例如，
$email = \Email::forge(); $email->priority(\Email::P_HIGHEST);
html_body
用途 − 设置 HTML 格式的邮件正文
参数 −
$html − HTML 格式的邮件正文；
generate_alt − 是否生成替代邮件；
auto_attach −是否嵌入图像
返回 − 返回当前实例
例如，
$email = \Email::forge();
// 确实生成 alt 主体，但不自动附加图像。
$email->html_body(\View::forge('welcome/email', $data), true, false);
from
用途 − 设置发件人地址
参数 −
$from − 发件人电子邮件地址；
$name − 发件人姓名
返回 − 返回当前实例
例如，
$email = \Email::forge();
$email->from('test@test.com', 'My Name');
subject
用途 − 设置邮件主题
参数 − $subject - 电子邮件主题
返回 − 返回当前实例
例如，
$email = \Email::forge();
$email->subject('Suject of the mail message');
to
用途 − 设置接收方电子邮件地址
参数 −
$email − 电子邮件地址或电子邮件地址数组；
$name − 接收方名称
返回 − 返回当前实例
例如，
$email = \Email::forge();
$email->to('test@test.com', 'My Dear Name');
$email->to (array(
'test@test.com',
'test@test.com' => 'My Dear friend',
));
header
用途 − 为电子邮件设置自定义标头
参数 −
$header − 标头类型或标头数组；
$value − 标头的值
返回 − 返回当前实例
例如，
$email = \Email::forge();
$email->header('X-SMTPAP', 'XXXXXXXX');
$email>reply_to (array(
'X-SMTPAP' => 'XXXXXX',
'X-SMTPAP2' > 'XXXXXA',
));
attach
用途 − 将文件附加到电子邮件消息
参数 −
$file − 文件路径;
$inline − 是否以内联方式附加文件;
$cid − 内容标识符;
$mime − 附件文件的 MIME 类型;
$name − 附件文件名覆盖
返回 − 返回当前实例
例如，
$email = \Email::forge(); $email>attach(DOCROOT.'attachments/sample_attachment.pdf');
send
用途 − 发送邮件。
参数 −
$validate − 是否验证电子邮件地址
返回 − true 或 false
例如，
$email = \Email::forge();
try{
$email->send();
} catch(\EmailSendingFailedException $e) {
// The driver could not send the mail.
} catch(\EmailValidationFailedException $e) {
// One or more email addresses failed validation.
}
工作电子邮件示例
让我们使用上一章中学到的 API，并创建一个简单的代码来发送消息。以下是发送消息的最简单的代码。
$email = Email::forge();
$email->from('someone@gmail.com', 'person1');
$email->to('anotherone@gmail.com', 'person2');
$email->subject('Add something');
$email->body('contents of mail'); $email->send();
FuelPHP - 分析器
分析器是分析和改进应用程序性能的重要工具之一。FuelPHP 提供了一个出色的分析器来分析应用程序。本章让我们了解一下 FuelPHP 中的配置文件。
启用配置文件
默认情况下，配置文件是禁用的。要启用配置文件，请在主配置文件 fuel/app/config/config.php 中将属性 profiling 设置为 true，如下所示。
'profiling' => true,
现在，应用程序中已启用配置文件。一旦启用分析功能，所有请求的页面将在页面底部显示一个额外的选项卡，其中包含分析信息，如以下屏幕截图所示。
分析器信息
分析器具有选项卡式界面，包含以下数据，
Console − 提供有关错误、日志条目、内存使用情况或执行时间的信息。
Load time − 显示请求加载时间。
Database − 执行的查询数和执行时间。
Memory −请求使用的总内存。
Files − 显示所有 PHP 文件。
Config − 请求结束时的配置内容。
Session − 请求结束时的会话内容。
GET − $_GET 数组的内容。
POST − $_POST 数组的内容。
Profiler 类
Profiler 类用于添加您的分析信息。它实现了 PHPQuickProfiler (PQP) 的定制版本。 Profiler 包含一组 javaScript 变量，用于控制 Profiler 的初始状态。
Profiler 类支持以下 方法 −
mark()
mark 方法将向分析器添加速度标记。它显示加载时间。
Profiler::mark('my custom code');
mark_memory()
*mark_memory* 方法向分析器添加内存标记。如果未指定输入，则记录该时间点的内存使用情况。如果我们指定变量和变量的标签(如下所示)，则它将显示变量的内存使用情况并使用指定的标签对其进行标记。
mark_memory($this, 'My Employee Controller 内存使用情况');
console()
控制台方法将简单地向分析器添加日志条目。
Profiler::console('log entry');
FuelPHP - 错误处理和调试
FuelPHP 为处理错误和调试应用程序提供了出色的支持。本章将介绍错误处理和调试。
错误处理
FuelPHP 错误处理基于异常。FuelPHP 为所有旧 php 错误提供 PhpErrorException 异常。每当遇到 PHP 代码中的错误时，FuelPHP 都会引发 PhpErrorException。FuelPHP 还可以轻松显示各种 HTTP 状态代码的自定义错误页面。
文件未找到错误
FuelPHP 提供了一个新的异常类 HttpNotFoundException 来处理未知请求。有时，我们可能会遇到可能无法处理的请求。那时，我们可以抛出 HttpNotFoundException。
默认情况下，在路由配置文件 fuel/app/config/routes.php 中使用 400 条目为 HttpNotFoundException 配置了一个默认页面。每当引发 HttpNotFoundException 时，请求将重定向到 400 页面。
'_404_' => 'welcome/404', // 主 404 路由
内部错误
FuelPHP 提供了一个新的异常类 HttpServerErrorException 来处理所有服务器错误。有时，我们可能由于内部错误而无法处理给定的请求。那时，我们可以抛出 HttpServerErrorException。
默认情况下，在路由配置文件 fuel/app/config/routes.php 中使用 500 条目为 HttpServerErrorException 配置一个默认页面。每当引发 HttpServerErrorException 时，请求将重定向到 500 页面。
'_500_' => 'welcome/500', // 主 500 路由
此页面将记录错误，在页面中显示格式化的错误，并偶尔向系统管理员发送通知。
访问冲突错误
FuelPHP 提供了一个新的异常类 HttpNoAccessException 来处理访问冲突。有时，我们可能由于访问限制而无法处理请求。那时，我们可以抛出 HttpNoAccessException。
默认情况下，在路由配置文件 fuel/app/config/routes.php 中使用 403 条目为 HttpNoAccessException 配置一个默认页面。每当引发 HttpNoAccessException 时，请求都会重定向到 403 页面。
'_403_' => 'welcome/403', // 主 403 路由
此页面将显示访问冲突信息。
调试
调试是开发应用程序最常见的活动之一。FuelPHP 提供了一个简单的类 Debug 来处理应用程序的调试活动。让我们在本章中学习 Debug 类及其方法。
Debug 类
Debug 类提供了实用方法来显示变量、对象、数组等的详细信息。Debug 类提供了以下方法，
dump
dump 方法以格式化的结构化方式向浏览器返回多个混合值。
Debug::dump($var1, $var2);
backtrace()
backtrace 显示有关当前代码执行的详细信息。它显示 PHP 文件信息、当前行及其所有先前的操作。
Debug::backtrace();
classes()
返回所有类的列表。
Debug::classes();
interfaces()
返回所有接口类的列表。
Debug::interfaces();
includes()
返回当前在运行时加载的所有包含文件的列表。
Debug::includes();
functions()
返回所有函数的列表。
Debug::functions();
constants()
返回所有常量的列表。
Debug::constants();
extensions()
返回所有扩展的列表。
Debug::extensions();
headers()
返回所有 HTTP 标头的列表。
Debug::headers();
phpini()
打印从 php.ini 文件读取的配置设置列表。
Debug::phpini();
FuelPHP - 单元测试
单元测试是开发大型项目必不可少的过程。单元测试有助于在开发的每个阶段自动测试应用程序的组件。当应用程序的组件未按照项目的业务规范运行时，它会发出警报。单元测试可以手动完成，但通常是自动化的。
PHPUnit
FuelPHP 框架与 PHPUnit 测试框架集成。要为 FuelPHP 框架编写单元测试，我们需要设置 PHPUnit。如果未安装 PHPUnit，请下载并安装它。我们可以使用以下命令确认系统中 PHPUnit 的可用性。
phpunit --version
如果 PHPUnit 可用，您将看到类似于以下的结果。
PHPUnit 5.1.3 由 Sebastian Bergmann 和贡献者开发。
创建单元测试
FuelPHP 提供的用于编写单元测试的标准位置是 fuel/app/tests。我们可以在单独的文件夹中为控制器、模型、视图和演示者编写单元测试。让我们编写一个单元测试来验证 Model_Employee 对象。
步骤 1 − 在 fuel/app/tests 文件夹下创建一个文件夹 model。
步骤 2 −在 fuel/app/tests/model/ 文件夹下创建一个文件 employee.php。
步骤 3 − 通过扩展 PHPUnit 提供的 TestCase 类创建一个新的测试类 Test_Model_Employee。
步骤 4 − 编写一个方法 testInstanceOfEmployee()，使用 PHPUnit 的 TestCase 类提供的 assertInstanceOf() 方法对员工对象的创建进行资产化。
以下是完整代码 −
<?php
class Test_Model_Employee extends TestCase {
public function testInstanceOfEmployee() {
$this->assertInstanceOf(Model_Employee::class, new Model_Employee());
}
}
创建测试组
FuelPHP 提供了创建一组测试用例的选项。创建组就像添加 docblock 属性 @group 一样简单。让我们将测试用例包含在 MyTest 组中。
<?php
/**
* @group MyTest
*/
class Test_Model_Employee extends TestCase {
public function testInstanceOfEmployee() {
$this->assertInstanceOf(Model_Employee::class, new Model_Employee());
}
}
运行测试
要运行目录中的所有测试，请使用以下命令。
$ php oil test
要运行特定的一组测试，请使用以下命令。
$ php oil test --group = MyTest
执行命令后，您将收到以下响应。
Tests Running...This may take a few moments.
PHPUnit 5.1.3 by Sebastian Bergmann and contributors.
1 / 1 (100%).
Time: 123 ms, Memory: 8.00Mb
OK (1 test, 1 assertion)
FuelPHP - 完整的工作示例
在本章中，我们将学习如何在 FuelPHP 中创建一个完整的基于 MVC 的 BookStore 应用程序。
步骤 1:创建项目
使用以下命令在 FuelPHP 中创建一个名为"BookStore"的新项目。
oil create bookstore
步骤 2:创建布局
为我们的应用程序创建一个新布局。在 fuel/app/views/layout.php 位置创建一个文件 layout.php。代码如下，
fuel/app/views/layout.php
<!DOCTYPE html>
<html lang = "en">
<head>
<meta charset = "utf-8">
<meta http-equiv = "X-UA-Compatible" content = "IE = edge">
<meta name = "viewport" content = "width = device-width, initial-scale = 1">
<title><?php echo $title; ?></title>
<!-- Bootstrap core CSS -->
<link href = "/assets/css/bootstrap.min.css" rel = "stylesheet">
<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js">
</script>
<script src = "/assets/js/bootstrap.min.js"></script>
</head>
<body>
<nav class = "navbar navbar-inverse navbar-fixed-top">
<div class = "container">
<div class = "navbar-header">
<button type = "button" class = "navbar-toggle collapsed"
datatoggle = "collapse" data-target = "#navbar"
aria-expanded = "false" ariacontrols = "navbar">
<span class= "sr-only">Toggle navigation</span>
<span class = "icon-bar"></span>
<span class = "icon-bar"></span>
<span class = "icon-bar"></span>
</button>
<a class = "navbar-brand" href = "#">FuelPHP Sample</a>
</div>
<div id = "navbar" class = "collapse navbar-collapse">
<ul class = "nav navbar-nav">
<li class = "active"><a href = "/book/index">Home</a></li>
<li><a href = "/book/add">Add book</a></li>
</ul>
</div><!--/.nav-collapse -->
</div>
</nav>
<div class = "container">
<div class = "starter-template" style = "padding: 50px 0 0 0;">
<?php echo $content; ?>
</div>
</div><!-- /.container -->
</body>
</html>
这里，我们使用 bootstrap 模板。FuelPHP 对 bootstrap 模板具有一流的支持。我们创建了两个变量，title 和 content。title 用于指定当前页面的标题，content 用于指定当前页面的详细信息。
步骤 3:创建控制器
创建一个新的控制器 Controller_Book 来显示、添加、编辑和删除书籍。创建一个新文件 fuel/app/classes/controller/book.php 并放置以下代码。
fuel/app/classes/controller/book.php
<?php
class Controller_Book extends Controller_Template {
public $template = 'layout';
public function action_index() {
// 创建视图对象
$view = View::forge('book/index');
// 设置模板变量
$this->template->title = "Book index page";
$this->template->content = $view;
}
}
这里我们通过继承模板控制器创建了书籍控制器，并将默认模板设置为fuel/app/views/layout.php。
步骤4:创建索引视图
在fuel/app/views文件夹下的views目录中创建一个文件夹book。然后，在book文件夹中创建一个文件index.php并添加以下代码，
fuel/app/views/index.php
<h3>index page</h3>
到目前为止，我们已经创建了一个基本的书籍控制器。
步骤5:修改默认路由
更新默认路由，将应用程序的主页设置为书籍控制器。打开默认路由配置文件fuel/app/config/routes.php，进行如下修改。
fuel/app/config/routes.php
<?php
return array (
'_root_' => 'book/index', // The default route
'_404_' => 'welcome/404', // The main 404 route
'hello(/:name)?' => array('welcome/hello', 'name' => 'hello'),
);
现在，请求 URL http://localhost:8080/ 将返回书籍控制器的索引页，如下所示，
第 6 步:创建数据库
使用以下命令在 MySQL 服务器中创建一个新数据库，
create database tutorialspoint_bookdb
然后，使用以下命令在数据库中创建一个表，
CREATE TABLE book ( id INT PRIMARY KEY AUTO_INCREMENT, title VARCHAR(80) NOT NULL, author VARCHAR(80) NOT NULL, price DECIMAL(10, 2) NOT NULL );
使用以下 SQL 语句向表中插入一些示例记录。
INSERT
INTO
book(title,
author,
price)
VALUES(
'The C Programming Language',
'Dennie Ritchie',
25.00
),(
'The C++ Programming Language',
'Bjarne Stroustrup',
80.00
),(
'C Primer Plus (5th Edition)',
'Stephen Prata',
45.00
),('Modern PHP', 'Josh Lockhart', 10.00),(
'Learning PHP, MySQL & JavaScript, 4th Edition',
'Robin Nixon',
30.00
)
步骤 7:配置数据库
使用位于 fuel/app/config 的数据库配置文件 db.php 配置数据库。
fuel/app/config/db.php
<?php
return array (
'development' => array (
'type' => 'mysqli',
'connection' => array (
'hostname' => 'localhost',
'port' => '3306',
'database' => 'tutorialspoint_bookdb',
'username' => 'root',
'password' => 'password',
'persistent' => false,
'compress' => false,
),
'identifier' => '`',
'table_prefix' => '',
'charset' => 'utf8',
'enable_cache' => true,
'profiling' => false,
'readonly' => false,
),
'production' => array (
'type' => 'mysqli',
'connection' => array (
'hostname' => 'localhost',
'port' => '3306',
'database' => 'tutorialspoint_bookdb',
'username' => 'root',
'password' => 'password',
'persistent' => false,
'compress' => false,
),
'identifier' => '`',
'table_prefix' => '',
'charset' => 'utf8',
'enable_cache' => true,
'profiling' => false,
'readonly' => false,
),
);
步骤 8:包含 Orm 包
更新主配置文件以包含 ORM 包。它位于"fuel/app/config/"。
fuel/app/config/config.php
'always_load' => array (
'packages' => array (
'orm'
),
),
步骤 9:创建模型
在位于"fuel/app/classes/model"的 book.php 中创建一个书籍模型。其定义如下 −
fuel/app/classes/model/book.php
<?php
class Model_Book extends Orm\Model {
protected static $_connection = 'production';
protected static $_table_name = 'book';
protected static $_primary_key = array('id');
protected static $_properties = array (
'id',
'title' => array (
'data_type' => 'varchar',
'label' => 'Book title',
'validation' => array (
'required',
'min_length' => array(3),
'max_length' => array(80)
),
'form' => array (
'type' => 'text'
),
),
'author' => array (
'data_type' => 'varchar',
'label' => 'Book author',
'validation' => array (
'required',
),
'form' => array (
'type' => 'text'
),
),
'price' => array (
'data_type' => 'decimal',
'label' => 'Book price',
'validation' => array (
'required',
),
'form' => array (
'type' => 'text'
),
),
);
protected static $_observers = array('Orm\Observer_Validation' => array (
'events' => array('before_save')
));
}
在这里，我们将数据库详细信息指定为模型的属性。它还具有验证详细信息。
步骤 10:显示书籍
更新书籍控制器中的索引操作以列出数据库中可用的书籍。
fuel/app/classes/controller/book.php
<?php
class Controller_Book extends Controller_Template {
public $template = 'layout';
public function action_index() {
// 创建视图对象
$view = View::forge('book/index');
// 从数据库获取书籍并将其设置到视图
$books = Model_Book::find('all');
$view->set('books', $books);
// 设置模板变量
$this->template->title = "Book index page";
$this->template->content = $view;
}
}
这里，我们使用 orm 从数据库获取图书详细信息，然后将图书详细信息传递给视图。
步骤 11:更新索引视图
更新位于"fuel/app/views/book"的视图文件 index.php。完整的更新代码如下，
fuel/app/views/book/index.php
<table class = "table">
<thead>
<tr>
<th>#</th>
<th>Title</th>
<th>Author</th>
<th>Price</th>
<th></th>
</tr>
</thead>
<tbody>
<?php
foreach($books as $book) {
?>
<tr>
<td><?php echo $book['id']; ?></td>
<td><?php echo $book['title']; ?></td>
<td><?php echo $book['author']; ?></td>
<td><?php echo $book['price']; ?></td>
<td>
<a href = "/book/edit/<?php echo $book['id']; ?>">Edit</a>
<a href = "/book/delete/<?php echo $book['id']; ?>">Delete</a>
</td>
</tr>
<?php
}
?>
</tbody>
</table>
<ul>
</ul>
现在，请求 URL http://localhost:8080/ 将显示以下页面 −
第 12 步:创建添加书籍的操作
创建将新书添加到书店的功能。在书籍控制器中创建一个新操作 action_add，如下所示，
public function action_add() {
// 创建新的字段集并添加书籍模型
$fieldset = Fieldset::forge('book')->add_model('Model_Book');
// 从字段集获取表单
$form = $fieldset->form();
// 向表单添加提交按钮
$form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit'));
// 构建表单并将当前页面设置为操作
$formHtml = $fieldset->build(Uri::create('book/add'));
$view = View::forge('book/add');
$view->set('form', $formHtml, false);
if (Input::param() != array()) {
try {
$book = Model_Book::forge();
$book->title = Input::param('title');
$book->author = Input::param('author');
$book->price = Input::param('price');
$book->save();
Response::redirect('book');
} catch (Orm\ValidationFailed $e) {
$view->set('errors', $e->getMessage(), false);
}
}
$this->template->title = "Book add page";
$this->template->content = $view; }
这里执行了以下两个过程，
使用 Fieldset 方法和 Book 模型构建图书表单以添加图书。
处理图书表单，当用户输入图书信息并提交表单时。可以通过检查 Input::param() 方法中是否有任何已提交的数据来找到它。处理表单涉及以下步骤 −
收集图书信息。
验证图书信息。我们已经设置在保存方法之前调用验证。如果验证失败，它将抛出 Orm\ValidationFailed 异常。
将图书信息存储到数据库中。
成功后将用户重定向到索引页。否则，再次显示表单。
我们同时执行这两个操作，即在同一操作中显示表单和处理表单。当用户首次调用该操作时，它将显示表单。当用户输入图书信息并提交数据时，它将处理表单。
步骤 13:创建添加图书操作的视图
创建添加图书操作的视图。创建一个新文件 fuel/app/views/book/add.php 并输入以下代码，
<style>
#form table {
width: 90%;
}
#form table tr {
width: 90%
}
#form table tr td {
width: 50%
}
#form input[type = text], select {
width: 100%;
padding: 12px 20px;
margin: 8px 0;
display: inline-block;
border: 1px solid #ccc;
border-radius: 4px;
box-sizing: border-box;
}
#form input[type = submit] {
width: 100%;
background-color: #3c3c3c;
color: white;
padding: 14px 20px;
margin: 8px 0;
border: none;
border-radius: 4px;
cursor: pointer;
}
#form div {
border-radius: 5px;
background-color: #f2f2f2;
padding: 20px;
}
</style>
<div id = "form">
<h2>Book form</h2>
<?php
if(isset($errors)) {
echo $errors;
}
echo $form;
?>
</div>
这里，我们仅显示在动作方法中创建的表单。此外，我们还会显示错误(如果有)。
步骤 14:检查添加书籍操作
请求 URL http://localhost:8080/book/add 或单击添加书籍导航链接将显示以下表单，
表单
包含数据的表单
输入书籍信息并提交页面后，书籍信息将存储到数据库中，页面将重定向到索引页面，如下所示。
包含新添加书籍的书籍列表
步骤 15:创建编辑书籍的操作
创建编辑和更新现有书籍信息的功能。在书籍控制器中创建一个新操作 action_edit，如下所示。
public function action_edit($id = false) {
if(!($book = Model_Book::find($id))) {
throw new HttpNotFoundException();
}
// 创建新的字段集并添加书籍模型
$fieldset = Fieldset::forge('book')->add_model('Model_Book');
$fieldset->populate($book);
// 从字段集获取表单
$form = $fieldset->form();
// 向表单添加提交按钮
$form->add('Submit', '', array('type' => 'submit', 'value' => 'Submit'));
// 构建表单并将当前页面设置为操作
$formHtml = $fieldset->build(Uri::create('book/edit/' . $id));
$view = View::forge('book/add');
$view->set('form', $formHtml, false);
if (Input::param() != array()) {
try {
$book->title = Input::param('title');
$book->author = Input::param('author');
$book->price = Input::param('price');
$book->save();
Response::redirect('book');
} catch (Orm\ValidationFailed $e) {
$view->set('errors', $e->getMessage(), false);
}
}
$this->template->title = "Book edit page";
$this->template->content = $view;
}
它与添加操作类似，不同之处在于它在处理页面之前通过 id 搜索请求的书籍。如果在数据库中找到任何书籍信息，它将继续并在表单中显示书籍信息。否则，它将抛出文件未找到异常并退出。
步骤 16:创建编辑操作的视图
创建编辑书籍操作的视图。在这里，我们使用与添加操作相同的视图。
步骤 17:检查编辑书籍操作。
单击书籍列表页面中任何书籍的编辑链接，它将显示相应的书籍表单，如下所示 −
包含书籍详细信息的表单
步骤 18:创建删除书籍的操作
创建从书店删除书籍的功能。在书籍控制器中创建一个新动作action_delete，如下所示，
public function action_delete($id = null) {
if ( ! ($book = Model_Book::find($id))) {
throw new HttpNotFoundException();
} else {
$book->delete();
}
Response::redirect('book');
}
在这里，我们使用提供的书籍 ID 检查数据库中是否存在书籍。如果找到该书籍，则将其删除并重定向到索引页。否则，将显示页面未找到信息。
步骤 19:检查删除操作
通过单击书籍列表页面中的删除链接检查删除操作。它将删除请求的书籍，然后再次重定向到索引页。
最后，创建添加、编辑、删除和列出书籍信息的所有功能。
与其他基于 MVC 的 PHP 框架相比，FuelPHP 简单、灵活、可扩展且易于配置。它提供了现代 MVC 框架的所有功能。它可以按原样使用，也可以完全更改以满足我们的需求。最重要的是，它是 Web 开发的绝佳选择。
