[TOC]
# 教程：INVO
在第二篇教程中，我们将解释一个更完整的应用程序，以便更深入地了解使用Phalcon进行开发。INVO是我们创建的示例应用程序之一。INVO是一个小型网站，允许用户生成发票并执行其他任务，例如管理客户和产品。您可以从[Github](https://github.com/phalcon/invo)克隆其代码。
INVO是使用客户端框架[Bootstrap](http://getbootstrap.com/)制作的。虽然应用程序不会生成实际的发票，但它仍然可以作为一个示例来说明框架的工作原理。
## 项目结构
在文档根目录中克隆项目后，您将看到以下结构：
```bash
invo/
app/
config/
controllers/
forms/
library/
logs/
models/
plugins/
views/
cache/
volt/
docs/
public/
css/
fonts/
js/
schemas/
```
如您所知，Phalcon没有为应用程序开发强加特定的文件结构。该项目具有简单的MVC结构和更目录public。
在浏览器`http://localhost/invo`中打开应用程序后，您将看到如下内容：
该应用程序分为两个部分：前端和后端。前端是一个公共区域，访客可以接收有关INVO的信息并请求联系信息。后端是一个管理区域，注册用户可以在其中管理其产品和客户。
## 路由
INVO使用与Router组件内置的标准路由。这些路由符合以下模式：`/:controller/:action/:params`。这意味着URI的第一部分是控制器，第二部分是控制器动作，其余部分是参数。
以下路由`/session/register`执行控制器`SessionController`及其操作`registerAction`。
## 配置
INVO有一个配置文件，用于设置应用程序中的常规参数。该文件位于`app/config/config.ini`，并加载到应用程序引导程序的第一行（`public/index.php`）：
```php
<?php
use Phalcon\Config\Adapter\Ini as ConfigIni;
// ...
// Read the configuration
$config = new ConfigIni(
APP_PATH . 'app/config/config.ini'
);
```
Phalcon Config（`Phalcon\Config`）允许我们以面向对象的方式操作文件。在这个例子中，我们使用ini文件进行配置，但Phalcon也有其他文件类型的`适配器`。配置文件包含以下设置：
```ini
[database]
host = localhost
username = root
password = secret
name = invo
[application]
controllersDir = app/controllers/
modelsDir = app/models/
viewsDir = app/views/
pluginsDir = app/plugins/
formsDir = app/forms/
libraryDir = app/library/
baseUri = /invo/
```
Phalcon没有任何预定义的设置约定。章节可以帮助我们根据需要组织选项。在此文件中，稍后将使用两个部分：`application`和`database`。
## 自动加载
引导文件（`public/index.php`）中出现的第二部分是自动加载器：
```php
<?php
/**
* Auto-loader configuration
*/
require APP_PATH . 'app/config/loader.php';
```
自动加载器注册一组目录，应用程序将在其中查找最终需要的类。
```php
<?php
$loader = new Phalcon\Loader();
// We're a registering a set of directories taken from the configuration file
$loader->registerDirs(
[
APP_PATH . $config->application->controllersDir,
APP_PATH . $config->application->pluginsDir,
APP_PATH . $config->application->libraryDir,
APP_PATH . $config->application->modelsDir,
APP_PATH . $config->application->formsDir,
]
);
$loader->register();
```
请注意，上面的代码已注册配置文件中定义的目录。唯一没有注册的目录是viewsDir，因为它包含HTML + PHP文件但没有类。另外，请注意我们使用一个名为APP_PATH的常量。此常量在bootstrap（`public/index.php`）中定义，以允许我们引用项目的根目录：
```php
<?php
// ...
define(
'APP_PATH',
realpath('..') . '/'
);
```
## 注册服务
引导程序中需要的另一个文件是（`app/config/services.php`）。该文件允许我们组织INVO使用的服务。
```php
<?php
/**
* Load application services
*/
require APP_PATH . 'app/config/services.php';
```
使用闭包来实现服务注册，以便延迟加载所需的组件：
```php
<?php
use Phalcon\Mvc\Url as UrlProvider;
// ...
/**
* The URL component is used to generate all kind of URLs in the application
*/
$di->set(
'url',
function () use ($config) {
$url = new UrlProvider();
$url->setBaseUri(
$config->application->baseUri
);
return $url;
}
);
```
我们稍后会深入讨论这个文件。
## 处理请求
如果我们跳到文件的末尾（`public/index.php`），请求最终由`Phalcon\Mvc\Application`处理，它初始化并执行使应用程序运行所需的所有内容：
```php
<?php
use Phalcon\Mvc\Application;
// ...
$application = new Application($di);
$response = $application->handle();
$response->send();
```
## 依赖注入
在上面代码块的第一行中，Application类构造函数接收变量`$di`作为参数。这个变量的目的是什么？Phalcon是一个高度分离的框架，因此我们需要一个充当胶水的组件，以使一切工作在一起。该组件是`Phalcon\Di`.它是一个服务容器，它还执行依赖注入和服务定位，实例化应用程序所需的所有组件。
在容器中注册服务的方法有很多种。在INVO中，大多数服务已使用匿名函数/闭包进行注册。由于这个原因，对象以惰性方式实例化，减少了应用程序所需的资源。
例如，在以下摘录中注册会话服务。只有在应用程序需要访问会话数据时才会调用匿名函数：
```php
<?php
use Phalcon\Session\Adapter\Files as Session;
// ...
// Start the session the first time a component requests the session service
$di->set(
'session',
function () {
$session = new Session();
$session->start();
return $session;
}
);
```
在这里，我们可以自由更改适配器，执行额外的初始化等等。请注意，该服务是使用名称`session`注册的。这是一种允许框架识别服务容器中的活动服务的约定。
请求可以使用许多服务，并且单独注册每个服务可能是一项繁琐的任务。因此，该框架提供了一个名为`Phalcon\Di\FactoryDefault`的`Phalcon\Di`变体，其任务是注册提供全栈框架的所有服务。
```php
<?php
use Phalcon\Di\FactoryDefault;
// ...
// The FactoryDefault Dependency Injector automatically registers the
// right services providing a full-stack framework
$di = new FactoryDefault();
```
它将大多数服务与框架提供的组件作为标准注册。如果我们需要覆盖某些服务的定义，我们可以像上面使用`session`或`url`一样重新设置它。这就是变量`$di`存在的原因。
## 登录应用程序
登录工具将允许我们处理后端控制器。后端控制器和前端控制器之间的分离是合乎逻辑的。所有控制器都位于同一目录（`app/controllers/`）中。
要进入系统，用户必须拥有有效的用户名和密码。用户存储在数据库`invo`中的表 `users`中。
在我们开始会话之前，我们需要在应用程序中配置与数据库的连接。在服务容器中使用连接信息设置名为`db`的服务。与自动加载器一样，我们再次从配置文件中获取参数以配置服务：
```php
<?php
use Phalcon\Db\Adapter\Pdo\Mysql as DbAdapter;
// ...
// Database connection is created based on parameters defined in the configuration file
$di->set(
'db',
function () use ($config) {
return new DbAdapter(
[
'host' => $config->database->host,
'username' => $config->database->username,
'password' => $config->database->password,
'dbname' => $config->database->name,
]
);
}
);
```
在这里，我们返回一个MySQL连接适配器的实例。如果需要，您可以执行额外操作，例如添加记录器，分析器或更改适配器，根据需要进行设置。
以下简单表单（`app/views/session/index.volt`）请求登录信息。我们删除了一些HTML代码，以使示例更简洁：
```twig
{{ form('session/start') }}
<fieldset>
<div>
<label for='email'>
Username/Email
</label>
<div>
{{ text_field('email') }}
</div>
</div>
<div>
<label for='password'>
Password
</label>
<div>
{{ password_field('password') }}
</div>
</div>
<div>
{{ submit_button('Login') }}
</div>
</fieldset>
{{ endForm() }}
```
我们开始使用`Volt`，而不是使用原始PHP作为上一个教程。这是一个内置的模板引擎，受`Jinja`的启发，提供了一种更简单友好的语法来创建模板。在你熟悉`Volt`之前不会花太多时间。
`SessionController::startAction`函数（`app/controllers/SessionController.php`）的任务是验证表单中输入的数据，包括检查数据库中的有效用户：
```php
<?php
class SessionController extends ControllerBase
{
// ...
private function _registerSession($user)
{
$this->session->set(
'auth',
[
'id' => $user->id,
'name' => $user->name,
]
);
}
/**
* This action authenticate and logs a user into the application
*/
public function startAction()
{
if ($this->request->isPost()) {
// Get the data from the user
$email = $this->request->getPost('email');
$password = $this->request->getPost('password');
// Find the user in the database
$user = Users::findFirst(
[
"(email = :email: OR username = :email:) AND password = :password: AND active = 'Y'",
'bind' => [
'email' => $email,
'password' => sha1($password),
]
]
);
if ($user !== false) {
$this->_registerSession($user);
$this->flash->success(
'Welcome ' . $user->name
);
// Forward to the 'invoices' controller if the user is valid
return $this->dispatcher->forward(
[
'controller' => 'invoices',
'action' => 'index',
]
);
}
$this->flash->error(
'Wrong email/password'
);
}
// Forward to the login form again
return $this->dispatcher->forward(
[
'controller' => 'session',
'action' => 'index',
]
);
}
}
```
为简单起见，我们使用`sha1`在数据库中存储密码哈希，但是，在实际应用中不建议使用此算法，而是使用`bcrypt`。
请注意，在控制器中访问多个公共属性，如：`$this->flash`，`$this->request` 或`$this->session`。这些是早期服务容器中定义的服务（`app/config/services.php`）。当它们第一次被访问时，它们作为控制器的一部分被注入。这些服务是`共享`的，这意味着无论我们调用它们的位置如何，我们总是访问同一个实例。例如，这里我们调用`session`服务，然后将用户身份存储在变量`auth`中：
```php
<?php
$this->session->set(
'auth',
[
'id' => $user->id,
'name' => $user->name,
]
);
```
本节的另一个重要方面是如何将用户验证为有效用户，首先我们验证请求是否已使用方法`POST`进行：
```php
<?php
if ($this->request->isPost()) {
// ...
}
```
然后，我们从表单中接收参数：
```php
<?php
$email = $this->request->getPost('email');
$password = $this->request->getPost('password');
```
现在，我们必须检查是否有一个用户具有相同的用户名或电子邮件和密码：
```php
<?php
$user = Users::findFirst(
[
"(email = :email: OR username = :email:) AND password = :password: AND active = 'Y'",
'bind' => [
'email' => $email,
'password' => sha1($password),
]
]
);
```
注意，使用'bound parameters'，占位符`:email:`和`:password:`放置在值应该的位置，然后使用参数`bind`绑定值。这可以安全地替换这些列的值，而不会有SQL注入的风险。
如果用户有效，我们会在会话中注册并将他/她转发到dashboard：
```php
<?php
if ($user !== false) {
$this->_registerSession($user);
$this->flash->success(
'Welcome ' . $user->name
);
return $this->dispatcher->forward(
[
'controller' => 'invoices',
'action' => 'index',
]
);
}
```
如果用户不存在，我们会再次将用户转发回显示表单的操作：
```php
<?php
return $this->dispatcher->forward(
[
'controller' => 'session',
'action' => 'index',
]
);
```
## 后端安全
后端是一个私有区域，只有注册用户才能访问。因此，有必要检查只有注册用户才能访问这些控制器。如果您没有登录到应用程序并尝试访问，例如，产品控制器（私有），您将看到如下屏幕：
每当有人尝试访问任何控制器/操作时，应用程序都会验证当前角色（在session中）是否可以访问它，否则它会显示如上所述的消息并将流转发到主页。
现在让我们看看应用程序如何实现这一点。首先要知道的是，有一个名为`Dispatcher`的组件。它被告知`Routing`组件找到的路由。然后，它负责加载适当的控制器并执行相应的操作方法。
通常，框架会自动创建`Dispatcher`。在我们的例子中，我们希望在执行所需操作之前执行验证，检查用户是否可以访问它。为此，我们通过在引导程序中创建函数来替换组件：
```php
<?php
use Phalcon\Mvc\Dispatcher;
// ...
/**
* MVC dispatcher
*/
$di->set(
'dispatcher',
function () {
// ...
$dispatcher = new Dispatcher();
return $dispatcher;
}
);
```
我们现在可以完全控制应用程序中使用的Dispatcher。框架中的许多组件触发允许我们修改其内部操作流程的事件。由于依赖注入组件充当组件的粘合剂，因此名为`EventsManager`的新组件允许我们拦截组件生成的事件，将事件路由到侦听器。
### 事件管理
`EventsManager`允许我们将侦听器附加到特定类型的事件。我们现在感兴趣的类型是“dispatch”。以下代码过滤`Dispatcher`生成的所有事件：
```php
<?php
use Phalcon\Mvc\Dispatcher;
use Phalcon\Events\Manager as EventsManager;
$di->set(
'dispatcher',
function () {
// Create an events manager
$eventsManager = new EventsManager();
// Listen for events produced in the dispatcher using the Security plugin
$eventsManager->attach(
'dispatch:beforeExecuteRoute',
new SecurityPlugin()
);
// Handle exceptions and not-found exceptions using NotFoundPlugin
$eventsManager->attach(
'dispatch:beforeException',
new NotFoundPlugin()
);
$dispatcher = new Dispatcher();
// Assign the events manager to the dispatcher
$dispatcher->setEventsManager($eventsManager);
return $dispatcher;
}
);
```
当触发一个名为`beforeExecuteRoute`的事件时，将通知以下插件：
```php
<?php
/**
* Check if the user is allowed to access certain action using the SecurityPlugin
*/
$eventsManager->attach(
'dispatch:beforeExecuteRoute',
new SecurityPlugin()
);
```
触发`beforeException`时，会通知其他插件：
```php
<?php
/**
* Handle exceptions and not-found exceptions using NotFoundPlugin
*/
$eventsManager->attach(
'dispatch:beforeException',
new NotFoundPlugin()
);
```
SecurityPlugin是一个位于（`app/plugins/SecurityPlugin.php`）的类。此类实现`beforeExecuteRoute`之前的方法。这与Dispatcher中生成的事件之一相同：
```php
<?php
use Phalcon\Events\Event;
use Phalcon\Mvc\User\Plugin;
use Phalcon\Mvc\Dispatcher;
class SecurityPlugin extends Plugin
{
// ...
public function beforeExecuteRoute(Event $event, Dispatcher $dispatcher)
{
// ...
}
}
```
钩子事件总是接收第一个参数，该参数包含所生成事件的上下文信息（`$event`），第二个参数是生成事件本身的对象（`$dispatcher`）。插件扩展`Phalcon\Mvc\User\Plugin`类并不是必须的，但通过这样做，他们可以更轻松地访问应用程序中可用的服务。
现在，我们将验证当前会话中的角色，检查用户是否具有使用ACL列表的访问权限。如果用户没有访问权限，我们会重定向到主屏幕，如前所述：
```php
<?php
use Phalcon\Acl;
use Phalcon\Events\Event;
use Phalcon\Mvc\User\Plugin;
use Phalcon\Mvc\Dispatcher;
class SecurityPlugin extends Plugin
{
// ...
public function beforeExecuteRoute(Event $event, Dispatcher $dispatcher)
{
// Check whether the 'auth' variable exists in session to define the active role
$auth = $this->session->get('auth');
if (!$auth) {
$role = 'Guests';
} else {
$role = 'Users';
}
// Take the active controller/action from the dispatcher
$controller = $dispatcher->getControllerName();
$action = $dispatcher->getActionName();
// Obtain the ACL list
$acl = $this->getAcl();
// Check if the Role have access to the controller (resource)
$allowed = $acl->isAllowed($role, $controller, $action);
if (!$allowed) {
// If he doesn't have access forward him to the index controller
$this->flash->error(
"You don't have access to this module"
);
$dispatcher->forward(
[
'controller' => 'index',
'action' => 'index',
]
);
// Returning 'false' we tell to the dispatcher to stop the current operation
return false;
}
}
}
```
### 获取ACL列表
在上面的例子中，我们使用`$this->getAcl()`方法获得了ACL。此方法也在插件中实现。现在我们将逐步解释如何构建访问控制列表（ACL）：
```php
<?php
use Phalcon\Acl;
use Phalcon\Acl\Role;
use Phalcon\Acl\Adapter\Memory as AclList;
// Create the ACL
$acl = new AclList();
// The default action is DENY access
$acl->setDefaultAction(
Acl::DENY
);
// Register two roles, Users is registered users
// and guests are users without a defined identity
$roles = [
'users' => new Role('Users'),
'guests' => new Role('Guests'),
];
foreach ($roles as $role) {
$acl->addRole($role);
}
```
现在，我们分别为每个区域定义资源。控制器名称是资源，其操作是对资源的访问：
```php
<?php
use Phalcon\Acl\Resource;
// ...
// Private area resources (backend)
$privateResources = [
'companies' => ['index', 'search', 'new', 'edit', 'save', 'create', 'delete'],
'products' => ['index', 'search', 'new', 'edit', 'save', 'create', 'delete'],
'producttypes' => ['index', 'search', 'new', 'edit', 'save', 'create', 'delete'],
'invoices' => ['index', 'profile'],
];
foreach ($privateResources as $resourceName => $actions) {
$acl->addResource(
new Resource($resourceName),
$actions
);
}
// Public area resources (frontend)
$publicResources = [
'index' => ['index'],
'about' => ['index'],
'register' => ['index'],
'errors' => ['show404', 'show500'],
'session' => ['index', 'register', 'start', 'end'],
'contact' => ['index', 'send'],
];
foreach ($publicResources as $resourceName => $actions) {
$acl->addResource(
new Resource($resourceName),
$actions
);
}
```
ACL现在知道现有控制器及其相关操作。角色`Users`可以访问前端和后端的所有资源。角色`Guests` 只能访问公共区域：
```php
<?php
// Grant access to public areas to both users and guests
foreach ($roles as $role) {
foreach ($publicResources as $resource => $actions) {
$acl->allow(
$role->getName(),
$resource,
'*'
);
}
}
// Grant access to private area only to role Users
foreach ($privateResources as $resource => $actions) {
foreach ($actions as $action) {
$acl->allow(
'Users',
$resource,
$action
);
}
}
```
## 使用 CRUD
后端通常提供允许用户操作数据的表单。继续对INVO的解释，我们现在讨论CRUD的创建，这是Phalcon将使用表单，验证，分页器等方式为您提供的一项非常常见的任务。
大多数操纵INVO中数据的选项（公司，产品和产品类型）都是使用基本和通用 [CRUD](http://en.wikipedia.org/wiki/Create,_read,_update_and_delete) （创建，读取，更新和删除）开发的。每个CRUD包含以下文件：
```bash
invo/
app/
controllers/
ProductsController.php
models/
Products.php
forms/
ProductsForm.php
views/
products/
edit.volt
index.volt
new.volt
search.volt
```
每个控制器都有以下操作：
```php
<?php
class ProductsController extends ControllerBase
{
/**
* The start action, it shows the 'search' view
*/
public function indexAction()
{
// ...
}
/**
* Execute the 'search' based on the criteria sent from the 'index'
* Returning a paginator for the results
*/
public function searchAction()
{
// ...
}
/**
* Shows the view to create a 'new' product
*/
public function newAction()
{
// ...
}
/**
* Shows the view to 'edit' an existing product
*/
public function editAction()
{
// ...
}
/**
* Creates a product based on the data entered in the 'new' action
*/
public function createAction()
{
// ...
}
/**
* Updates a product based on the data entered in the 'edit' action
*/
public function saveAction()
{
// ...
}
/**
* Deletes an existing product
*/
public function deleteAction($id)
{
// ...
}
}
```
## 搜索表单
每个CRUD都以搜索表单开头。此表单显示表具有的每个字段（产品），允许用户为任何字段创建搜索条件。`products`表与表`products_types`有关系。在这种情况下，我们先前查询了此表中的记录，以便于按该字段进行搜索：
```php
<?php
/**
* The start action, it shows the 'search' view
*/
public function indexAction()
{
$this->persistent->searchParams = null;
$this->view->form = new ProductsForm();
}
```
`ProductsForm`表单的一个实例（`app/forms/ProductsForm.php`）被传递给视图。此表单定义了用户可见的字段：
```php
<?php
use Phalcon\Forms\Form;
use Phalcon\Forms\Element\Text;
use Phalcon\Forms\Element\Hidden;
use Phalcon\Forms\Element\Select;
use Phalcon\Validation\Validator\Email;
use Phalcon\Validation\Validator\PresenceOf;
use Phalcon\Validation\Validator\Numericality;
class ProductsForm extends Form
{
/**
* Initialize the products form
*/
public function initialize($entity = null, $options = [])
{
if (!isset($options['edit'])) {
$element = new Text('id');
$element->setLabel('Id');
$this->add($element);
} else {
$this->add(new Hidden('id'));
}
$name = new Text('name');
$name->setLabel('Name');
$name->setFilters(
[
'striptags',
'string',
]
);
$name->addValidators(
[
new PresenceOf(
[
'message' => 'Name is required',
]
)
]
);
$this->add($name);
$type = new Select(
'profilesId',
ProductTypes::find(),
[
'using' => [
'id',
'name',
],
'useEmpty' => true,
'emptyText' => '...',
'emptyValue' => '',
]
);
$this->add($type);
$price = new Text('price');
$price->setLabel('Price');
$price->setFilters(
[
'float',
]
);
$price->addValidators(
[
new PresenceOf(
[
'message' => 'Price is required',
]
),
new Numericality(
[
'message' => 'Price is required',
]
),
]
);
$this->add($price);
}
}
```
使用基于表单组件提供的元素的面向对象方案声明表单。每个元素都遵循几乎相同的结构：
```php
<?php
// Create the element
$name = new Text('name');
// Set its label
$name->setLabel('Name');
// Before validating the element apply these filters
$name->setFilters(
[
'striptags',
'string',
]
);
// Apply this validators
$name->addValidators(
[
new PresenceOf(
[
'message' => 'Name is required',
]
)
]
);
// Add the element to the form
$this->add($name);
```
其他元素也以这种形式使用：
```php
<?php
// Add a hidden input to the form
$this->add(
new Hidden('id')
);
// ...
$productTypes = ProductTypes::find();
// Add a HTML Select (list) to the form
// and fill it with data from 'product_types'
$type = new Select(
'profilesId',
$productTypes,
[
'using' => [
'id',
'name',
],
'useEmpty' => true,
'emptyText' => '...',
'emptyValue' => '',
]
);
```
请注意，`ProductTypes::find()`包含使用`Phalcon\Tag::select()`填充SELECT标记所需的数据。将表单传递给视图后，可以将其呈现并呈现给用户：
```twig
{{ form('products/search') }}
<h2>
Search products
</h2>
<fieldset>
{% for element in form %}
<div class='control-group'>
{{ element.label(['class': 'control-label']) }}
<div class='controls'>
{{ element }}
</div>
</div>
{% endfor %}
<div class='control-group'>
{{ submit_button('Search', 'class': 'btn btn-primary') }}
</div>
</fieldset>
{{ endForm() }}
```
这会产生以下HTML：
```html
<form action='/invo/products/search' method='post'>
<h2>
Search products
</h2>
<fieldset>
<div class='control-group'>
<label for='id' class='control-label'>Id</label>
<div class='controls'>
<input type='text' id='id' name='id' />
</div>
</div>
<div class='control-group'>
<label for='name' class='control-label'>Name</label>
<div class='controls'>
<input type='text' id='name' name='name' />
</div>
</div>
<div class='control-group'>
<label for='profilesId' class='control-label'>profilesId</label>
<div class='controls'>
<select id='profilesId' name='profilesId'>
<option value=''>...</option>
<option value='1'>Vegetables</option>
<option value='2'>Fruits</option>
</select>
</div>
</div>
<div class='control-group'>
<label for='price' class='control-label'>Price</label>
<div class='controls'>
<input type='text' id='price' name='price' />
</div>
</div>
<div class='control-group'>
<input type='submit' value='Search' class='btn btn-primary' />
</div>
</fieldset>
</form>
```
当提交表单时，在控制器中执行`search`动作，该控制器基于用户输入的数据执行搜索。
## 执行搜索
`search` 操作有两种行为。当通过POST访问时，它会根据表单发送的数据执行搜索，但是当通过GET访问时，它会移动分页器中的当前页面。为区分HTTP方法，我们使用`Request`组件进行检查：
```php
<?php
/**
* Execute the 'search' based on the criteria sent from the 'index'
* Returning a paginator for the results
*/
public function searchAction()
{
if ($this->request->isPost()) {
// Create the query conditions
} else {
// Paginate using the existing conditions
}
// ...
}
```
在 `Phalcon\Mvc\Model\Criteria`的帮助下，我们可以根据表单发送的数据类型和值智能地创建搜索条件：
```php
<?php
$query = Criteria::fromInput(
$this->di,
'Products',
$this->request->getPost()
);
```
此方法验证哪些值与''（空字符串）和null不同，并将它们考虑在内以创建搜索条件：
* 如果字段数据类型是文本或类似（char，varchar，text等），它使用SQL的`like`运算符来过滤结果。
* 如果数据类型不是文本或类似的，它将使用 `=` 运算符。
此外，`Criteria`忽略所有与表中的任何字段都不匹配的`$_POST`变量。使用`绑定参数`自动转义值。
现在，我们将生成的参数存储在控制器的会话包中：
```php
<?php
$this->persistent->searchParams = $query->getParams();
```
会话包是控制器中的一个特殊属性，它在使用会话服务的请求之间保持不变。访问时，此属性会在每个控制器中注入一个独立的`Phalcon\Session\Bag`实例。
然后，基于构建的参数，我们执行查询：
```php
<?php
$products = Products::find($parameters);
if (count($products) === 0) {
$this->flash->notice(
'The search did not found any products'
);
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'index',
]
);
}
```
如果搜索未返回任何产品，我们会再次将用户转发给索引操作。让我们假装搜索返回结果，然后我们创建一个分页器来轻松浏览它们：
```php
<?php
use Phalcon\Paginator\Adapter\Model as Paginator;
// ...
$paginator = new Paginator(
[
'data' => $products, // Data to paginate
'limit' => 5, // Rows per page
'page' => $numberPage, // Active page
]
);
// Get active page in the paginator
$page = $paginator->getPaginate();
```
最后我们传递返回的页面到视图：
```php
<?php
$this->view->page = $page;
```
在视图（`app/views/products/search.volt`）中，我们遍历与当前页面对应的结果，向用户显示当前页面中的每一行：
```twig
{% for product in page.items %}
{% if loop.first %}
<table>
<thead>
<tr>
<th>Id</th>
<th>Product Type</th>
<th>Name</th>
<th>Price</th>
<th>Active</th>
</tr>
</thead>
<tbody>
{% endif %}
<tr>
<td>
{{ product.id }}
</td>
<td>
{{ product.getProductTypes().name }}
</td>
<td>
{{ product.name }}
</td>
<td>
{{ '%.2f'|format(product.price) }}
</td>
<td>
{{ product.getActiveDetail() }}
</td>
<td width='7%'>
{{ link_to('products/edit/' ~ product.id, 'Edit') }}
</td>
<td width='7%'>
{{ link_to('products/delete/' ~ product.id, 'Delete') }}
</td>
</tr>
{% if loop.last %}
</tbody>
<tbody>
<tr>
<td colspan='7'>
<div>
{{ link_to('products/search', 'First') }}
{{ link_to('products/search?page=' ~ page.before, 'Previous') }}
{{ link_to('products/search?page=' ~ page.next, 'Next') }}
{{ link_to('products/search?page=' ~ page.last, 'Last') }}
<span class='help-inline'>{{ page.current }} of {{ page.total_pages }}</span>
</div>
</td>
</tr>
</tbody>
</table>
{% endif %}
{% else %}
No products are recorded
{% endfor %}
```
上面的例子中有很多东西值得详细说明。首先，使用Volt `for`来遍历当前页面中的活动项目。Volt为PHP `foreach`提供了更简单的语法。
```twig
{% for product in page.items %}
```
与在PHP中的以下内容相同：
```php
<?php foreach ($page->items as $product) { ?>
```
整个`for` 块提供以下内容：
```twig
{% for product in page.items %}
{% if loop.first %}
Executed before the first product in the loop
{% endif %}
Executed for every product of page.items
{% if loop.last %}
Executed after the last product is loop
{% endif %}
{% else %}
Executed if page.items does not have any products
{% endfor %}
```
现在，您可以返回视图并查看每个块正在执行的操作。`product`中的每个字段都相应打印：
```twig
<tr>
<td>
{{ product.id }}
</td>
<td>
{{ product.productTypes.name }}
</td>
<td>
{{ product.name }}
</td>
<td>
{{ '%.2f'|format(product.price) }}
</td>
<td>
{{ product.getActiveDetail() }}
</td>
<td width='7%'>
{{ link_to('products/edit/' ~ product.id, 'Edit') }}
</td>
<td width='7%'>
{{ link_to('products/delete/' ~ product.id, 'Delete') }}
</td>
</tr>
```
正如我们之前看到的那样，使用`product.id`与PHP中的相同：`$product->id`，我们使用`product.name`进行相同的操作。其他字段的呈现方式不同，例如，让我们将焦点放在`product.productTypes.name`中。要理解这一部分，我们必须查看Product模型（`app/models/Products.php`）：
```php
<?php
use Phalcon\Mvc\Model;
/**
* Products
*/
class Products extends Model
{
// ...
/**
* Products initializer
*/
public function initialize()
{
$this->belongsTo(
'product_types_id',
'ProductTypes',
'id',
[
'reusable' => true,
]
);
}
// ...
}
```
模型可以有一个名为`initialize()`的方法，每个请求调用一次该方法，并为ORM初始化模型。在这种情况下，通过定义此模型与另一个名为“ProductTypes”的模型具有一对多关系来初始化“Products”。
```php
<?php
$this->belongsTo(
'product_types_id',
'ProductTypes',
'id',
[
'reusable' => true,
]
);
```
这意味着，`Products`中的本地属性`product_types_id`在其属性`id`中与`ProductTypes`模型具有一对多的关系。通过定义此关系，我们可以使用以下方法访问产品类型的名称：
```twig
<td>{{ product.productTypes.name }}</td>
```
使用Volt过滤器格式化字段`price` ：
```twig
<td>{{ '%.2f'|format(product.price) }}</td>
```
在普通的PHP中，这将是：
```php
<?php echo sprintf('%.2f', $product->price) ?>
```
打印产品是否处于活动状态使用模型中实现的帮助程序：
```php
<td>{{ product.getActiveDetail() }}</td>
```
此方法在模型中定义。
## 创建和更新记录
现在让我们看看CRUD如何创建和更新记录。在`new`视图和`edit`视图中，用户输入的数据将分别发送到执行创建和更新产品操作的`create`和`save` 操作。
在创建案例中，我们恢复提交的数据并将其分配给新的`Products`实例：
```php
<?php
/**
* Creates a product based on the data entered in the 'new' action
*/
public function createAction()
{
if (!$this->request->isPost()) {
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'index',
]
);
}
$form = new ProductsForm();
$product = new Products();
$product->id = $this->request->getPost('id', 'int');
$product->product_types_id = $this->request->getPost('product_types_id', 'int');
$product->name = $this->request->getPost('name', 'striptags');
$product->price = $this->request->getPost('price', 'double');
$product->active = $this->request->getPost('active');
// ...
}
```
还记得我们在产品表单中定义的过滤器吗？在分配给对象`$product`之前过滤数据。这种过滤是可选的;ORM还会转义输入数据并根据列类型执行其他转换：
```php
<?php
// ...
$name = new Text('name');
$name->setLabel('Name');
// Filters for name
$name->setFilters(
[
'striptags',
'string',
]
);
// Validators for name
$name->addValidators(
[
new PresenceOf(
[
'message' => 'Name is required',
]
)
]
);
$this->add($name);
```
保存时，我们将知道数据是否符合以`ProductsForm`形式（`app/forms/ProductsForm.php`）形式实现的业务规则和验证：
```php
<?php
// ...
$form = new ProductsForm();
$product = new Products();
// Validate the input
$data = $this->request->getPost();
if (!$form->isValid($data, $product)) {
$messages = $form->getMessages();
foreach ($messages as $message) {
$this->flash->error($message);
}
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'new',
]
);
}
```
最后，如果表单没有返回任何验证消息，我们可以保存产品实例：
```php
<?php
// ...
if ($product->save() === false) {
$messages = $product->getMessages();
foreach ($messages as $message) {
$this->flash->error($message);
}
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'new',
]
);
}
$form->clear();
$this->flash->success(
'Product was created successfully'
);
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'index',
]
);
```
现在，在更新产品的情况下，我们必须首先向用户显示当前在编辑记录中的数据：
```php
<?php
/**
* Edits a product based on its id
*/
public function editAction($id)
{
if (!$this->request->isPost()) {
$product = Products::findFirstById($id);
if (!$product) {
$this->flash->error(
'Product was not found'
);
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'index',
]
);
}
$this->view->form = new ProductsForm(
$product,
[
'edit' => true,
]
);
}
}
```
通过将模型作为第一个参数传递，找到的数据绑定到表单。由于这个原因，用户可以更改任何值，然后通过 `save` 操作将其发送回数据库：
```php
<?php
/**
* Updates a product based on the data entered in the 'edit' action
*/
public function saveAction()
{
if (!$this->request->isPost()) {
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'index',
]
);
}
$id = $this->request->getPost('id', 'int');
$product = Products::findFirstById($id);
if (!$product) {
$this->flash->error(
'Product does not exist'
);
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'index',
]
);
}
$form = new ProductsForm();
$data = $this->request->getPost();
if (!$form->isValid($data, $product)) {
$messages = $form->getMessages();
foreach ($messages as $message) {
$this->flash->error($message);
}
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'new',
]
);
}
if ($product->save() === false) {
$messages = $product->getMessages();
foreach ($messages as $message) {
$this->flash->error($message);
}
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'new',
]
);
}
$form->clear();
$this->flash->success(
'Product was updated successfully'
);
return $this->dispatcher->forward(
[
'controller' => 'products',
'action' => 'index',
]
);
}
```
## 用户组件
应用程序的所有UI元素和视觉样式主要通过[Bootstrap](http://getbootstrap.com/)实现。某些元素（例如导航栏）会根据应用程序的状态而更改。例如，在右上角，如果用户登录到应用程序，则`Log in / Sign Up`链接将更改为`Log out`。
应用程序的这一部分在组件`Elements`（`app/library/Elements.php`）中实现。
```php
<?php
use Phalcon\Mvc\User\Component;
class Elements extends Component
{
public function getMenu()
{
// ...
}
public function getTabs()
{
// ...
}
}
```
此类扩展了`Phalcon\Mvc\User\Component`。它不是用于扩展具有此类的组件，但它有助于更快地访问应用程序服务。现在，我们将在服务容器中注册我们的第一个用户组件：
```php
<?php
// Register a user component
$di->set(
'elements',
function () {
return new Elements();
}
);
```
作为视图中的控制器，插件或组件，该组件还可以访问容器中注册的服务，只需访问与以前注册的服务同名的属性：
```twig
<div class='navbar navbar-fixed-top'>
<div class='navbar-inner'>
<div class='container'>
<a class='btn btn-navbar' data-toggle='collapse' data-target='.nav-collapse'>
<span class='icon-bar'></span>
<span class='icon-bar'></span>
<span class='icon-bar'></span>
</a>
<a class='brand' href='#'>INVO</a>
{{ elements.getMenu() }}
</div>
</div>
</div>
<div class='container'>
{{ content() }}
<hr>
<footer>
<p>© Company 2017</p>
</footer>
</div>
```
重要的是：
```twig
{{ elements.getMenu() }}
```
## 动态更改标题
当您在一个选项和另一个选项之间浏览时，会看到标题会动态更改，指示我们当前的工作位置。这是在每个控制器初始化程序中实现的：
```php
<?php
class ProductsController extends ControllerBase
{
public function initialize()
{
// Set the document title
$this->tag->setTitle(
'Manage your product types'
);
parent::initialize();
}
// ...
}
```
注意，也调用方法`parent::initialize()` ，它向标题添加更多数据：
```php
<?php
use Phalcon\Mvc\Controller;
class ControllerBase extends Controller
{
protected function initialize()
{
// Prepend the application name to the title
$this->tag->prependTitle('INVO | ');
}
// ...
}
```
最后，标题打印在主视图中（app/views/index.volt）：
```php
<!DOCTYPE html>
<html>
<head>
<?php echo $this->tag->getTitle(); ?>
</head>
<!-- ... -->
</html>
```
- 常规
- Welcome
- 贡献
- 生成回溯
- 测试重现
- 单元测试
- 入门
- 安装
- Web服务器设置
- WAMP
- XAMPP
- 教程
- 基础教程
- 教程：创建一个简单的REST API
- 教程：Vökuró
- 提升性能
- 教程：INVO
- 开发环境
- Phalcon Compose (Docker)
- Nanobox
- Phalcon Box (Vagrant)
- 开发工具
- Phalcon开发者工具的安装
- Phalcon开发者工具的使用
- 调试应用程序
- 核心
- MVC应用
- 微应用
- 创建命令行（CLI）应用程序
- 依赖注入与服务定位
- MVC架构
- 服务
- 使用缓存提高性能
- 读取配置
- 上下文转义
- 类加载器
- 使用命名空间
- 日志
- 队列
- 数据库
- 数据库抽象层
- Phalcon查询语言（PHQL）
- ODM（对象文档映射器）
- 使用模型
- 模型行为
- ORM缓存
- 模型事件
- 模型元数据
- 模型关系
- 模型事务
- 验证模型
- 数据库迁移
- 分页
- 前端
- Assets管理
- 闪存消息
- 表单
- 图像
- 视图助手（标签）
- 使用视图
- Volt：模板引擎
- 业务逻辑
- 访问控制列表（ACL）
- 注解解析器
- 控制器
- 调度控制器
- 事件管理器
- 过滤与清理
- 路由
- 在session中存储数据
- 生成URL和路径
- 验证
- HTTP
- Cookies管理
- 请求环境
- 返回响应
- 安全
- 加密/解密
- 安全
- 国际化
- 国际化
- 多语言支持