ZendFramework2-秘籍-全-

ZendFramework2 秘籍（全）

原文：zh.annas-archive.org/md5/679d6eca2d8751050b9b962f44fe55f2

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

几年前，我的一个朋友向我介绍了 Zend Framework 1，从那时起我就成了它的粉丝。尽管第一个框架是一个真正的庞大框架，文档也不多，但我感觉框架的第二版有了很大的改进。功能丰富的工具箱，使这个框架（就我个人而言）成为最好的工作框架之一。

但正如我们可能都知道的，由于其功能极其丰富，学习曲线可能看起来非常陡峭。这就是为什么我觉得有必要将框架的所有重要部分写成小块，这样就不会让那些想要学习它的人（在这种情况下是你）感到不知所措。

这本书涵盖的内容

第一章, Zend Framework 2 基础，讲述了我们如何设置一个小型应用程序并运行它。依赖注入和配置也得到了处理。

第二章, 翻译和邮件处理，解释了国际化和本地化的重要性，以及在我们应用程序中发送和接收邮件的整体处理。

第三章, 处理和装饰表单，展示了如何创建表单。之后，它讨论了表单的过滤、验证和装饰。

第四章, 使用视图，涵盖了框架中将要讨论的最重要的部分之一，即视图的设置和渲染。

第五章, 配置和使用数据库，提供了数据库的配置和解释，这将使我们深入了解如何在我们的应用程序中充分利用它们。

第六章, 模块、模型和服务，主要讨论了模块是如何构建的，模型可以被激活，以及服务是如何定义的。

第七章, 处理身份验证，深入探讨了不同的用户认证方式以及我们如何创建自己的认证方法。

第八章, 优化性能，讨论了缓存的使用以及可用于缓存输出、操作码的方法，以及如何使用插件。

第九章, 捕获错误，教我们如何调试应用程序，处理异常，以及记录信息。

附录, 设置基本要素，展示了我们可以在哪里找到文档，如何设置开发环境，以及展示了 composer 的工作原理。

你需要这本书的内容

为了最好地跟随本书，我建议使用基于 Linux 的 Web 服务器，因为大多数食谱都是面向 Linux 的，而不是 Windows。如果您是 Windows 用户，您可能最好安装一个带有 Linux 的虚拟机，或者安装一个 Zend Server 社区版，以确保您的机器兼容于 Zend Framework 2 开发（您也可以不使用 Zend Server 这样做，但这会更方便）。

本书面向对象

《Zend Framework 2 烹饪秘籍》是为那些在 PHP 编程方面相当先进的 PHP 开发者准备的。对于那些对超出简单脚本页面组合的边界扩展知识有浓厚兴趣的开发者来说，本书也将非常有用。由于本书将讨论单元测试和 MVC，因此了解这些技术对读者来说是有益的，尽管开发应用程序的经验并非必不可少。

习惯用法

在本书中，您将找到多种文本样式，以区分不同类型的信息。以下是一些这些样式的示例及其含义的解释。

文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称如下所示："我们可以通过使用getFlags()方法，或者使用hasFlag()方法从消息中获取标志。"

代码块设置如下：

<?php
echo $this->dateFormat(
    // Format the current UNIX timestamp.
    time(),

    // Our date is to be a LONG date format.
    IntlDateFormatter::LONG,

    // We want to omit the time, defining this is 
    // optional as the default is NONE.
    IntlDateFormatter::NONE

);

当我们希望您注意代码块中的特定部分时，相关的行或项目将以粗体显示：

SampleModule/
  config/
    module.config.php
 language/
  src/
    SampleModule/
      Controller/
        IndexController.php
  view/
    samplemodule/
      index/
        index.phtml
  Module.php

任何命令行输入或输出都如下所示：

php composer.phar update

新术语和重要词汇以粗体显示。您在屏幕上看到的单词，例如在菜单或对话框中，在文本中如下所示："在我们已经做了所有能做的事情之后，点击确定，您可以选择保存我们的文件的位置。"

注意

警告或重要注意事项以如下框中的形式出现。

小贴士

小技巧和技巧如下所示。

读者反馈

我们欢迎读者的反馈。让我们知道您对这本书的看法——您喜欢什么或可能不喜欢什么。读者反馈对我们开发您真正从中获得最大收益的标题非常重要。

要向我们发送一般反馈，只需发送电子邮件到<feedback@packtpub.com>，并在邮件主题中提及书名。

如果您在某个主题领域有专业知识，并且您对撰写或为本书做出贡献感兴趣，请参阅我们的作者指南www.packtpub.com/authors。

客户支持

现在您已经是 Packt 图书的骄傲拥有者，我们有一些事情可以帮助您从您的购买中获得最大收益。

下载示例代码

您可以从www.packtpub.com购买的所有 Packt 书籍的账户中下载示例代码文件。如果您在其他地方购买了这本书，您可以访问www.packtpub.com/support并注册，以便将文件直接通过电子邮件发送给您。

勘误

尽管我们已经尽一切努力确保我们内容的准确性，但错误仍然可能发生。如果您在我们的某本书中发现错误——可能是文本或代码中的错误——如果您能向我们报告这一点，我们将不胜感激。通过这样做，您可以节省其他读者的挫败感，并帮助我们改进本书的后续版本。如果您发现任何勘误，请通过访问www.packtpub.com/submit-errata，选择您的书籍，点击勘误提交表单链接，并输入您的勘误详情来报告。一旦您的勘误得到验证，您的提交将被接受，勘误将被上传到我们的网站，或添加到该标题的现有勘误列表中，在“勘误”部分下。您可以通过从www.packtpub.com/support选择您的标题来查看现有勘误。

盗版

互联网上对版权材料的盗版是一个跨所有媒体的持续问题。在 Packt，我们非常重视我们版权和许可证的保护。如果您在互联网上发现我们作品的任何非法副本，无论形式如何，请立即提供位置地址或网站名称，以便我们可以寻求补救措施。

请通过链接mailto:copyright@packtpub.com与我们联系，并提供疑似盗版材料的链接。

我们感谢您在保护我们作者和提供有价值内容方面的帮助。

问题

如果您在本书的任何方面遇到问题，您可以通过链接mailto:questions@packtpub.com与我们联系，我们将尽力解决。

第一章。Zend Framework 2 基础知识

本章我们将涵盖：

设置 Zend Framework 2 项目
处理程序
理解依赖注入
利用配置来获得好处
事件管理器和 Bootstrap 类

简介

在本章中，我们将从头开始介绍一个基本的 Zend Framework 2 应用程序，从下载、设置到运行。如果您不熟悉 Zend Framework 2 的工作原理以及最佳安装方式，可以使用本章作为参考。在章节的后续部分，我们将通过查看依赖注入（DI）以及它如何帮助我们更高效地编码来对框架进行更深入的了解。最后，我们将更详细地介绍配置选项、EventManager和ModuleManager。

设置 Zend Framework 2 项目

没有什么比在我们的最爱框架中设置一个新的项目更令人兴奋的了。每次我们开始一个新的项目，我们都是从一张白纸开始。

准备工作

在您设置新的 Zend Framework 2 应用程序之前，您需要确保您已准备好以下项目：

一个运行 PHP 版本 5.3.3 或更高版本的 Apache 网络服务器，您可以通过网络浏览器访问它
Git

如果您没有准备好上述所有项目，您最好在继续阅读本章内容之前，阅读本食谱中提到的也见部分（我们本章中解释的每个主题都称为食谱）。

我们假设将在基于 Linux 的平台和 Apache 2 网络服务器上使用 Zend Framework 2；这意味着命令可能不会在 Windows 平台上直接工作。然而，Windows 用户可以通过在虚拟机上安装 Linux 来设置虚拟机，以充分利用本书。

要在 Windows 上安装虚拟机，我们可以使用一个名为 Oracle VM VirtualBox 的应用程序，它是免费提供的。我们可以访问www.virtualbox.org下载并安装 VirtualBox 的最新版本，我们还可以访问 VirtualBoxes (virtualboxes.org/images/ubuntu)并从那里下载一个预配置的虚拟机。

在 VirtualBoxes 网站上，我们只需点击列表中最新的 Ubuntu（Linux 的一个发行版）链接，请注意那里显示的用户名和密码，因为我们稍后会需要它们来登录。一旦下载了镜像，就可以按照 VirtualBoxes 网站上可找到的文档说明将其准备好（virtualboxes.org/doc/register-and-load-a-downloaded-image）。

假设图像已导入，我们可以轻松启动虚拟机并输入与下载的虚拟机一起提供的用户名和密码。

登录到虚拟机后，我们需要确保 Git 已安装，这可以通过输入以下命令轻松完成（请注意，美元符号是命令提示符，而不是我们需要输入的命令）：

$ sudo apt-get install git

如果 Git 未安装，系统将提示您安装 Git，这可以通过按Y键，然后按Enter键来完成；另一方面，如果 Git 已经安装，则不会进行任何操作，并告诉您它已经安装。

如何做到这一点…

首先，我们需要 Zend Framework 2 骨架，这样我们就可以轻松地创建一个新项目。骨架是一个模板结构，可以用来开始使用应用程序进行开发，在这种情况下，它为我们创建了一个在 Zend Framework 中开发的模板。幸运的是，这样做相对简单，几乎从不引起任何问题，当它发生时，通常与 Git 无法检索代码有关。当 Git 无法检索骨架时，请确保命令中没有拼写错误，并且 Git 有外部访问权限（我们可以通过输入ping Github.com并查看是否收到响应来测试这一点）。

我们将要使用的方法称为克隆，通过名为 Git 的版本控制系统。克隆源代码将确保我们总是获取开发者（在这种情况下是 Zend 本身）已上传的最新版本。

克隆骨架

我们可以通过以下命令克隆骨架——实际上，在 GitHub 上几乎可以克隆任何东西：

$ git clone git://github.com/zendframework/
 ZendSkeletonApplication.git

移动骨架

完成后，我们可以进入新创建的名为ZendSkeletonApplication的文件夹，并将里面的所有内容复制粘贴到我们的 Web 服务器文档根目录。在 Linux 系统中，这通常是/var/www（当我们使用 Zend Server 时也是如此，如附录中所述，设置基本要素）。我们可以通过输入以下命令来完成此操作：

$ cd ZendSkeletonApplication
$ mv ./* /var/www –f
$ cd /var/www

初始化 Composer

在所有内容复制完毕后，我们将通过输入以下命令来初始化项目：

$ php composer.phar install

现在，PHP 的命令行界面（CLI）执行composer.phar，在这个例子中，它将下载并安装 Zend Framework 2 库，并为我们设置一个简单项目，以便我们能够工作。

此命令可能需要很长时间才能成功执行，因为 Composer 需要在告诉您 Zend Framework 2 已准备好使用之前完成很多事情，我们在这里不会深入讨论 Composer 的工作原理，因为它已经在附录中讨论过，设置基本要素。

一旦完成此命令，我们需要确保我们的 Web 服务器文档根已更改以匹配骨架布局。通常的做法是，Zend Framework 2 使用public文件夹作为应用程序的主要着陆点。Zend Framework 2 骨架的结构允许我们将用户绑定到public文件夹，同时所有逻辑都安全地位于公共区域之外。

从本质上讲，这意味着我们需要首先使用public文件夹root或jailWeb 服务器，然后我们才能真正看到我们刚刚安装的内容。我们想要root或jailWeb 服务器，因为我们不希望外部世界过度滥用我们的 Web 服务器，而root或jail确保 Web 服务器本身无法访问除其被jail的文件夹之外的其他任何文件夹，从而使我们的服务器更加安全。

在我个人的情况下，这意味着更改 Apache 2 配置。在大多数基于 Linux 的系统上，它将是 Apache Web 服务器为我们提供 Web 请求。

最简单的事情就是找到您的 Web 服务器配置（通常位于/etc/apache2），并将 DocumentRoot 追加为/public。对我来说，这将更改文档根从/var/www到/var/www/public。

小贴士

如果您使用 Apache，您需要检查AllowOverride设置是否设置正确，这可以在与文档根相同的部分找到，并应反映以下内容：

AllowOverride FileInfo

最后，我们需要重新启动 Apache Web 服务器，如果您以 root 用户登录，可以通过以下命令完成，或者通过在命令前添加sudo来调用它，这告诉服务器我们想要以超级用户身份执行它。

$ apache2ctl restart

现在，我们能够检查我们的浏览器并查看我们实际上做了什么。我们现在只需使用 Web 浏览器输入 URL 访问创建的项目，在我的情况下，这将如下所示：

http://localhost/

这将导致以下屏幕：

恭喜，您现在已设置了一个基本的 Zend Framework 2 应用程序。

它是如何工作的…

在基本 Zend Framework 2 骨架工作正常后，安装 ZFTool 是完美的时机。ZFTool 是一个实用模块，当我们需要列出项目中的当前模块、添加新模块或设置新项目时，它非常有用。它还包含一个极其有用的类映射生成器，我们可以在 Zend Framework 2 的某些更高级区域中使用它。

我们可以通过以下命令安装此实用程序：

$ cd /var/www
$ mkdir -p vendor/zftool
$ cd vendor/zftool
$ wget https://packages.zendframework.com/zftool.phar

虽然我们已通过 composer 设置了 Zend Framework 2 骨架，但向您展示如何轻松通过 ZFTool 设置新项目可能很有趣。

$ cd /var/www
$ php vendor/zftool/zftool.phar create project new-project

上述命令将在/var/www/new-project文件夹中创建一个新的 Zend Framework 2 骨架项目。这反过来意味着我们新项目的文档根应设置为/var/www/new-project/public。

要完成新项目中 Zend Framework 2 应用程序，我们只需进入新项目目录并执行以下命令：

$ cd new-project
$ php composer.phar install

ZFTool 的另一个实用命令是在我们的项目中创建和显示模块。ZFTool 可以轻松显示我们当前使用的模块列表（对于大型应用程序，我们往往容易失去对模块的视线），以及为我们应用程序创建新骨架模块的能力。要查看我们应用程序中当前使用的模块列表，我们可以使用以下命令：

$ php ../vendor/zftool/zftool.phar modules

要在基于/var/www/new-project目录的项目中创建一个名为wow-module的新模块，我们可以使用以下命令：

$ php ../vendor/zftool/zftool.phar create module wow-module
 /var/www/new-project

提供应用程序的路径是可选的，但如果我们在同一台机器上使用多个项目，最好确保我们有正确的项目路径。

现在是最后一条，也可能是 ZFTool 中最有用的一条命令，即类映射生成器。类映射文件是一个包含项目所有类及其相应路径的文件，这使得 PHP 自动加载器加载类文件变得更容易。通常类文件位于我们知道的路径中，这会导致自动加载器实际上需要搜索文件，从而产生小的延迟。然而，使用类映射文件，情况并非如此，因为自动加载器可以立即找到所需的文件。

类映射在 Zend Framework 2 中是一个大问题，因为不良的类映射可以使一个良好的应用程序运行得非常慢，而且为了完全公平，Zend Framework 2 可以使用它所能获得的所有速度。

类映射生成器的作用是创建一个包含所有可自动加载的类和路径的文件。这样我们就不必担心类的位置。

要生成新的类映射文件，我们可以使用以下命令：

$ php zftool.phar classmap generate <directory> <file> -w

命令要求我们提供两个不同的参数：

<directory>：需要索引类的目录。例如，这可以是添加到vendor目录的新库。
<file>：这是 ZFTool 需要生成的类映射文件。我们的 Zend Framework 2 自动加载器需要拾取此文件，因此我们需要确保 ZFTool 可以找到该文件。如果您没有指定文件，它将在当前工作目录中创建一个名为autoload_classmap.php的文件。

大多数情况下，如果您想追加而不是覆盖类映射文件，这是必要的，如果您想追加，只需将-w改为-a。

类映射文件的示例是vendor/composer目录中的autoload_namespaces.php文件，它看起来有点像这样：

<?php
return array(
  // Every class beginning with namespace Zend\ will be 
  // searched in this specific directory
  'Zend\\' => array(
    __DIR__ . '/../zendframework/zendframework/library'
  ),
  'ZendTest\\' => array(
    __DIR__ . '/../zendframework/zendframework/tests'
  ),
);

小贴士

下载示例代码

您可以从www.packtpub.com的账户下载您购买的所有 Packt 书籍的示例代码文件。如果您在其他地方购买了这本书，您可以访问www.packtpub.com/support并注册，以便将文件直接通过电子邮件发送给您。

还有更多...

安装 ZFTool 也有其他方法，其中一些与使用 composer 一样简单，所以我们将介绍两种其他安装 ZFTool 的方法。这样我们就能获得最广泛的可选方案。

安装 ZFTool 的另一种方法是利用 git，从而从仓库本身克隆源代码。然而，这会获取当前的 master 版本，可能会有些 bug。

$ cd vendor
$ git clone https://github.com/zendframework/ZFTool.git
$ cd ZFTool
$ php ./zf.php

现在我们有了zf.php文件，可以像使用zftool.phar一样使用它。现在我们已经涵盖了安装 ZFTool 的所有不同选项。

参见

附录中的确保你拥有所有需要的东西配方，设置基本要素
附录中的下载 Zend Framework 2 及其文档配方，设置基本要素
附录中的作曲家及其在 Zend Framework 2 中的用途配方，设置基本要素
Apache 网络服务器 apache.org/
PHP 网站 php.net

处理例程

一个重要方面（如果不是最重要的方面）是 Zend Framework 2 中的路由。在其最基本的形式中，路由告诉框架用户应该如何从页面 A 到达页面 B，以及到达那个目的地需要做什么。这就是为什么我们通常认为这是如果你是初学者的话，理解的最重要部分。

如何做到这一点...

要定义一个路由，我们只需进入一个配置文件，并将路由配置添加到那里。

设置路由

让我们看看我们的简单（Segment）配置如下（文件：/module/Application/config/module.config.php）：

return array(
  // Here we define our route configuration
  'routes' => array( 

    // We give this route the name 'website'
    'website' => array( 

      // The route type is of the class:
      // Zend\Mvc\Router\Http\Segment
      'type' => 'segment', 

        // Lets set the options for this route
        'options' => array( 

          /*
            The route that we want to match is /website
            where we can optionally add a controller name
            and an action name. For example:
              /website/index/index
          */ 
          'route' => '/website[/:controller[/:action]]',

          /*
            We don't want to accept everything, but this
            regex makes sure we only accept alpha-
            numeric characters and a dash and underscore.

            In our instance we want to check this for the
            action and the controller.
          */
          'constraints' => array( 
            'controller' => '[a-zA-Z][a-zA-Z0-9_-]*',
            'action' => '[a-zA-Z][a-zA-Z0-9_-]*'
          ),

          /*
           We want to make sure that if the user only 
           types /website in the URL bar it will actually
           go somewhere. We defined that here.
          */
          'defaults' => array( 
            'controller' => 'Website\Controller\Index', 
            'action' => 'index'
          ),
        ),
      ),
    ),
  ),
);

使用这个基本配置，我们可以轻松地在我们的应用程序中定义路由，在这个例子中，我们已经配置了一个响应/website URL 的路由。当我们访问/website URL 时，我们默认会被路由到Website\Controller\Index::indexAction。如果我们使用路由/website/another/route，我们会被路由到Website\Controller\Another::routeAction，因为我们已经定义了控制器和动作可以解析在后面。如果我们省略路由路径并输入/website/another，我们会重定向到Website\Controller\Another::indexAction，因为这是框架默认使用的。

上述示例只有一个真正的主要缺点，那就是当我们决定在配置中使用匿名函数来创建更多动态路由时，我们无法缓存路由，因为闭包不能被缓存序列化。

然而，还有一种声明路由的方法，那就是在代码中。在代码中创建路由功能的需求（显然每个人都有自己的原因和需求）可能是因为我们想在稍后的阶段缓存配置（例如，因为我们不能缓存匿名函数）或者当我们想从数据库中动态加载路由时。

让我们看看/module/Application/Module.php的例子：

<?php

// We are working in the Application module
namespace Application;

// Our main imports that we want to use
use Zend\Mvc\ModuleRouteListener;
use Zend\Mvc\MvcEvent;

// Define our module class, this is always 'Module', but 
// needs to be specifically created by the developer.
class Module
{
  public function onBootstrap(MvcEvent $e)
  {
    // First we want to get the ServiceManager
    $sm = $e->getApplication()->getServiceManager();

    /*
      Say our logged in user is 'gdog' and we want
      him to be able to go to /gdog to see his profile.
    */
    $user = 'gdog';

    // Now get the router
    $router = $sm->get('router');

    // Lets add a route called 'member' to our router
    $router->addRoute('member', array(

      /*
        We want to make /$user the main end point, with 
        an optional controller and action.
      */
     'route' => '/'. $user. '[/:controller[/:action]]',

      /*
        We want a default end point (if no controller
        and action is given) to go to the index action
        of the index controller.
      */
      'defaults' => array( 
        'controller' => 'Member\Controller\Index', 
        'action' => 'index' 
      ), 

      /*
        We only want to allow alphanumeric characters
        with an exception to the dash and underscore.
      */
      'constraints' => array( 
          'controller' => '[a-zA-Z][a-zA-Z0-9_-]*', 
          'action' => '[a-zA-Z][a-zA-Z0-9_-]*' 
      ), 
    ));
  }
}

自然地，有更多添加路由的方法，但前述代码中提到的添加路由的方法展示了动态添加路由的巧妙方式。我们在那里创建的是，每当 Gdog 去他的个人资料时，他可以简单地输入http://example.ext/gdog并最终到达他的个人资料页面。

更令人惊奇的是，如果我们的朋友 Gdog 想看看他的朋友，他只需输入例如http://example.ext/gdog/my/friends，这将解析到Member模块，然后转到My控制器，最后执行Friends操作。

使用 SimpleRouteStack

这个路由栈——正如其名所示——是最简单的路由器之一，基本上是一个包含路由的列表，这些路由被解析以查看哪个路由匹配。默认情况下，这种类型的路由器在 Zend Framework 2 中不被使用。一般规则是，如果我们想添加一个具有高优先级的路由，我们给它一个高的索引号，例如 100 或 200。如果我们想给路由一个非常低的优先级，我们会给它一个索引号，例如 5 或 10。

当我们有非常具体的路由（通常具有高优先级）和不太具体的路由（低优先级）时，给路由分配优先级很有用。如果我们，例如，想让/website/url重定向到一个完全不同的模块、控制器和操作，但不影响其他网站路由，我们需要给/website/url路由一个更高的优先级，这样当它被找到时，它就不会搜索低优先级的路由。

如果我们不小心颠倒了优先级，我们会发现我们的/website/url总是重定向到包含所有/website路由的路由。

SimpleRouteStack使用Zend\Mvc\Router\PriorityList类来管理其路由优先级。

在我们想要开始创建应用程序之前，我们需要考虑路由，因为当应用程序增长时，如果我们没有事先考虑“如何路由”，我们可能会遇到路由问题。因此，在我们编码路由之前“绘制”应用程序的“网站地图”是明智的，以确保我们有正确的路由列表，并且没有创建任何冲突的路由。

SimpleRouteStack类定义了一些对我们非常有用的方法：

getRoute($name) / getRoutes($name): 这将检索当前路由——如果提供了名称——或者检索我们定义在SimpleRouteStack中的路由。如果我们不确定我们定义了哪些路由，这是一个首先检查的好地方。

addRoute($name, $route, $priority) / addRoutes($routes): 我们可以通过简单地将它添加到这个方法中来使用它来添加一个新的路由或一组路由到我们的路由类型。一个路由需要一个 name、route（可以是字符串或 RouteInterface 的实例）以及如果我们想要一个优先级，我们可以将其作为第三个参数提供。

hasRoute($name): 如果我们想要检查是否存在特定的路由，我们可以通过其 name 来搜索，并找出它是否存在。

removeRoute($name): 当我们厌倦了一个路由时，我们可以简单地给出它的名字，并将其从列表中删除。如果我们想要例如在用户登录后重定向到 /user 而不是 /login，这可能会特别有用。
SimpleRouteStack: 没有多个具有相同优先级的路由的功能。如果已经定义了一个具有优先级的路由，它将优先考虑最后添加的路由作为具有最高优先级的路由。

使用 TreeRouteStack

路由器不仅限于使用 URI 路径来确定如何路由请求。它们还可以使用其他信息，如查询参数、头部、方法或主机名来找到匹配项。

它是如何工作的...

在 Zend Framework 2 中，我们通常会使用基于请求 URI 的路由，其中包含应查询的路径段。路由是通过路由器匹配的，路由器利用 RouteStack 来找到与路由器查询相匹配的路由。我们使用 RouteStack 是因为我们想要一种管理不同路由的合理方式。在 Zend Framework 2 中提供了大量的路由类型，但只有两种无味的路由器，即 SimpleRouteStack 和 TreeRouteStack。

当我们定义一个路由器时，我们需要确保我们理解它是如何工作的。虽然创建不同路径的列表足够简单，但记住，Zend Framework 2 的路由器通常使用 后进先出（LIFO）的概念，这意味着经常使用的路由会被最后注册，而较少使用的路由会在路由器堆栈中较早注册。

理解依赖注入

当我们谈论依赖注入，简称 DI 时，我们谈论的是在需要时，例如在初始化时向对象或方法中注入数据，这些对象或方法在用后要么修改要么销毁对象。DI 可能是 Zend Framework 2 中最复杂的功能之一。不幸的是，由于 DI 在调试和性能上的过度复杂性以及服务定位器（在第六章中解释，模块、模型和服务），DI 可能不是最好的工具。然而，尽管它不是最好的工具，我们仍然必须努力去学习它，因为一旦掌握，它可能证明是一个非常强大的工具，可以创建非常易于维护的代码。

如果我们遇到需要我们在类中输入大量参数的情况，因为代码中更深层的对象依赖于它们，这可能是我们在甚至最专业环境中能找到的最令人烦恼且难以维护的代码片段。我们需要主要考虑在应用程序中多次使用且总是需要重新实例化的对象。

如何实现...

让我们看看以下示例，并假设FirstClass是我们将在代码中进一步需要的唯一类：

namespace OneNamespace
{
  class FirstClass 
  {
    private $secondClass;
    public function __construct(SecondClass $secondClass)
    {
      $this->secondClass = $secondClass;  
    } 
  }

  class SecondClass 
  {
    private $thirdClass;
    private $vehicle;
    public function __construct(ThirdClass $thirdClass, $vehicle)
    {
      $this->thirdClass = $thirdClass;
      $this->vehicle = $vehicle;
    }
  }
}

namespace AnotherNamespace 
{
  class ThirdClass 
  {
    private $first_name;
    private $last_name;

    public function __construct($first_name, $last_name)
    {
      $this->first_name = $first_name;
      $this->last_name = $last_name;
    }
  }
}

// Let us now create the example through the classic 
// method.
$thirdClass = new AnotherNamespace\ThirdClass("John", "Doe");
$secondClass = new OneNamespace\SecondClass($thirdClass, 
  'Motorcycle');
$firstClass = new OneNamespace\FirstClass($secondClass);

上述两个例子都给出了仅用于实例化另一个类或/和在阅读代码时增加复杂性的变量。尽管它们都是正确的，但在这个情况下，使用 DI 可以使这两个类的配置变得更加容易。

在调用时间初始化 DI

让我们看看这个 DI 示例，考虑到我们拥有与前面示例相同的类：

namespace OneNamespace
{
  class FirstClass 
  {
    [..] 
  }

  class SecondClass 
  {
    [..]  
  }
}

namespace AnotherNamespace 
{
  class ThirdClass 
  {
    [..]
  }
}

// Instead of configuring all the classes, we will now 
// simply configure the Di, and only instantiate the 
// class that we want to use.
$di = new \Zend\Di\Di();
$lister = $di->get(
    'OneNamespace\FirstClass',
    array(
        'first_name' => 'Jane',
        'last_name' => 'Doe',
        'vehicle' => 'Car',
    )
);

在前面的例子中，我们只是告诉 DI，AnotherNamespace\ThirdClass在其__construct方法中有两个参数。然后 DI 将利用Reflection来找出那里有哪些参数，然后将为任何在其构造函数中具有first_name、vehicle或last_name参数的类提供该参数。

当然，我们在这里会看到一个潜在的缺陷，因为你可能需要利用多个实例化，可以假设在某个时刻会使用到相同的参数名称。在我们的例子中，如果另一个类也有一个$first_name参数但需要不同的输入，那么这将会引起问题，因为 DI 将简单地给出列表中的那个。

小贴士

如果我们使用依赖注入（DI）来实例化我们的类，并且我们只需要构造函数来设置变量，那么我们可以很容易地完全移除构造函数，因为 DI 不会使用构造函数来初始化变量。相反，DI 将只设置值的属性。

关于这一点的一个好处是，这种错误只会在我们使用 DI 在调用时间级别时发生，而不会在全局配置级别上，正如我们现在将要看到的。这就是为什么不建议在调用时间级别上使用 DI。

通过配置对象初始化 DI

我们还可以通过使用配置对象来创建更具体（或更准确）的对象初始化，并确保具有相同属性名的类不会发生冲突。

这个想法是，我们首先创建一个配置对象（或数组），它定义了哪些类需要设置哪些属性，然后使用它来初始化 DI，DI 反过来找出何时需要启动什么。

看看下面的例子，它展示了我们刚才解释的 exactly 东西：

<?php
// We are assuming that we are using the same classes as 
// in the previously shown examples.
namespace OneNamespace 
{
  class FirstClass 
  {
    [..] 
  }

  class SecondClass 
  {
    [..]  
  }
}

namespace AnotherNamespace 
{
  class ThirdClass 
  {
    [..]
  }
}

// After defining our classes we now begin to create our 
// configuration array which we will use to initialize 
// the DI.
$configuration = array(

  // We want to use this specific configuration at 
  // initialization of our class.
  'instance' => array(

    // We specify the class name to use here
    'SecondClass' => array(

      // We want to use this as a parameter
      'parameters' => array(

        // The property name to fill is vehicle.
        'vehicle' => 'Airplane'
      ),
    ),

    'FirstClass' => array(
      // Again we want to use this as a parameter
      'parameters' => array(

        // The property name to fill is first name and 
        //last name.
        'first_name' => 'Neil',
        'last_name' => 'deGrasse Tyson',
      ),
    ),
  ),
);

// We want to instantiate the Di\Configuration now.
use \Zend\Di\Configuration; 

$diConfiguration = new Configuration($configuration);

// Now instantiate the Di itself, with the configuration 
// attached.
$di = new \Zend\Di\Di($configuration);

// And to get the object we want to use, we just do the 
//same as before.
$firstClass = $di->get('OneNamespace\FirstClass');

为了让一切更加完美，我们只需将 DI 的Zend\Di\Configuration放在我们模块的引导程序中，这样我们就可以在整个命名空间中轻松使用它。这样我们就可以简单地将 DI 的配置放在我们的module.config.php中，让框架来处理它。

它是如何工作的…

DI 或依赖注入器是 Zend Framework 2 的一个重要特性，但大多数时候都被忽视了。DI 通过自动查找我们应用中需要的类，使我们的生活变得更加容易。

然而，尽管它很复杂，但也有一些特性我们应该小心。

DI 只提供一个对象的实例

这意味着每次get()调用都会导致相同的实例化重复进行。如果我们想要一个新的实例，我们需要调用newInstance()，因为 DI 实现了单例模式，这意味着每次我们调用get()方法时，所有数据都会持续存在，除非我们强制创建 DI 的新实例。

定义所有属性或使用完全合格（FQ）设置器参数

当我们的类具有比我们定义的更多的属性时，我们会发现 DI 将使用类中每个其他属性的最后一个值。当然，这是我们不希望的，如果我们自己编写了类，我们应该考虑重构配置和/或类。

然而，当没有其他方法可以定义正确的属性时，我们只能通过使用完全合格（FQ）设置器参数来定义。

在我们的配置中，我们可以定义一个非常具体的属性名，例如，class::method:paramPos。如果我们以之前提到的ThirdClass为例，那么这将分别是ThirdClass::setFirstName:0和ThirdClass::setLastName:0。

还有更多…

在 Zend Framework 2 中，我们还可以学习更多关于 DI 的知识。以下列表提供了一个非常简短且紧凑的描述，介绍了其他有趣的 DI 组件：

RuntimeDefinition（默认）、CompilerDefinition和ClassDefinition：这些定义用于确定如何配置我们的对象。尽管默认的一个通常可以完成工作，但看看其他两个定义做了什么是有好处的，因为它们都有其优缺点。
InstanceManager：用于定义配置，特别是Aliases、Parameters和Preferences。

利用配置的优势

配置在 Zend Framework 2 的工作中起着至关重要的作用，因此了解它是如何工作的至关重要。

如何做到这一点...

遍历以下部分，以利用配置：

创建全局配置

当开始使用 Zend Framework 2 编码时，对于不同的配置文件的作用存在一些误解。默认情况下，我们有多个配置文件，而且可能并不总是简单易懂地知道东西应该放在哪里。这就是为什么我们喜欢应用一个简单的规则：

注意

配置是否需要在所有模块中都是必要的？如果是，请将您的配置放在config/application.config.php文件中。如果不是，请将配置放在属于该模块的config/global.php文件中。

我们通常放在global.php文件中的配置，例如，可以是缓存方法和配置、数据库配置。通常我们希望放置与环境相关的项目，但没有任何安全敏感的信息。

让我们看看global.php的一个糟糕的例子：

<?php
return array(

  // We want to create a new database connection
  'db' => array(

    // The driver we want to use is the Pdo, our  
    // favorite
    'driver' => 'Pdo',

    // This is our connection url, defining a MySQL 
    // connection, with database 'somename' which is 
    // available on the localhost server.
    'dsn' => 'mysql:dbname=somename;host=localhost',

    // This is exactly what we should NOT do in this  
    // file, shame on you developer!
    'username' => 'terribleuser',
    'password' => 'evenworsepassword',
  ),

  // We need a database adapter defined as well, 
  // otherwise we can't use it at all.
  'service_manager' => array(
    'factories' => array(
      'Zend\Db\Adapter\Adapter' => 
  'Zend\Db\Adapter\AdapterServiceFactory',
    ),
  ),
);

在global.php文件中放置用户名和密码是非常糟糕的做法。global.php文件应该放入我们的版本控制中，因此应该只包含全局运行应用程序所需的配置项，而不是与特定环境相关的特定信息，例如数据库用户名和密码。

创建仅适用于本地机器的配置

在 Zend Framework 2 中，超多配置文件的好处之一是您可以使用本地配置覆盖全局配置。这在开发过程中非常有用，当您发现自己处于配置与生产环境略有不同的情况时。

假设我们有一个如下的/config/autoload/global.php配置文件：

<?php
return array(

  // We want to create a new database connection
  'db' => array(

    // The driver we want to use is the Pdo, our  
    // favorite
    'driver' => 'Pdo',

    // This is our connection url, defining a MySQL 
    // connection, with database 'somename' which is 
    // available on the localhost server.
    'dsn' => 'mysql:dbname=somename;host=localhost',
  ),

  // We need a database adapter defined as well, 
  // otherwise we can't use it at all.
  'service_manager' => array(
    'factories' => array(
      'Zend\Db\Adapter\Adapter' => 
  'Zend\Db\Adapter\AdapterServiceFactory',
    ),
  ),
);

正如前一个例子所示，我们创建了一个很好的简单的 MySQL 数据库连接到我们位于本地的somename数据库。但作为优秀的开发者，我们并没有在这里定义用户名和密码。这就是/config/autoload/local.php文件的作用所在。

让我们看看我们的local.php可能的样子：

<?php
return array(
  'db' => array(
    'username' => 'awesomeuser',
    'password' => 'terriblepassword',
  ),
);

如果我们使用版本控制系统（请说“是”），我们不应该提交此文件，这不仅出于安全原因，而且因为这是一个本地配置文件，在实时系统中可能并不必要，因为我们会在该环境中创建一个新的具有正确细节的文件。

编辑您的 application.config.php 文件

如果我们查看我们的默认config/application.config.php文件，我们只设置了少量属性，但有很多内联注释，当我们不再记得某个属性的准确名称或描述时，这些注释非常有用。

在我们开发应用程序时，我们将更改最多的主要配置是modules属性。这个特定的属性是一个简单的数组，包含我们在应用程序中（并希望使用）的不同模块命名空间。默认情况下，它看起来有点像这样：

<?php 

return array(
  // This should be an array of module namespaces used 
  // in the application.
  'modules' => array(
    'Application',
  ),
[..]

当我们添加或删除模块时，此行也需要修改，甚至可以在开始新模块或删除模块之前修改此文件。原因很简单，当我们忘记在删除模块时修改此文件，访问应用程序时会在浏览器中生成500 – 应用程序错误。而且因为此配置文件在实例化早期就被读取，有时对于开发者来说很难确定为什么应用程序突然无法加载。

它是如何工作的…

如果我们查看public文件夹中的index.php文件，我们可以看到我们将初始配置文件通过以下行解析到 Zend Framework MVC 应用程序中：require 'config/application.config.php'。然后加载主配置文件，它反过来定义了所有我们的属性。

application.config.php文件中的一个巧妙属性是config_glob_paths属性。任何额外的配置文件默认情况下都会通过在config/autoload文件夹中查找文件来读取，使用一个非常具体的文件模式，即*global.php和*local.php。定义的顺序也非常重要。

当我们说*global.php时，我们可以从somemodule.global.php到menu.global.php，甚至只是global.php来定义任何内容，因为文件模式（也称为GLOB_BRACE）会搜索任何匹配的内容。对于*local.php也是如此。

如前所述，定义的顺序非常重要，因为我们希望全局配置在本地配置之前加载，否则覆盖全局配置就没有意义了，对吧？

还有更多…

总结配置文件：

config/application.config.php: 可以在此处添加和删除模块，并且非常底层的配置也在这里进行。
config/autoload/some-module.global.php: 用于覆盖模块配置的默认值。请确保不要在此处放置敏感信息，但主机名和数据库名称应该放在这里。
config/autoload/some-module.local.php: 您可以在此处放置您的用户名和密码以及其他非常特定于您本地环境的配置项。
module/SomeModule/config/module.config.php: 模块特定配置在此处进行，请仅使用默认值，并确保不要在此处输入过于具体的内容。

事件管理器和引导类

我们将展示 Zend Framework 2 最漂亮的功能之一：事件管理器。

如何操作…

EventManager和Bootstrap类是我们应用程序的重要组成部分，这个配方主要介绍如何使用这两个工具：

使用引导

在我们的情况下，引导是模块的开始，每当请求一个模块时，它将使用位于 Module.php 文件中的 onBootstrap() 方法。虽然这个方法不是必需的，但我们通常希望在模块中包含这个方法，因为它是一个确保在进一步处理客户端请求之前某些实例已经存在或配置好的简单方法。

开始一个会话

会话是保存用户临时信息的绝佳方式。想想保存已登录用户的信息，或者他们在页面上浏览的历史记录。一旦我们开始创建应用程序，我们会发现自己会在会话中保存很多东西。

我们需要做的第一件事是修改 /module/Application/config/module.config.php 文件，并向其中添加一个名为 session 的新部分。假设我们有一个完全空的模块配置：

<?php
return array(
  'service_manager' => array(
     // These are the factories needed by the Service 
     // Locator to load in the session manager
    'factories' => array(
      'Zend\Session\Config\ConfigInterface' => 
  'Zend\Session\Service\SessionConfigFactory',
      'Zend\Session\Storage\StorageInterface' => 
  'Zend\Session\Service\SessionStorageFactory',
      'Zend\Session\ManagerInterface' => 
  'Zend\Session\Service\SessionManagerFactory',
    ),
    'abstract_factories' => array(
  'Zend\Session\Service\ContainerAbstractFactory',
    ),
  ),
  'session_config' => array(
    // How long can the session be idle for in seconds 
    // before it is being invalidated
    'remember_me_seconds' => 3600,

    // What is the name of the session (can be anything)
    'name' => 'some_name',
  ),
  // What kind of session storage do we want to use, 
  // only SessionArrayStorage is available at the minute
  'session_storage' => array(
    'type' => 'SessionArrayStorage',
    'options' => array(), 
  ),
  // These are session containers we can use to store 
  // our information in
  'session_containers' => array(
    'ContainerOne',
    'ContainerTwo',
  ),
);

就这样。会话现在可以在我们的控制器和模型中使用。我们现在创建了两个会话容器，我们可以使用它们来存储我们的信息。我们可以通过以下方式在任何有服务定位器可用的控制器或模型中访问这些容器（文件：/module/Application/src/Application/Controller/IndexController.php）：

<?php

namespace Application;

use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractController
{
  public function indexAction()
  {
    // Every session container we define receives a 
    // SessionContainer\ prefix before the name
    $containerOne = $this->getServiceLocator()
  ->get('SessionContainer\ContainerOne');
  }
}

使用 EventManager 类

EventManager 类可能是框架中最好的特性之一。当正确使用时，它可以使我们的代码更加动态和易于维护，而不会产生乱麻般的代码。

它所做的事情相对简单，例如；一个类可能有一个名为 MethodA 的方法。这个 MethodA 有一个监听器列表，它们对这个类的结果感兴趣。当 MethodA 执行时，它只是运行其正常程序，完成后就通知 EventManager 发生了一个特定的事件。现在 EventManager 将触发所有感兴趣的相关方，而这些相关方将依次执行它们的代码。

明白了？如果你不明白，不要担心，因为这个示例代码可能会澄清一些问题（文件：/module/Application/src/Application/Model/SwagMachine.php）：

<?php
// Don't forget to add the namespace
namespace Application\Model;

// We shouldn't forget to add these!
use Zend\EventManager\EventManager;

class SwagMachine
{
  // This will hold our EventManager
  private $em;

  public function getEventManager() 
  {
    // If there is no EventManager, make one!
    if (!$this->em) {
      $this->em = new EventManager(__CLASS__);
    }

    // Return the EventManager.
    return $this->em;
  }

  public function findSwag($id)
  {
    // Trigger our findSwag.begin event 
    // and push our $id variable with it.
    $response = $this->getEventManager()
                     ->trigger(
           'findSwag.begin', 
           $this,
           array(
             'id' => $id
           )
    );

    // Make our last response, the final 
    // ID if there is a response.
    if ($response->count() > 0)
      $id = $response->last();

    // ********************************
    // In the meantime important code 
    // is happening...
    // ********************************

    // ...And that ends up with the 
    // folowing return value:
    $returnValue = 'Original Value ('. $id. ')';

    // Now let's trigger our last 
    // event called findSwag.end and 
    // give the returnValue as a 
    // parameter.
    $this->getEventManager()
         ->trigger(
           'findSwag.end', 
           $this, 
           array(
             'returnValue' => $returnValue
           )
    );

    // Now return our value.
    return $returnValue;
  }
}

正如我们所看到的，我们创建了一个带有两个事件触发器的小类，分别是 findSwag.begin 和 findSwag.end，分别位于方法的开始和结束处。findSwag.begin 事件可能会修改 $id，而 findSwag.end 事件仅解析 returnValue 对象，无法修改其值。

现在我们来看看实现触发器的代码（文件：/module/Application/src/Application/Controller/IndexController.php）：

<?php

namespace Application\Controller;

use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractActionController
{
  public function indexAction() 
  {
    // Get our SwagMachine
    $machine = new SwagMachine();

    // Let's attach our first callback, 
    // which potentially will increase 
    // the $id with 10, which would 
    // make it result in 30!
    $machine->getEventManager()
            ->attach(
        'findSwag.begin',
        function(Event $e) 
        {
          // Get the ID from our findSwag() 
          // method, and add it up with 12.
          return $e->getParam('id') + 10;
        },
        200
    );

    // Now attach our second callback, 
    // which potentially will increase 
    // the value of $id to 60! We give 
    // this a *higher* priority then 
    // the previous attached event 
    // trigger.
    $machine->getEventManager()
            ->attach(
        'findSwag.begin',
        function(Event $e) 
        {
        // Get the ID from our findSwag() 
        // method, and add it up with 15.
        return $e->getParam('id') + 40;
      },
      100
    );

    // Now create a trigger callback 
    // for the end event called findSwag.end, 
    // which has no specific priority, 
    // and will just output to the screen.
    $machine->getEventManager()
            ->attach(
        'findSwag.end',
        function(Event $e) 
        {
          echo 'We are returning: '
             . $e->getParam('returnValue');
        }
    );

    // Now after defining the triggers, 
    // simply try and find our 'Swag'.      
    echo $machine->findSwag(20);
  }
}

正如我们所看到的，将触发器附加到事件上非常简单。如果事件得到适当的文档说明，当我们需要修改传入方法（如我们用 findSwag.begin 所做的那样）的参数或只是将结果输出到日志（如 findSwag.end）时，它们会很有用。

当我们查看屏幕上的内容时，它应该是这样的：

We are returning: Original Value (60)
Original Value (60)

结果是，最上面一行是来自findSwag.end触发器的输出，而值60来自最高优先级的触发器，即优先级为100的触发器（因为那被认为比200的优先级更高）。

更改视图输出

有时候，我们需要不同的视图输出，例如当我们需要构建自己的 REST 服务或 SOAP 服务时。虽然这可以通过控制器插件更简单地安排，但它是一个如何连接到dispatch事件并查看那里的示例。

不再赘述，让我们看一下以下代码片段：

Module.php:
namespace Application;

// We are going to use events, and because we use a MVC, 
// we need to use the MvcEvent.
use Zend\Mvc\MvcEvent;

class Module
{
  public function onBootstrap(MvcEvent $e)
  {
    // Get our SharedEventManager from the MvcEvent $e 
    // that we got from the method
    $sharedEvents = $e->getApplication()
                      ->getEventManager()
                      ->getSharedManager();

    // Also retrieve the ServiceManager of the 
    // application.
    $sm = $e->getApplication()->getServiceManager();

    // Let's propose a new ViewStrategy to our 
    // EventManager.
    $sharedEvents->attach(

        // We are attaching the event to this namespace 
        // only.
        __NAMESPACE__, 

        // We want to attach to this very specific 
        // event, the Dispatch event of our controller.
        MvcEvent::EVENT_DISPATCH, 

        // The callback function of the event, used when 
        // the event we attached to happens. In our 
        // callback we also want our local variable $sm 
        // to be available for use.
        function($e) use ($sm) 
        {
          // Get our alternate view strategy from the 
          // ServiceManager and attach the EventManager     
          // to the strategy.
          $strategy = $sm->get('ViewJsonStrategy');
          $view = $sm->get('ViewManager')->getView();
          $strategy->attach($view->getEventManager());
        }, 

        // We want to give this a priority, so this will 
        // get more priority.
        100
    );
}

如我们所见，将回调函数附加到EventManager对象相对简单。在这个例子中，我们使用McvEvent::EVENT_DISPATCH作为我们想要连接的事件。所以基本上发生的事情是，每当控制器执行onDispatch()方法时，这个事件也会被触发。这意味着通过事件，我们可以修改方法的输出结果，而实际上并不需要修改代码。

它是如何工作的...

EventManager类通过几种不同的方法工作，即观察者模式、面向方面编程技术（或 AOP）和事件驱动架构。

观察者模式解释

简单来说，观察者模式意味着存在几个感兴趣的参与者，称为监听器，它们希望知道当应用程序触发某个事件时。当特定事件被触发时，监听器将收到通知，以便它们可以采取必要的行动。

面向方面编程（AOP）解释

如果我们要解释 AOP 是什么，我们可以简单地说，它代表编写只包含功能且尽可能与代码其他部分隔离的干净代码。

事件驱动架构解释

事件驱动架构的好处是，我们不必创建大量需要检查每个条件的代码，我们可以轻松地将自己连接到不同的事件，本质上这将创建一个更响应的应用程序。

还有更多...

EventManager对象通过PriorityQueue进行查询，这告诉我们，重要的事件通常会得到更低的值，而不重要的事件会得到更高的值。例如，最高优先级可能得到优先级-1000，而相当低的优先级可能得到 40。然后EventManager类通过FIFO（先进先出）的概念获取队列，这意味着优先级越高，数字越低。

第二章翻译和邮件处理

在本章中，我们将涵盖：

翻译您的应用程序
本地化您的应用程序
发送邮件
接收邮件

简介

一个应用程序如果不能响应用户，那就不是一个真正的应用程序。显然，一个简单而有效的方法是显示文本和发送电子邮件。在过去的几年里，国际化（i18n）和本地化（l10n）变得越来越重要。如今，用户期望以他们的语言被问候，甚至在日常工作中从应用程序中收到自动化的电子邮件。

翻译您的应用程序

在这个菜谱中，我们将使用 Zend Framework 2 框架作为基础，但我们将创建一个新的模块来展示它是如何工作的。

准备工作

对于这个菜谱，我们假设您已经有一个运行的 Zend Framework 2 应用程序/框架。为了确保我们可以实际运行在菜谱中产生的代码，我们需要确保 PHP 中的 intl 和 gettext 扩展已被启用。

在翻译字符串时，我们将使用 Poedit，这是一个跨平台的开源应用程序，用于翻译 gettext 目录。当前版本是 1.5.5，可以在 www.poedit.net/ 网站找到。我们使用 gettext，因为这是一个广泛使用的国际化本地化系统，用于编写多语言应用程序。由 Poedit 生成的文件扩展名为 .po 或 .mo。.po 文件用于编辑；让我们假设这是一个未编译的翻译文件。.mo 文件是编译后的翻译文件，用于我们的应用程序。

如何操作…

在这个菜谱中，我们将讨论如何将我们的应用程序翻译成其他语言，这在当今的应用程序中非常有用。

设置和检查基本要素

我们将假设我们至少设置了一个基本的模块，其中包含一个简单的 IndexController，它输出一个简单的视图。

我们首先要做的是确保在我们的模块结构中有一个语言目录，如下面的代码所示：

SampleModule/
  config/
    module.config.php
  language/
  src/
    SampleModule/
      Controller/
        IndexController.php
  view/
    samplemodule/
      index/
        index.phtml
  Module.php

在这个目录中，所有 gettext 文件都将被存储，这将使我们更容易控制它们。现在，我们已经设置了一个简单的文件夹结构，我们需要确保模块配置也知道我们在做什么。现在，我们打开 module.config.php 并向数组中添加以下行：

// We want to have our translator available through the 
// ServiceManager.
'service_manager' => array(
  'factories' => array(
    // Make our translator available in the 
    // ServiceManager so we can retrieve it under the 
    // 'translator' key.
    'translator' => 'Zend\I18n\Translator\TranslatorServiceFactory',
  ),
),

// Now to configure the Translator
'translator' => array(
  'locale' => 'en_US',

  // We would like using file patterns when matching 
  // i18n files, as that makes our lives so much easier, 
  // this is default in the skeleton.
  'translation_file_patterns' =>array(
    array(
      // The type of i18n we want to use is gettext.
      'type'     => 'gettext',

      // Here we define our i18n file directory, this is 
      // the directory we just made.
      'base_dir' => __DIR__ . '/../language',

      // We want to match our i18n files through this 
      // pattern, what will be for example 'nl_NL.mo'.
      'pattern'  => '%s.mo',
    ),
  ),
),

通过上述配置，我们已经将我们的模块设置成我们需要的样子。就这样；我们的模块现在已设置好以使用国际化。

在控制器中翻译字符串

一旦我们设置了翻译器，翻译字符串将变得非常简单。在以下示例（文件：/module/Application/src/Application/Controller/IndexController.php）中，我们将翻译控制器中的字符串，但在实际应用中这样做并不好，这里仅作为示例展示：

<?php

// Set our namespace
namespace Application\Controller;

// We need to use the following abstract on our 
// controller
use Zend\Mvc\Controller\AbstractActionController;

// Begin our index controller class

class IndexController extends AbstractActionController
{
  // We can use this property to translate the strings, 
  // or do some other translator related stuff.
  public $i18n;

  // Lets attach the setLocale to the dispatch event, so 
  // it will be run before the action logic is executed
  public function setEventManager(EventManagerInterface $events) 
  {
    // Instantiate the i18n through our ServiceLocator.
    parent::setEventManager($events);

    // We want to use this controller in our event
    $c = $this;

    // Attach our locale setting to the dispatch event
    $events->attach(
      'dispatch', 

      // Variable $e is a Zend\Mvc\MvcEvent
      function ($e) use ($c) 
      {
        // Put our translator in a local property
        $c->i18n = $this->getServiceLocator()
                        ->get('translator'); 

        // while we are here, let's change the locale 
        // to Dutch.
        $c->i18n->setLocale('nl_NL');
      }, 

      // Make sure this event is triggered before the 
      // action execution
      100
    ); 

    // Return our selves
    return $this;
  }

  public function indexAction()
  {
    // Now simply translate this string with our i18n.
    $myTranslatedString = $this->i18n
                               ->translate("And how about me?");
  }
}

在视图中翻译字符串

视图中的翻译甚至比控制器（已经很简单了）还要简单。我们只需要我们想要翻译的字符串，就是这样。我们对index.phtml文件进行以下修改：

<?php
  // Translate and display this text.
  echo $this->translate(
      "Hello, I am a translated text!"
  );

使用 Poedit 翻译字符串

在我们安装 Poedit 后，在开始翻译字符串之前，我们需要设置一些设置。Gettext 与称为目录的文件一起工作。目录是表示特定语言的源文本和翻译文本的文件。

首先，我们应该创建一个新的目录。在输入项目名称和要翻译的语言（例如，nl-NL）的第一个标签后，我们应该转到名为“源路径”的第二个标签。该路径应包含我们想要翻译的源路径，并且很可能是按模块划分的，这意味着基本路径应该是模块目录。

在第三个标签中，应该有一些标识符，Poedit 可以通过这些标识符识别哪些字符串应该翻译或不应翻译。因为我们将会使用translate()方法，我们需要确保至少单词“translate”在列表中，我们可以保留其余的，因为它们不会造成任何伤害。

在我们完成所有能做的事情后，点击确定并选择一个保存文件的位置。此文件需要保存在模块的语言目录中，并且应该有一个命名模式，例如，nl_NL.po，en_GB.po，en_US.po。文件的命名约定是[language]_[COUNTRY]；一些国家（例如，比利时和加拿大）有多个州语言，也需要定义。

保存后，点击更新按钮，这将导致代码被扫描以查找可翻译的字符串。现在出现了一个新列表，列出了所有可翻译的字符串。我们可以轻松地将我们的翻译放入翻译框中并保存。

如果我们完成了所有这些，我们的屏幕可能看起来类似于以下截图：

恭喜，我们现在已经成功创建了一个国际化应用程序！

它是如何工作的...

在 ZF2 中翻译字符串有多种方式，而且它们都相对容易实现。

在你的模块中基本设置翻译

虽然应用程序模块已经设置了翻译功能，但这可能不是我们想要在整个应用程序中使用的。例如，如果我们（我们将这样做）使用不同的模块，我们不想使用应用程序模块中的翻译文件，因为这会使它变得不那么动态。

如果我们在所有模块中使用相同的gettext文件，并将其存储在应用程序模块中，这意味着如果我们没有使用特定的模块，翻译仍然会被加载。当然，这将意味着更多的内存使用，而这本不应该发生。

因此，为每个模块单独设置翻译是一个好主意。

在 ZF2 中，翻译工作显然是因为有Zend\I18n\Translator\Translator类。这个类然后查看配置并加载我们需要的相关Zend\I18n\Translator\Loader。如果找到，它将查看当前选定的区域设置（例如，通过setLocale()设置的nl_NL、en_GB、en_US等）然后解析相关的翻译文件——对于 gettext 是.mo，对于 INI 是.ini，对于 PHP 数组是.php等——并让加载器解析。

一旦我们调用translate()或translatePlural()方法，翻译器将在会话中搜索相关的未翻译字符串。如果找到，它可以轻松返回翻译后的字符串，但如果是未翻译的字符串，它将只返回未翻译的字符串。

还有更多...

除了使用 gettext，还有其他几种方法可以作为翻译文件使用。默认情况下，ZF2 有选项使用以下格式之一：

PHP 数组

虽然这是一种可行且易于翻译的方法，但就我个人而言，我不会推荐它。我的个人经验是，使用这种方法限制了翻译文件的使用范围仅限于 PHP。例如，gettext 是一个行业标准，可以被许多平台和应用使用。

在语言目录中，我们将 PHP 文件命名为[language]_[COUNTRY].php的格式，例如nl_NL.php。我们的module.config.php需要如以下代码所示的条目：

'translator' => array(
  'locale' => 'en_US',
  'translation_file_patterns' =>array(
    array(
      // This is the method we want to use.
      'type' => 'phparray',

      // We tell the config that our translations can be 
      // found in the language directory.
      'base_dir' => __DIR__ . '/../language',

      // It will now search for files like en_US.php and 
      // nl_NL.php.
      'pattern' => '%s.php',
    ),
  ),
),

当这在module.config.php文件中定义时，翻译本身将完全相同，翻译文件（例如，nl_NL.php）将类似于以下代码：

<?php

// We need to return an array with the translated 
// strings.
return array(

  // The key is the untranslated string, while the value 
  // is the translated text.
  'And how about me?'=> 'En hoe zit het met mij?',

  // More translations here [..]
);

Gettext

我们在先前的例子中使用了这种格式，正如我们所见，它们可以通过像 Poedit 这样的应用程序轻松编辑。根据维基百科，gettext 最常用的实现是 GNU gettext。编辑 gettext 文件是在所谓的.po文件中完成的，其中 po 代表可移植对象，一旦文件编译用于使用，它们将被放置在.mo文件中，其中 mo 代表机器对象。

我们可以在www.poedit.net/网站上找到翻译工具 Poedit。

Ini

这种ini文件的工作方式基本上与之前描述的任何其他方法相同。语言目录中的文件可以命名为[locale].ini（例如，nl_NL.ini），在module.config.php中，我们会有一个类似于以下代码的条目：

'translator' => array(
  'locale' =>array('en_US', 'nl_NL'),
  'translation_file_patterns' =>array(
    array(
      'type' => 'ini',
      'base_dir' => __DIR__ . '/../language',
      'pattern' => '%s.ini',
    ),
  ),
),

正如我们所见，我们在配置中定义了两个区域设置，这意味着这两个是我们的可用 i18n，但我们的en_US是我们的后备区域设置。后备区域设置在找不到合适的区域设置时使用。我们的翻译文件（nl_NL.ini）将类似于以下示例：

translation.0.message = "And how about me?"
translation.0.translation = "En hoe zit het met mij?"

translation.1.message = "Hello, I am a translated text!"
translation.1.translation = "Hallo, ik ben een vertaaldetekst!"

我们总是从一个翻译开始，使用translation.X，其中X是一个之前未使用的数字。我们应该将其视为一个 INI 数组，类似于它在 PHP 中的工作方式。

本地化您的应用程序

在这个菜谱中，我们将解释本地化及其用途。本地化与国际化的区别在于，本地化指的是例如数字、日期和时间格式，以及货币的使用。

如何操作...

在这个菜谱中，我们将讨论我们应用程序本地化的重要过程。

因此，故事开始了

当用户访问我们的网站时，我们很可能希望用户自动跳转到正确的语言。尽管有几种实现方法，但我们将使用手动检查来查看用户偏好的语言是否也在我们的语言列表中。

我们通过几个简单的技巧来实现这一点：

首先，我们从 HTTP 请求中获取Accept-Language头
然后我们遍历它们，看看标题中提到的语言中是否有与我们所拥有的语言相匹配的
最后，我们将语言设置为找到的语言，或者如果没有找到，则设置为回退语言

让我们看看它在我们的Module.php代码中的样子：

// We will be using a modified version of the default 
// Module.php which comes with the Application module on 
// the ZF2 Skeleton.
namespace Application;

// onBootStrap requires a McvEvent.
use Zend\Mvc\MvcEvent;

首先，我们需要声明命名空间（在我们的情况下是Application），因为我们希望框架知道我们的代码在哪里。然后我们想要确保我们总是将所有必需的类放在使用声明中，这样我们就可以在代码进一步之前预加载这些类。

// Start of our Module class
class Module
{
  // Private storage of all our local languages
  // available.
  private $locales;

  /**
   * Retrieves any locale that is available in the 
   * language directory. This
   * assumes that our language directory contains files 
   * in the format of en_GB.ext, nl_NL.ext.
   */
  private function retrieveLocales()
  {
    // If we haven't already got all the locales,
    // please do it now.
    if ($this->locales === null) {
      $handle = opendir(__DIR__. '/language');
      $locales = array();

     if ($handle !== false) {
       // Loop through the directory
       while (false !== ($entry = readdir($handle))) {
         if ($entry === '..' || $entry === '.') {
            continue;
          }

         // We only want the front part of the filename
          $split = explode('.', $entry);

          // Split[0] should be en_GB if the file is 
          // en_GB.ext.
          if (in_array($split[0], $locales) === false) {
            $locales[] = $split[0];
          }

          unset($split);
        }

        // We are done, now close the directory again
        closedir($handle);
      }

      // Make sure the locale is available for next time
      $this->locales = $locales;

      unset($handle, $locales);
    }

    // Return our available locales
    return $this->locales;
  }

在retrieveLocales()方法中，我们正在解析语言目录，并假设我们的文件名为en_GB.ext。这样我们就可以轻松地将所有语言解析到一个数组中：

public function onBootstrap(MvcEvent $e)
{
  // Retrieve the HTTP headers of the user's request
  $headers = $e->getApplication()
               ->getRequest()
               ->getHeaders();

  // Get the translator
  $translator = $e->getApplication()
                  ->getServiceManager()
                  ->get('translator');

  // Check if we have a user that accepts specific 
  // languages.
  if ($headers->has('Accept-Language')) {
    // Retrieve our locales that our user accepts
    $headerLocales = $headers->get('Accept-Language')
                             ->getPrioritized();

    // Retrieve the locales that we have in our system
    $locales = $this->retrieveLocales();

    // Make sure that our fallback has been set in 
    // case we couldn't find a locale
    $translator->setFallbackLocale('en_US');

    // Go through all accepted languages, most of the 
    // time this will be only 1 or 2 languages.
    foreach ($headerLocales as $locale) {
      // getLanguage retrieves languages in a en-GB 
      // manner, but ZF2 only supports the underscore, 
      // like en_GB.
      $language = str_replace(
        '-', 
        '_', 
        $locale->getLanguage()
      );

      // See if this is a language we support in our application.
      if (in_array($language, $locales) === true) {
       // We have found our *exact* match
        break;
      }
    }

    // Now set our locale 
    $translator->setLocale($language);
  }
}

// We can just use the methods that are already in the 
// module.php, let's not repeat that code here.  
public function getConfig() {}

public function getAutoloaderConfig() {}
}

如前所述的代码所示，我们试图实现的是查看我们是否与支持的语言（en_GB、nl_NL）中的任何一个完全匹配。如果没有找到完全匹配，我们已经确保正在使用回退语言（en_US）。

小贴士

请确保在配置中启用了 PHP 的intl扩展，否则此示例将无法正确工作。

本地化货币

在 Zend Framework 2 中，可以通过 i18n 视图助手在视图中本地化货币，该助手是 ZF2 的标准功能。可以通过以下方法调用轻松在视图中使用名为CurrencyFormat的视图助手。我们对sometemplate.phtml文件进行了以下修改：

<?php

// We always use $this for accessing a view helper.
echo $this->currencyFormat(45312.56, "EUR", "nl_NL");

这段代码将输出45.312,56 €，因为我们指定了使用荷兰本地化格式本地化欧元货币符号，在这种情况下是千位点的逗号和十位点的分隔符。我们也可以省略nl_NL，然后CurrencyFormat视图助手将自动选择应用程序的默认区域设置。

本地化日期/时间

要在我们的应用程序中格式化任何日期和时间，我们可以使用 DateFormat 视图助手，它就像货币视图助手一样容易使用，但有一些额外的选项可以使用。我们对 sometemplate.phtml 文件进行了以下修改。

<?php
echo $this->dateFormat(
    // Format the current UNIX timestamp.
    time(),

    // Our date is to be a LONG date format.
    IntlDateFormatter::LONG,

    // We want to omit the time, defining this is 
    // optional as the default is NONE.
    IntlDateFormatter::NONE
);

之前的代码只会显示日期，它将被格式化为 Monday, May 14, 2012 AD。我们可以省略提供任何参数，但这样将不会显示任何内容，因为默认选项是 IntlDateFormatter::NONE。

它是如何工作的…

本地化（l10n）就像国际化（i18n）一样，是公共应用程序的一个重要方面。我们在上一个食谱中讨论了如何确保你的应用程序可以翻译，但现在我们需要确保我们能够找到使用任何 l10n 的方法。

Zend Framework 2 与 PHP 内置的 i18n/l10n 功能紧密协作。尽管我们可以单独使用 PHP 的 Locale 类而不依赖于 ZF2 类，但并不推荐这样做，因为 ZF2 已经使用了 PHP 自身的 Locale，但它提供了一个更优雅、更快捷的接口。

然而，在幕后，ZF2 直接与 PHP 的 Locale 进行通信，但如果我们想使用更强大的功能，我们应该使用 ZF2 库（这在创建多语言 Web 应用程序时非常有用）。

识别客户端语言

之前的示例代码依赖于客户端浏览器发送 Accept-Language 头部。尽管大多数现代浏览器都会这样做，但这仍然可能不是总是可行的。总的来说，这是一个相当好的工具，可以预先选择任何语言。

与之前展示的自行构建一切不同，还有一个非常巧妙的模块叫做 SlmLocale，由 Jurian Sluiman 创建（github.com/juriansluiman/SlmLocale），我们推荐用于检测和选择默认区域设置。

本地化货币和日期

本地化货币和日期通常在视图中完成，因为这基本上只是格式化信息的一部分。你可以在其他地方做，但我们应该始终小心，确保我们不会在例如模型中本地化任何内容，因为它们只应包含逻辑。在大多数情况下，语言不是逻辑的一部分，而是一种使视图更用户友好的简单方式。

发送邮件

通过 sendmail 发送电子邮件通常是一种相当标准的操作方式，因为它可能是 Linux 系统上传输电子邮件（或代理电子邮件到 SMTP 服务器）最常用的方式之一。在大多数 Linux 服务器上，sendmail 已经安装好了，因此使用它来发送电子邮件非常简单。

因此，我们将首先讨论这种发送电子邮件的方法，这样我们可以从简单开始。

如何操作…

在本食谱中，我们将讨论在应用程序内部发送邮件的方法。

Transport\Sendmail

让我们看看以下通过sendmail发送电子邮件的示例，尽管这个功能被放置在控制器中，但在现实生活中，这需要远离控制器，安全地放置在模型中：

<?php

namespace Application\Controller;

// We need the following libraries at a minimum to 
// send an e-mail.
use Zend\Mail\Message;
use Zend\Mail\Transport\Sendmail;
use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractActionController
{
  public function indexAction()
  {
    // We start off by creating a new Message, which 
    // will contain our message body, subject, to, 
    // etcetera.
    $message = new Message();

    // Add the options we would like to give the 
    // message, in this case we will be creating a text 
    // message.
    $message->addFrom('awesome.coder@example.com')
            ->addTo('rookie.coder@example.com')
            ->setSubject('Watch and learn.')
            ->setBody('My wisdom in a message.');

    // Now we have set up our message, let's initialize 
    // the transport.
    $sendmail = new Sendmail();

    // Although checking isValid is optional, it is a 
    // great way of checking if our message would send 
    //if we are getting input from outside.
    if ($message->isValid() === true) {
      // Send the message through sendmail.
      $sendmail->send($message);
    }
  }
}

通常情况下，设置通过sendmail发送的电子邮件不需要配置，因为它仅是本地主机上的邮件传输应用程序。

Transport\Smtp

如果我们想通过 SMTP 发送电子邮件（如果我们知道 SMTP 服务器的详细信息的话）：

<?php
// Usually this sort of code is defined in the Model, 
// but to test it out we can place it in the 
// controller as well.
namespace Application\Controller;

// We need these classes to initiate a SMTP sending.
use Zend\Mail\Message;
use Zend\Mail\Transport\Smtp;
use Zend\Mail\Transport\SmtpOptions;
use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractActionController
{
  public function indexAction()
  {
    // First we built up a small message that we want to 
    // send off.
    $message = new Message();

    // We need at least one recipient and a message body 
    // to send off a message.
    $message->addTo('someone@example.com')
            ->addFrom('developer@example.com')
            ->setSubject('An example message!')
            ->setBody('This is a test message!');

    // Now we created our message we need to set up our 
    // SMTP transportation.
    $smtp = new Smtp();

    // Set our authentication and host details of our 
    // SMTP server.
    $smtp->setOptions(new SmtpOptions(array(
      // Name represents our domain name.
      'name' => 'ourdomain.com',

      // Host represents the SMTP server that will 
      // handle the sending of our mail. This could also 
      // be 'localhost' if the sending happens on our 
      // local server.
      'host' => 'smtp.somewhere.com',

      // Port is default 25, which in most cases is 
      // fine, but this is just to show how we can 
      // change it.
      'port' => '1234',

      // Connection class is the class used for 
      // authenticating with the SMTP server. Normally 
      // login will suffice, but sometimes the SMTP 
      // server requires a PLAIN (plain) or CRAM-MD5 
      // (crammd5) authentication method.
      'connection_class' => 'login',

      // This tells the connection_class which 
      // properties to set. The default three connection
      // classes only require username and password.
      'connection_config' =>array(
        'username' => 'someuser',
        'password' => 'someplainpassword',
      ),
    ))); 

    // We have set the options, now let's send the 
    // message.
    $smtp->send($message);
  }
}

Transport\File

让我们看看如何将我们的电子邮件发送到文件的示例…

<?php
// Usually this sort of code is defined in the Model, 
// but to test it out we can place it in the 
// controller as well.
namespace Application\Controller;

// We need these classes to initiate a SMTP sending.
use Zend\Mail\Message;
use Zend\Mail\Transport\File;
use Zend\Mail\Transport\FileOptions;
use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractActionController
{
  public function indexAction()
  {
    // First we create our simple message. 
    $message = new Message();

    // Set the essential fields send it off.
    $message->addTo('someone@example.com')
            ->addFrom('developer@example.com')
            ->setSubject('An example message!')
            ->setBody('This is a test message!');

    // Now we will initialize our File transport.
     $file = new File();

    // Set the options for the File transport.
    $file->setOptions(new FileOptions(array(
      // We want to save our e-mail in the /tmp path,   
      // this can be anything where we have write  
      // permission on.
      'path' => '/tmp',

      // Define our callback, which will be ran when 
      // the e-mail is being saved to our system. This 
      // also called an anonymous function, as it 
      // isn't defined as a normal method.
      'callback' = function(File $file) {

      // We want to return a name in which the file 
      // should be saved, which should be a unique.
      return 'mail_'. time(). '.txt';
    }
   )));

   // Now send off the message.
   $file->send($message);
  }
}

发送电子邮件后，文件传输器将创建一个可能看起来像mail_453421020.txt的文件。我们指定了/tmp作为文件应该保存的目录，我们应该在那里查看我们的文件是否存在。

当然，我们可以在回调函数中做任何事情，例如，我们可以检查某个文件是否存在，或者从数据库中拉取一个名称。选项是无限的。

工作原理…

Zend Framework 2 需要至少两个对象来使电子邮件发送工作。首先是Zend\Mail\Message对象，用于完全定义需要发送的消息。我们可以在该对象中定义to、cc、bcc和from地址。该对象还用于设置消息正文；这可以是 HTML 或纯文本，完全取决于我们的需求。

作为第二个对象，我们需要一个类来实现Zend\Mail\Transport\TransportInterface类，该类负责处理电子邮件的实际发送。这个类目前（至少现在）只定义了一个send(Mail\Message $message)方法，在我们实现传输时需要添加。

定义两个对象之后，我们将Message对象交给Transport对象，并告诉它发送。发送是如何处理的，显然是由Transport对象决定的。

通过 SMTP 发送邮件

通过 SMTP 传输邮件可能对我们来说不熟悉，但它是通过另一个系统发送电子邮件的常用方法。想想看，桌面电子邮件客户端从另一个服务器检索我们的电子邮件。当我们从这个相同的电子邮件客户端发送电子邮件时，我们可能会使用 SMTP 来发送它。简而言之，SMTP 是将电子邮件发送到另一个邮件服务器，然后由该服务器为我们处理邮件传输。

通过文件发送邮件

虽然不常用，但有一些电子邮件发送者会简单地从特定目录中提取需要发送的完整消息的纯文本文件，并将它们发送出去。显然，如果我们没有测试实际电子邮件发送的方法，这也是测试系统是否工作的一种很好的方式。

接收邮件

现在，让我们处理接收邮件的部分。

准备工作

在这个菜谱中，我们将给出通过 ZF2 连接到邮箱的不同方法的示例，因此如果我们能访问我们连接到的邮箱那就太好了。当然，这不是必需的，但有一个实际工作的邮箱确实增加了乐趣。

如何做到这一点...

我们现在将讨论在应用程序内接收电子邮件，这在某些场合可能很有用。

连接到 IMAP 邮件服务器

连接到邮件服务器的第一种方法是使用 IMAP。该协议基本上允许我们连接到邮件服务器，并在服务器上的不同文件夹中查找是否有未读电子邮件。

让我们来看看我们的示例：

<?php
// Usually this sort of code is defined in the Model,
// but to test it out we can place it in the 
// controller as well.
namespace Application\Controller;

// We need these classes to initiate an IMAP connection
use Zend\Mail\Storage\Imap;
use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractActionController
{
  public function indexAction()
  {

    // We will create a new IMAP connection here:
    // host: user/password: The username and password 
    // to use. 
    $mail = new Imap(array(
   // Refers to the host where we want to connect to.
   'host' => 'imap.example.com',

   // The username/password to connect to the server 
   // with.
   'user' => 'some_user',
   'password' => 'some_password',

   // Do we want to explicitly use a secure 
   // connection.
   'ssl' => true,

   // If we want to use a port that is different to 
   // the default port, we can do that here.
   'port' => 1234,

   // Specify the folder we want to use, if none 
   // given it will always use INBOX. This will also 
   // work with the Mbox and Maildir protocol.
   'folder' => 'Some_Folder',
 ));

 // We want to parse through all our e-mails.
 foreach ($mail as $message) {
   // Display the from and subject line.
      echo $message->from. ': '. $message->subject;
    }
  }
}

连接到 POP3 邮件服务器

让我们来看看我们的简单连接示例：

<?php
// Usually this sort of code is defined in the Model, 
// but to test it out we can place it in the 
// controller as well.
namespace Application\Controller;

// We need these classes to initiate a POP3 connection
use Zend\Mail\Storage\Pop3;
use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractActionController
{
  public function indexAction()
  {        
    // We will create a new POP3 connection here
    $mail = new Pop3(array(
      // Refers to the host where we want to connect 
      // to
      'host' => 'pop3.example.com',

      // The username/password to connect to the 
      // server with.
      'user' => 'some_user',
      'password' => 'some_password',

      // Do we want to explicitly use a secure 
      // connection.
      'ssl' => true,

      // If we want to use a port that is different to 
      // the default port, we can do that here.
      'port' => 4321
    ));

    // We want to parse through all our e-mails.
    foreach ($mail as $message) {
      // Display the from and subject line.
      echo $message->from. ': '. $message->subject;
    }
  }
}

在 IMAP 或 Maildir 连接上处理标志

标志是附加到消息上的属性，我们可以从中看到消息的特定属性。简单来说，它可以告诉我们，例如，消息是否已阅读或回复。我们可以通过使用 getFlags() 方法或 hasFlag() 方法从消息中获取标志。可用的标志可以在 Zend\Mail\Storage 类中找到。

Maildir++ 配额系统

让我们来看看以下示例：

<?php
// Usually this sort of code is defined in the Model,
// but to test it out we can place it in the 
// controller as well.
namespace Application\Controller;

// We need these classes to initiate a Maildir storage 
// connection
use Zend\Mail\Storage\Maildir;
use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractActionController
{
  public function indexAction()
  {	
    // Open up a new Maildir connection
    $mail = new Maildir(array(
      // Our mail folder on the server.
      'dirname' => '/home/user/.mymail/'
    ));

    if ($mail->checkQuota() === true) {
      // We are over quote, let's check what we are 
      // using!

      // Give us extended information about the quota.
      $quota = $mail->checkQuota(true);

      // Normalise the string if we are over the
      // quota.
      $overQuota = $quota['over_quota'] ? 'Yes' : 'No';

      // Display the information.
      echo "
        -- QUOTA --
        Total quota size: {$quota['quota']['size']}
        Total quota objects: {$quota['quota']['count']}
        -- USE --
        Total used size: {$quota['size']}
        Total used objects: {$quota['count']}
        Are we over quota: {$overQuota}
     ";
    }
  }
}

保持连接活跃

以下是一个使用 NOOP 的示例：

<?php
// Usually this sort of code is defined in the Model,
// but to test it out we can place it in the 
// controller as well.
namespace Application\Controller;

// We need these classes to initiate a IMAP connection
use Zend\Mail\Storage\IMAP;
use Zend\Mvc\Controller\AbstractActionController;

class IndexController extends AbstractActionController
{
  public function indexAction()
  {
    // Open up a new connection to the mail server.
    $mail = new Imap(array(
     'host' => 'imap.example.com',
     'user' => 'some_user',
     'password' => 'some_password'
  ));

 // Loop through the messages.
 foreach ($mail as $message) {
   /** Do stuff which takes a lot of time.. **/

   // Now let the server know we are still alive..
   $mail->noop(); 

   /** Do some more stuff..  **/

   // Let the server know again we are still here..
   $mail->noop();
    }
  }
}

这里棘手的部分是何时使用 noop()，因为有时很难预测哪个进程耗时最长。这就是为什么我们创建了一个特殊的示例来向您展示确保 noop() 定期执行有多容易，直到我们完成我们的进程。

我们可以通过利用 register_tick_function 来实现这一点，它使我们能够在每个 tick 上调用一个特定的进程。我们将创建一个处理 noop() 的类，并每 5 分钟执行一次，直到我们说它应该停止：

<?php

// We can make this anything we want, we just decided on 
// this though
namespace Application\System;

// Lets call our class this
class NoopTick
{
  // This is our Zend\Mail\Storage\Imap which is a 
  // static so we can call from outside the context of 
  // this class without instantiating the class
  private static $imap;

  // This is the time value in seconds of the next time 
  // we want to execute our noop functionality
  private static $newTime;

  // This is the amount of seconds between noop
  // executions, which in this case is 5 minutes
  private static $timeInBetween = 300;

  // This is our main method, which will only call the 
  // noop method
  public static function tickTock()
  {
    if (time() >= self::$newTime) {
      // We can execute our noop now
      self::$imap->noop();

      // Now set the new time
      self::$newTime = (time() + self::$timeInBetween);
    }
  }

  // Now we want to have a method that starts up the 
  // noop triggering
  public static function start($imap)
  {
    // Set our imap storage to use
    self::$imap = $imap;

    // Now we register the tick function, which executes 
    // every tick of the process, we will use the class 
    // NoopTicks (this class) and method 'tickTock'
    register_tick_function(array(
      'Application\System\NoopTick','tickTock'
    ));
  }

  // And we now unregister our tick function again when 
  // we are done with our operation
  public static function stop()
  {
    // Unregister our tick function again, mind that we 
    // don't have to provide our class name here
    unregister_tick_function('tickTock');
  }
}

如果我们现在遇到一段需要长时间执行的代码，我们可以轻松地调用 start() 方法来为我们执行 NOOP，如下面的代码行所示：

Application\System\NoopTick::start($imapStorage);

当我们完成时，我们只需再次 stop() NOOP'ing，如下面的代码行所示：

Application\System\NoopTick::stop();

它是如何工作的...

邮箱正在连接；然而，在 ZF2 中我们将它们视为存储对象。正因为如此，我们可以轻松地遍历所有消息，在某些情况下，我们甚至能够操纵存储中的消息，例如复制或移动它们。我们需要记住，消息始终是只读的，而存储是可以被操纵的。例如，我们可以创建和删除文件夹，但永远不能编辑现有的消息。

我们用于操作消息的唯一可写功能是 appendMessage()，它将消息追加到存储中。但是，当它被存储后，我们就无法再次编辑它。

连接到 POP3 服务器

使用 POP3 服务器连接与使用 IMAP 服务器非常相似（方便，不是吗？）。唯一的重大区别通常在于，使用 POP3 服务器，在检索消息后，消息会从邮件服务器上消失，除非我们明确告诉服务器否则。

关于 Maildir++配额系统

Maildir++是 Maildir 的扩展版本，但仍然与正常的 Maildir 程序兼容，并支持配额系统。这是一个非常有用的系统，因为它有配额以及如何存储消息（在文件系统上）。这个系统在许多公司中被使用，但显然它也伴随着自己的问题。例如，当尝试在 Maildir++服务器上写入/复制消息时，可能会抛出异常，因为我们已经超过了系统配额。

正因如此，除非你确定 Maildir++没有被使用，否则在尝试执行任何基于写入的功能之前，实施一个配额检查是明智的。

保持连接活跃

一旦建立了连接并且解析消息被实例化，如果时间过长，连接有很大可能会关闭。在那个时刻，实施一个“无操作”命令，或称 NOOP，总是明智的。这将告诉邮件服务器我们还在那里，但此刻正在做其他事情。

还有更多…

显然，关于从邮件服务器检索电子邮件还有很多可以说的，找到所有这些内容将是一次伟大的冒险。不幸的是，详细讲解所有高级细节几乎可以写成一本书，所以我们只列出了一些值得探索的主题：

缓存实例（参见第八章优化性能，优化性能）
读取 HTML 消息，或带有附件的多部分消息
在 IMAP/Maildir/Mbox 上的文件夹的高级使用
协议类扩展
通过配置设置电子邮件箱设置

第三章. 处理和装饰表单

在本章中，我们将涵盖：

创建表单
使用表单视图辅助工具
创建自定义表单元素和表单视图辅助工具

简介

在本章中，我们将讨论表单，特别是它们的生成和处理。表单在与用户通信中起着非常重要的作用，因为它是从用户那里接收信息的一种方式。同时，结合 JavaScript 和 PHP，使用表单对元素进行大量验证也是一个很好的方法。如果我们还能让它看起来很棒，我们为什么不这样做呢？

创建表单

这个配方涉及创建表单的不同方法，然后我们将讨论如何将元素添加到表单中。在这个配方的最后部分，我们将讨论如何验证表单，以及完成此任务的最佳方式。

准备工作...

创建和输出表单所需的至少有一个模块的基本 ZF2 骨架应用程序是必要的。

如果我们想使用表单注解，我们也需要在骨架中初始化 Doctrine\Common，因为它有解析注解的解析引擎。如果我们使用 composer（它包含在 Zend Framework 2 骨架中），我们可以简单地更新我们的 composer.json 文件，在所需部分添加以下行：

"doctrine/common": ">=2.1",

小贴士

确保行尾的逗号只有在还有行在其下方时才存在。如果除了一个闭合括号之外没有其他行跟在此行之后，请勿添加逗号，因为它将导致过程失败。

接下来是运行 composer update 命令以确保其被安装，可以使用以下类似命令：

php composer.phar update

如果我们不使用 composer，我们最好查看 Doctrine 项目网站 (www.doctrine-project.org/projects/common.html) 以获取有关如何安装此项目的更多信息。

如何做到这一点...

我们首先将讨论创建表单和元素，然后我们将讨论添加过滤器和验证。

创建基本表单

表单始终需要是以下之一：

从 Zend\Form 类扩展的类
使用 Zend\Form\Annotation 定义方法的类

定义一个从 Zend\Form 扩展的表单

我们将从定义第一个方法开始，通过从 Zend\Form 类扩展它。如果我们是 Zend Framework 2 (ZF2) 的新手，这可能是开始的最简单方法。

基本思想是我们的表单类应该从 Zend\Form 类扩展，并且至少有一个 __construct 方法来定义我们的元素。

让我们看看 /module/Application/src/Application/Form/NormalForm.php 文件中的以下示例：

<?php

// We define our namespace here
namespace Application\Form; 

// We need to use this to create an extend 
use Zend\Form\Form; 

// Starting class definition, extending from Zend\Form
class NormalForm extends Form 
{
  // Define our constructor that sets up our elements 
  public function __construct($name = null) 
  {
    // Create the form with the following name/id
    parent::__construct($name);
  }
}

如果我们现在去我们的控制器，比如 Application 模块的 IndexController，我们可以通过在文件 /module/Application/src/Application/Controller/IndexController.php 中执行以下操作将表单输出到视图：

<?php

// Namespace of the controller
namespace Application\Controller;

// Use the following classes at a minimum
use Zend\Mvc\Controller\AbstractActionController;
use Application\Form\NormalForm;
use Zend\View\Model\ViewModel;

// Begin our class definition
class IndexController extends AbstractActionController
{
  // Set up our indexAction,  in which we want to 
  // display our form.
  public function indexAction()
  {
    // Initialize our form
    $form = new NormalForm();

    // Return the view model to the user, with the 
    // attached form
    return new ViewModel(array(
        'form' =>  $form
    ));
  }
}

如果我们现在查看我们的视图脚本，我们可以看到我们有一个可用的变量。现在，我们将通过以下示例将表单实际输出到屏幕（文件/module/Application/view/application/index/index.phtml）：

<?php
  // Output the opening FORM tag: <form>
  echo $this->form()->openTag($this->form); 

  // Output the formatted elements of the form
  echo $this->formCollection($this->form);

  // Output the closing FROM tag </form>
  echo $this->form()->closeTag();

这个代码示例的输出将类似于以下内容：

<form action="" method="POST" name="normalform" id="normalform"></form>

这告诉我们实例化进行得很顺利，并且它是完全功能的。正如我们也可以看到，我们定义的名称（"normalform"）正在作为表单的name和id返回。

定义一个使用 Zend\Form\Annotation 的表单

让我们看看一个空表单（/module/Application/src/Application/Form/AnnotationForm.php）在注解表单中的样子：

<?php

// We first define our namespace as usual
namespace Application\Form;

// We need to use this otherwise it will not parse the 
// elements correctly.
use Zend\Form\Annotation;

/**
 * We want to name this form annotationform, which is 
 * why we use the tag below, defining the name. 
 *
 * @Annotation\Name("annotationform")
 * 
 * A hydrator makes sure our framework can 'read' the 
 * properties in our object, in this case we tell our 
 * annotation engine that we have an object that needs 
 * its properties read. There is probably a more 
 * technical, accurate way of explaining it, but let's 
 * just keep it to this for now. 
 *
* @Annotation\Hydrator(
 *     "Zend\Stdlib\Hydrator\ObjectProperty
 * ")
*/
class AnnotationForm
{
  /**
   * If we want to exclude properties in our form just 
   * use the Exclude annotation.
   * 
   * @Annotation\Exclude()
   */
  public $id;
}

如果我们现在想开始将表单输出给用户，我们可以用类似正常表单的方式来做（幸运的是）。为此，我们首先需要做的是实际上再次将表单分配给视图（/module/Application/src/Application/Controller/IndexController.php），这是与正常表单创建略有不同的一点。

<?php

// Namespace of the controller
namespace Application\Controller;

// Use the following classes at a minimum
use Zend\Mvc\Controller\AbstractActionController;
use Application\Form\AnnotationForm;
use Zend\Form\Annotation\AnnotationBuilder;
use Zend\View\Model\ViewModel;

// Begin our class definition
class IndexController extends AbstractActionController
{

  // Set up our indexAction,  in which we want to 
  // display our form.
  public function indexAction()
  {
    // Set up the output model
    $viewModel = new ViewModel;

    // Instantiate the AnnotationBuilder which will 
    // create the actual form object
    $builder = new AnnotationBuilder();

    // Instantiate our annotated form
    $annotationForm = new AnnotationForm();

    // Now let the annotation builder create the form 
    // from scratch
    $form = $builder->createForm($annotationForm);

    // Set our form to be the form variable in the view
    $viewModel->setVariable('form', $form);

    // Return the view model to the user
    return $viewModel;
  }
}

如果我们现在想将表单输出到我们的视图（文件/module/Application/view/application/index/index.phtml），我们可以简单地像处理其他表单一样做：

<?php
  // Output the opening FORM tag: <form>
  echo $this->form()->openTag($this->form); 

  // Output the formatted elements of the form
  echo $this->formCollection($this->form);

  // Output the closing FROM tag </form>
  echo $this->form()->closeTag();

这个示例的 HTML 输出将产生以下内容：

<form action="" method="POST" name="annotationform" id="annotationform"></form>

向 Zend\Form 扩展表单添加元素

在这种表单中创建元素相当简单，让我们通过一个简短的例子来看看它是什么样子（文件/module/Application/src/Form/NormalForm.php）：

// Adding a simple input text field
public function __construct($name = null) 
{
  // Create the form with the following name/id
  parent::__construct($name); 

  $this->add(array( 	
    // Specifying the name of the field
    'name' => 'name', 

    // The type of field we want to show
    'type' => 'Zend\Form\Element\Text', 

    // Any extra attributes we can give the element
    'attributes' => array( 
      // If there is no text we will display the 
      // placeholder
      'placeholder' => 'Your name here...', 

      // Tell the validator if the element is required 
      // or not
      'required' => 'required', 
    ), 

    // Any extra options we can define
    'options' => array(  
      // What is the label we want to give this element
      'label' => 'What is your name?', 
    ), 
  )); 
}

向注解表单添加元素

让我们以一个注解元素创建的例子为例：

class AnnotationForm
{
 /**
   * Add two filters to this element.
   *
   * @Annotation\Filter({"name": "StringTrim"})
   * @Annotation\Filter({"name": "StripTags"})

   * Add a validator to make sure the string length 
   * isn't going to be longer than 50, but also not 
   * smaller than 5.
   *
   * @Annotation\Validator({
   *    "name": "StringLength", 
   *    "options":{
   *        "min": 5, 
   *        "max": 50, 
   *        "encoding": "UTF-8"
   * }})
   *

   * Set this element to be required.
   * 
   * @Annotation\Required(true)

   * Set the attributes for the element
   *
   * @Annotation\Attributes({
   *     "type": "text", 
   *     "placeholder": "Your name here...", 
   * })

   * Set the options of this element.
   *
   * @Annotation\Options({
   *    "label": "What is your name?"
   * })
   */
  public $name;

验证表单输入

拥有表单最重要的一个方面是使用我们应用程序中的数据，因为如果不是为了使用这些数据，我们最初为什么要创建表单呢？

让我们去创建一个简单的模型（/module/Application/src/Application/Model/SampleModel.php），稍后我们可以用它作为例子，但这个模型对这道菜谱来说完全没有其他用途。

<?php

namespace Application\Model;

class SampleModel
{
  public function doStuff($array) { 
    return true; 
  }
}

如我们所见，这个模型根本什么都没做，但我们稍后还需要它。

我们现在已经创建了自己的表单扩展，所以现在是时候创建我们的InputFilter类了，这个类将过滤和验证我们将要放入表单中的值，稍后通过setInputFilter将其附加到表单上（我们将编辑文件/module/Application/src/Application/Form/NormalFormValidator.php）：

<?php

// Of course our namespace first
namespace Application\Form; 

// As this will be an input filter, we need the 
// following imports to make it work
use Zend\InputFilter\Factory as InputFilterFactory; 
use Zend\InputFilter\InputFilter; 
use Zend\InputFilter\InputFilterAwareInterface; 
use Zend\InputFilter\InputFilterInterface; 

// Create our class, which should be implementing the 
// InputFilterAwareInterface if we want to attach it to 
// the form later on
class NormalFormValidator implements 
InputFilterAwareInterface
{ 
  // This is the input filter that we will create
  protected $inputFilter; 

  // This method is required by the implementation, but 
  // we will just throw an exception instead of setting 
  //the input filter as we don't want anyone to override 
  // us
  public function setInputFilter(InputFilterInterface $inputFilter) 
  { 
    // We want to make sure that we cannot set an input 
    // filter, as we already do that ourselves
    throw new \Exception("Cannot set input filter."); 
  }

我们现在已经开始创建我们的输入过滤器类，并且已经创建了InputFilterAwareInterface的两个必需方法之一。现在，让我们继续到实现第二个方法，并构建实际的过滤器：

// This is the second method that is required by the 
// interface
public function getInputFilter() 
{ 
  // If our input filter doesn't exist yet, create one
  if ($this->inputFilter === null) {
    // Create the input filter which we will put in our 
    // property later
    $inputFilter = new InputFilter(); 

    // Also instantiate our factory so we can get more 
    // filters at ease
    $factory = new InputFilterFactory(); 

    // Let's add a filter for our name Element in our 
    // form
    $inputFilter->add($factory->createInput(array(
      // This is the element is applies to
      'name' => 'name', 

      // We want no one to skip this field, we need it
      'required' => true, 

      // Now we are defining the filters, which make 
      // sure that no malicious or invalid characters 
      // are supplied
      'filters' => array( 
        // Make sure no tags are in our value, which 
        // could make our system vulnerable for hacks
        array('name' => 'StripTags'), 

        // We want to make sure our string doesn't 
        // have any leading or trailing spaced	
        array('name' => 'StringTrim'), 
      ), 

      // Validators make the form generate errors when 
      // the data is invalid, filters only filter	
      'validators' => array( 
        array ( 
          // We want to add a validator that checks the 
          // length of the string received
          'name' => 'StringLength', 
          'options' => array( 
            // Check if the string is in UTF-8 encoding  
            // and between the 5 and 50 characters long
            'encoding' => 'UTF-8', 
            'min' => '5', 
            'max' => 50', 
          ), 
        ), 
      ), 
    )));

我们刚刚添加了一个简单的验证器，确保字符串的长度不小于 5 个字符，也不大于 50 个字符，当然，在我们的案例中，我们还想使用UTF-8字符，但显然，如果我们需要的话，我们可以取消选择这个选项或更改字符集。

现在，我们将添加一个简单的密码字段验证器和过滤器，但下一个验证器将检查repeat_password字段是否与密码字段值相同。我个人非常喜欢这个验证器，因为它简单而且足够强大，可以减少一些手动劳动。

    // We are doing the same trick again for the 
    // password, so we can just skip over this, as this 
    // was just necessary for the one after this one.
    $inputFilter->add($factory->createInput(array(
      'name' => 'password', 
      'filters' => array( 
        array('name' => 'StripTags'), 
        array('name' => 'StringTrim'), 
      ), 
      'validators' => array( 
        array ( 
          'name' => 'StringLength', 
          'options' => array( 
            'encoding' => 'UTF-8', 
            'min' => '5', 
          ), 
        ), 
      ), 
    )));

    // And here is the great piece of validation we 
    // wanted to show off. This validator checks if the 
    // value of the given element is identical to 
    // another fields value. This way we don't have to 
    // manually check if the password is the same as the 
    // repeat password field.
    $inputFilter->add($factory->createInput(array(
      'name' => 'password_verify', 
      'filters' => array( 
        // The usual filters, as we almost always want 
        // to be sure it contains no tags or 
        //trailing/leading spaces
        array('name' => 'StripTags'), 
        array('name' => 'StringTrim'), 
      ), 
      'validators' => array( 
        array( 
          'name' => 'identical', 
          'options' => array( 
            'token' => 'password', 
          ), 
        ), 
      ), 
    )));

在那个巧妙的验证器之后，我们现在将添加一个简单的电子邮件验证器，它也将有一个非空验证器，用于检查字段是否为空。我们将使用以下代码进行电子邮件验证：

// Email validator works perfectly, especially if we 
// don't want to trust any client side validation 
// (which we shouldn't)
$inputFilter->add($factory->createInput(array(
  'name' => 'email', 
  'filters' => array( 
     array('name' => 'StripTags'), 
     array('name' => 'StringTrim'), 
  ), 
  'validators' => array( 
    array ( 
       'name' => 'StringLength', 
       'options' => array( 
       'encoding' => 'UTF-8', 
       'min' => '5', 
       'max' => '250', 
        ), 
      ), 
      array( 
        // Don't you hate it when you get email 
        // addresses that are not valid? Well, no 
        // more as we can simply validate on that 
        // as well.
        'name' => 'EmailAddress', 
        'options' => array( 
        'messages' => array( 
            // We can even leave a neat little error 
            // message to display
            'emailAddressInvalidFormat' => 'Your email seems to be invalid', 
          ) 
        ), 
      ), 
      array( 
        // This validator makes sure the email 
        // address is not left empty. And although we 
        // can simply say this field is required, 
        // this will give us the opportunity to leave 
        // a nice error message that is relevant to 
        // the user as well
        'name' => 'NotEmpty', 
        'options' => array( 
        'messages' => array( 
            // This message is displayed when the 
            // field is empty, instead of a 'field 
            // required' message as we didn't make 
            // the field required
            'isEmpty' => 'I am sorry, your email is required', 
          ) 
        ), 
      ), 
    ), 
  )));

即使是日期验证也不是问题，我们甚至可以做得更好，只允许我们选择日期范围，这在某些情况下（例如 18+网站）是非常有用的。

      $inputFilter->add($factory->createInput(array(
        'name' => 'birthdate', 
        'required' => true, 
        'filters' => array( 
          array('name' => 'StripTags'), 
          array('name' => 'StringTrim'), 
        ), 
        'validators' => array( 
          array(
            'name' => 'Between',
            'options' => array(
              // We can define the ranges of dates 
              // here, min and max are both optional, 
              // as long as one of them at least exists
              'min' => '1900-01-01', 
              'max' => '2013-01-01', 
            ),
          ),
        ), 
      )));

      // Set the property
      $this->inputFilter = $inputFilter;
    }

    // End of our method, just return our created input 
    // filter now
    return $this->inputFilter;
  } 
}

让我们立即开始，看看一个简单的例子，它使用我们的normalform，就像之前一样（/module/Application/src/Application/Controller/IndexController.php）：

<?php

// Define the namespace of our controller
namespace Application\Controller;

// We need to use the following classes
use Zend\Mvc\Controller\AbstractActionController;
use Zend\View\Model\ViewModel;
use Application\Form\NormalForm;
use Application\Form\NormalFormValidator;
use Application\Model\SampleModel;

// Set up our class definition
class IndexController extends AbstractActionController
{
  // We want to parse/display our form on the index
  public function indexAction()
  {
    // Initialize our form
    $form = new NormalForm(); 

    // Set our request in a local variable for easier
    // access
    $request = $this->getRequest();

    if ($request->isPost() === true) {
      // Create a new form validator
      $formValidator = new NormalFormValidator();

      // Set the input filter of the form to the form
      // validator
      $form->setInputFilter(
          $formValidator->getInputFilter()
      );

      // Set the data from the post to the form
      $form->setData($request->getPost());

      // Check with the form validator if the form is 
      // valid or not
      if ($form->isValid() === true) { 
        // Do some Model stuff, like saving, this is 
        // just an empty model we created to show what 
        // probably would happen after a validation 
        // success.
        $user = new SampleModel();

        // Get *only* the filtered data from the form
        $user->doStuff($form->getData());

        // Done with this, unset it
        unset($user);
      }
    }

    // Return the view model to the user
    return newViewModel(array(
        'form' => $form
    ));
  }
}

它是如何工作的…

让我们了解我们是如何实现我们所实现的。

设置基本表单

之前的第一例，创建一个从Zend\Form扩展的表单类，这是设置表单的最基本要求。正如我们所看到的，这个表单目前没有任何元素或属性设置，它唯一定义的是表单对象的 DOM 元素的name/id。在那之后我们所做的是首先初始化表单，然后将ViewModel分配给它，因为这将是要输出到屏幕的视图。

在例子中我们所做的唯一一件事是首先输出<form>标签——包括它的所有属性，如method、action等。第二件事是我们确实输出了表单中的所有元素（在这个例子中是没有的），最后我们输出表单结束标签</form>，这现在结束了表单声明。

如果我们打开浏览器查看我们的代码，我们将看到与之前没有太大的不同，可能是一个空页面。然而，当我们打开该页面的源代码（在 Firefox 中，这是在页面上右键单击并点击查看页面源代码）时，我们看到我们实际上已经正确地实例化了表单，在 HTML 中。

我们的基本表单实例化现在已经完成，如果我们想要一个更高级但同时也更吸引人的定义表单的方式，我们应该继续阅读下一部分。

设置带注释的表单

定义带注释的表单与普通表单略有不同，主要区别在于带注释的表单只是一个具有属性的类，它没有从任何其他类扩展，而另一种方法要求我们扩展Zend\Form类。在先前的例子中，我们首先使用注释方法创建了一个非常简单且为空的表单。我们还可以看到，我们需要一个 Hydrator 来让注释引擎理解我们在说什么，但我们不需要扩展类，所以我们可以在那里自由地做我们想做的事情。

我们唯一需要小心的是，我们表单中需要的每个元素，都应该将属性访问设置为 public，否则从技术上讲，注解引擎无法识别它。我们不需要为属性创建 getter/setter（除非我们想为自己使用它），因为注解引擎直接使用公共属性。

在控制器中使用表单与正常表单略有不同，因为如果我们只是实例化类并使用它作为表单，最终会出错。类需要首先通过AnnotationBuilder来实际构建表单。这就是为什么我们需要执行createForm()，然后输出一个表单。

这将不会输出任何可见的内容，但如果我们查看页面源代码（在 Firefox 中，这是通过右键单击页面然后点击查看页面源代码来实现的），我们会看到我们有一个新的表单开启标签<form>和一个表单结束标签</form>。在这些标签之间，你可以看到我们的表单，名为annotationform，现在被设置为表单的name和id。

一些开发者认为这种定义表单的方式有点过度，因为最终可能看起来我们没有增加很多可用性，这在所有公平的讨论中确实有点道理。这完全取决于具体情况，某种方法是否比其他方法更好，但公平地说，这是一种相当流畅的定义表单的方式！

向表单添加元素

如果我们以与之前相同的方式设置了表单，那么我们有两种定义元素到表单的方法。第一种将是定义表单的正常方法，它是对Zend\Form\Form的扩展，就像在如何做...部分中的表单示例一样，以及它的注解表单，就像在如何做...部分中的AnnotationForm第二个示例。

第一个示例假设我们在扩展自Zend\Form\Form的表单中定义了__construct()。它所做的就是调用Zend\Form\Form的add()方法，我们向该方法提供一个方法数组（是的，你同样可以在配置文件中创建整个表单！）。

添加一个元素就像那样简单。显然，还有更多的元素可供选择，它们都有自己的选项和属性，但我们不会深入讨论所有这些，因为讨论起来会非常冗长。

向注解表单添加元素既简单又复杂。说它简单是因为在最基本的概念中，它只需要你向类中添加一个属性，这已经足够简单了。但如果你想做得更多，添加验证或过滤器，你需要在属性上方添加注解注释。

正如我们在前面的例子中所看到的，通过注解定义元素的方式并不特别困难，只是我们需要知道使用哪个@Annotation。当设置属性/选项或有时其他注解时，我们会看到两个花括号{}，这代表 JavaScript 中的一个对象，并用于 JSON。

显然，这并不困难，但需要我们稍微改变一下思维方式。

表单、过滤和验证

一个从Zend\Form\Form扩展的普通表单通过查看表单的$this->elements来创建元素，其中所有表单元素都将被存储。一旦触发表单渲染器，所有这些元素都将装饰成真实的 HTML 标签。在注解表单中，将类转换为 HTML 的过程需要额外一步，简单来说就是将注解类转换成一个类似于Zend\Form\Form扩展类的框架。这样我们就可以像使用真实表单对象一样使用从注解类构建的表单。

当我们提交表单时（你不必一定指定一个 POST，因为它默认已经是POST了），我们让表单检查值是否正确，更重要的是，我们想要确保我们得到的是我们预期的值。

不仅从安全角度验证表单很重要，从过滤角度也很重要。如果我们对我们的元素应用多个过滤器（例如，字符串修剪和去除标签），我们希望它们都为我们准备好了，而不是在之后再次使用这些过滤器。显然，更大的问题是保护我们的应用程序免受恶意用户的侵害，并验证用户的输入。

正如我们在最后一个前面的代码示例中所看到的，我们首先创建表单，然后检查用户是否尝试提交表单。如果是这样，我们将设置我们为该表单创建的特定表单验证器。然后，我们将请求数据（这是用户填写我们的表单的内容）分配给表单。在将数据分配给表单后，我们调用isValid()来查看数据是否有效。如果是，我们使用getData()将过滤后的数据分配给我们的示例模型以保存它。

最后，我们将表单再次分配给视图，这样我们就可以显示在验证过程中发生的任何验证错误。很简单！

还有更多...

我们也可以仅通过配置来定义一个表单形式，这被称为通过工厂创建表单形式，我们鼓励您看看它是如何工作的，因为这同样是一种创建表单的极好方式。

为了增加表单的安全性，人们可能会考虑向我们的表单中添加一个 Zend\Form\Element\Csrf 元素，该元素检查表单的来源以确保没有执行跨站请求伪造（CSRF）。这是一个添加到表单中的唯一密钥，用于验证过程。我们甚至会进一步说，建议创建一个已经添加了 CSRF 元素的基础表单，这样我们就不必担心是否忘记了，只要我们扩展自基础表单即可。

使用表单视图助手

与 Zend Framework 1 的装饰器（在表单的创建和渲染中是一个关键）不同，我们现在知道在 Zend Framework 2 中，使用不同的视图助手和渲染器来渲染表单会更好。