Zend Framework 快速开始

Zendframework 快速开始

目录

1、  Zend Framework & MVC 介绍

2、  创建你的项目

3、  创建布局（Layout）

4、  创建模型和数据表

5、  创建表单

6、  恭喜

 

Zend Framework & MVC 介绍

 

Zend Framework

Zend Framework 是一个为PHP5开发的开源、面向对象的web应用程序框架。Zend Framework 经常被称为“组件库”，因为它有许多松散链接的、几乎独立使用的组件。但是Zend Framework 也提供高级的“模型-试图-控制器（MVC）”组件（implementation），它能够为你的应用程序建立一个基本结构。带有简短描述的Zend Framework完整组件列表可以在» components overview中找到。这个快速教程将向你介绍一些Zend Framework的最常用的组件，包括Zend_Controller,Zend_Layout, Zend_Config, Zend_Db, Zend_Db_Table, Zend_Registry,，还包括一些制图助手。

       使用这些组件，我们将在几分钟内建立一个简单的数据库驱动的留言板（guestbook）应用程序。程序的完整源代码可以从下面的压缩文件中得到：

·         » zip

·         » tar.gz

 

Model-View-Controller

 

这就是每个人谈论的MVC模式。为什么应该关心？MVC不仅仅是听起来时髦，随时可以读出的由三个首字母组成的缩略语，它几乎已经成为web应用程序的设计标准。有充分的理由相信，大多数的web应用程序代码属于下面三个类别中的一个：展示、业务逻辑和数据存取。MVC模式模型分开关注这三个方面（The MVC pattern models this separation of concerns well）。最终，展示代码将成为带有业务逻辑和数据存储代码的应用程序的一部分。许多开发者已经发现这种为了组织代码而定义明确的分离，特别是当不止一个开发者工作于同一个应用程序时。

注：更多信息

我们来打破这种模式，来看看各个单件：

 

 

• 模型（Model）-这是你的应用程序的一部分，其在一系列抽象概念后定义了基本功能。数据访问例程和一些业务逻辑将在这个模型中定义。
• 视图（View）-视图精确定义什么将展现给用户，通常控制器传递数据给每个视图按某种格式渲染。视图也经常从用户收集代码。这里是在你的MVC应用程序中很可能发现HTML标记的地方
• 控制器（Controller）-控制器将整个模式绑定在一起。他们基于用户的请求和其他因素操纵模型，决定哪个视图去显示，传递每个视图都需要的数据，或者完全的将控制权交给另一个控制器。多数 MVC专家建议：»尽可能小的保持控制器（keeping controllers as skinny as possible）.

当然关于这个关键性的模式有»有更多的话要说，但是应该给你足够的背景去明白这个我们要建立的留言板（guestbook）应用程序

 

创建你的项目

 

为了创建你的项目，你必须首先下载和提取ZendFramework。

 

安装ZendFramework

 

得到带有完整PHP堆栈的ZendFramework的最容易的方法是安装Zend Server。Zend Server已经有为Mac OSX、Windows、Fedora Core 和Ubuntu的本地安装版本，也有一个兼容大多数Linux发布版本的通用安装包。

在安装ZendServer之后，在Mac OSX和Linux中，框架文件存储在/usr/local/zend/share/ZendFramework，在windows上，存储在C:/Program Files/Zend/ZendServer/share/ZendFramework。Include_path已经被配置包含Zend Framework。

另外，你也可以下载最新版本的Zend Framework并提取内容（» Download the latest version of Zend Framework），记下来你在哪里做的（make a note of where you have done so）。

可选的，你可以将档案（archive）的library/子目录路径加入到到你的php.ini中include_path设置中。（Optionally, you can add the path to the library/ subdirectory of the archive to your php.ini's include_pathsetting.）

就这么简单！Zend Framework已经被安装并可以使用了

 

创建你的项目

 

注: zf 命令行工具

Make a note of the absolute path to this script. 
Wherever you see references to the command zf, please substitute the absolute path to the script. On Unix-like systems, you may want to use your shell's alias functionality: aliaszf.sh=path/to/ZendFramework/bin/zf.sh. 
If you have problems setting up the zf command-line tool, please refer to the manual.

在你的Zend Framework安装目录中有个bin/子目录，里面含有分别为Unix用户和Window用户准备的zf.sh和zf.bat脚本。记下这个脚本的绝对路径。

无论在哪里看到zf命令的参考（references），请替代为脚本的绝对路径。在类Unix系统中，你可能想使用shell的别名函数：alish

zf.sh=path/to/ZendFramework/bin/zf.sh.

如果你再安装zf命令行工具是有任何问题，请参考手册。

打开终端（windows：开始->运行，然后使用cmd命令）。到你准备开始新项目的目录。然后使用相应的脚本路径并且执行下面当中的一个：

1. % zf create project quickstart

运行这个命令将创建你的基本网站结构，包括你的初始控制器和视图。目录树看起来像下面这样：

1. quickstart
2. |-- application
3. |   |-- Bootstrap.php
4. |   |-- configs
5. |   |   `-- application.ini
6. |   |-- controllers
7. |   |   |-- ErrorController.php
8. |   |   `-- IndexController.php
9. |   |-- models
10. |   `-- views
11. |       |-- helpers
12. |       `-- scripts
13. |           |-- error
14. |           |   `-- error.phtml
15. |           `-- index
16. |               `-- index.phtml
17. |-- library
18. |-- public
19. |   |-- .htaccess
20. |   `-- index.php
21. `-- tests
22.     |-- application
23.     |   `-- bootstrap.php
24.     |-- library
25.     |   `-- bootstrap.php
26.     `-- phpunit.xml

这个时候，如果你还没有将Zend Framework加入到你的include_path，我们推荐或者拷贝或者链接它到你的library/目录，无论哪种情况，你将想或者递归的拷贝或者链接Zend Framework 安装目录的library/Zend/子目录到你的项目的library/目录。在类unix系统中，它将象下面这样：

1. # Symlink:
2. % cd library; ln -s path/to/ZendFramework/library/Zend .
3.  
4. # Copy:
5. % cd library; cp -r path/to/ZendFramework/library/Zend .

在windows系统中，在资源管理其中可以很容易的做这个事情。

既然项目已经创建了，开始要弄懂的主要的工作就是引导程序（bootstrap），配置（configuration），动作控制器（action controllers）和视图（views）。

引导程序（Bootstrap）

引导类定义哪些资源和组件要去初始化。默认情况下，Zend Framework 的前端控制器是被初始化的，并且使用application/controllers/ 作为寻找动作控制器的默认的目录（稍后更多）。这个类看起来像这样：

1. // application/Bootstrap.php
2.  
3. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
4. {
5. }

就想你看到的，要开始的内容没有多少

配置

Zend Framework自身是没有配置的，你经常需要配置你的应用程序。默认的配置位于application/configs/application.ini,它包含一些设置你的PHP环境的基本指令（比如，打开或关闭错误报告），指示你的引导类（bootstrap class）路径（以及它的类名），还有你的动作控制器路径，它看起来像下面这样：

1. ; application/configs/application.ini
2.  
3. [production]
4. phpSettings.display_startup_errors = 0
5. phpSettings.display_errors = 0
6. includePaths.library = APPLICATION_PATH "/../library"
7. bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
8. bootstrap.class = "Bootstrap"
9. appnamespace = "Application"
10. resources.frontController.controllerDirectory = APPLICATION_PATH"/controllers"
11. resources.frontController.params.displayExceptions = 0
12.  
13. [staging : production]
14.  
15. [testing : production]
16. phpSettings.display_startup_errors = 1
17. phpSettings.display_errors = 1
18.  
19. [development : production]
20. phpSettings.display_startup_errors = 1
21. phpSettings.display_errors = 1

这个文件的许多东西应该注意，首先，当使用INI类型的配置，你应该直接提到常量并且扩展它们；APPLICATION_PATH 实际上是一个常量。另外注意有许多定义的部分：production，staging，testing和development。后面三个继承“production”环境的设置。这是一个有用的组织配置方法去确信适当的配置在应用程序开发的每个阶段都是可用的。

动作控制器

应用程序的动作控制器包含应用程序工作流，并且做映射请求到适当模型和视图的工作。

    一个动作控制器应该有一个或多个以“Action”结尾的方法；这些方法可能后面通过web被请求。默认的，Zend Framework URLs按照“/controller/action” 模式，这里“controller”映射动作控制器名（减去“Controller”后缀），“action”映射一个动作方法（减去“Action”后缀 ）。

典型的，你总是需要一个IndexController，这是一个后备控制器（fallback controller），而且它也是站点的主页。还需要一个ErrorController，它为了指示诸如HTTP 404错误（没有发现控制器或者动作）和HTTP 500错误的发生（应用程序错误）。

默认的 IndexController 像下面这样:

1. // application/controllers/IndexController.php
2.  
3. class IndexController extends Zend_Controller_Action
4. {
5.  
6.     public function init()
7.     {
8.         /* Initialize action controller here */
9.     }
10.  
11.     public function indexAction()
12.     {
13.         // action body
14.     }
15. }

默认的 ErrorController像下面这样:

1. // application/controllers/ErrorController.php
2.  
3. class ErrorController extends Zend_Controller_Action
4. {
5.  
6.     public function errorAction()
7.     {
8.         $errors = $this->_getParam('error_handler');
9.  
10.         switch ($errors->type) {
11.             caseZend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ROUTE:
12.             caseZend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_CONTROLLER:
13.             caseZend_Controller_Plugin_ErrorHandler::EXCEPTION_NO_ACTION:
14.  
15.                 // 404 error -- controller or action not found
16.                 $this->getResponse()->setHttpResponseCode(404);
17.                 $this->view->message = 'Page not found';
18.                 break;
19.             default:
20.                 // application error
21.                 $this->getResponse()->setHttpResponseCode(500);
22.                 $this->view->message = 'Application error';
23.                 break;
24.         }
25.  
26.         $this->view->exception = $errors->exception;
27.         $this->view->request   = $errors->request;
28.     }
29. }

你会注意到：（1）IndexController没有包含真是代码；（2）ErrorController提到视图属性。这导致我们很好的进入到下一个主题

视图

Zend Framework中的视图是用普通的PHP代码写的。视图脚本放置在application/views/scripts/中，这里脚本被使用控制器名称进一步的分类。在我们的示例中，我们已经有了一个IndexController和一个ErrorController，因此在视图脚本目录有相应的index/ 和 error/ 子目录。在这些子目录中，随后你将发现和创建对应每个暴露的（exposed）控制器动作的视图脚本。在默认情况下，我们会有视图脚本index/index.phtml 和error/error.phtml.

视图脚本可以包含任何你想要的标记，并且使用<?php 开始标记和?>结束标记区插入PHP指令。

下面的代码是默认安装下index/index.phtml视图脚本：

1. <!-- application/views/scripts/index/index.phtml -->
2. <style>
3.  
4.     a:link,
5.     a:visited
6.     {
7.         color: #0398CA;
8.     }
9.  
10.     span#zf-name
11.     {
12.         color: #91BE3F;
13.     }
14.  
15.     div#welcome
16.     {
17.         color: #FFFFFF;
18.         background-image: url(http://framework.zend.com/images/bkg_header.jpg);
19.         width:  600px;
20.         height: 400px;
21.         border: 2px solid #444444;
22.         overflow: hidden;
23.         text-align: center;
24.     }
25.  
26.     div#more-information
27.     {
28.         background-image: url(http://framework.zend.com/images/bkg_body-bottom.gif);
29.         height: 100%;
30.     }
31.  
32. </style>
33. <div id="welcome">
34.     <h1>Welcome to the <span id="zf-name">Zend Framework!</span><h1 />
35.     <h3>This is your project's main page<h3 />
36.     <div id="more-information">
37.         <p>
38.             <img src="http://framework.zend.com/images/PoweredBy_ZF_4LightBG.png" />
39.         </p>
40.  
41.         <p>
42.             Helpful Links: <br />
43.             <a href="http://framework.zend.com/">Zend Framework Website</a> |
44.             <a href="http://framework.zend.com/manual/en/">Zend Framework
45.                 Manual</a>
46.         </p>
47.     </div>
48. </div>
49.  

Error/error.phtml视图脚本有点更加有趣，因为它使用一些PHP的条件语句。

1. <!-- application/views/scripts/error/error.phtml -->
2. <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN";
3.     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd>
4. <html xmlns="http://www.w3.org/1999/xhtml">
5. <head>
6.   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
7.   <title>Zend Framework Default Application</title>
8. </head>
9. <body>
10.   <h1>An error occurred</h1>
11.   <h2><?php echo $this->message ?></h2>
12.  
13.   <?php if ('development' == $this->env): ?>
14.  
15.   <h3>Exception information:</h3>
16.   <p>
17.       <b>Message:</b> <?php echo $this->exception->getMessage() ?>
18.   </p>
19.  
20.   <h3>Stack trace:</h3>
21.   <pre><?php echo $this->exception->getTraceAsString() ?>
22.   </pre>
23.  
24.   <h3>Request Parameters:</h3>
25.   <pre><?php echo var_export($this->request->getParams(), 1) ?>
26.   </pre>
27.   <?php endif ?>
28.  
29. </body>
30. </html>

创建一个虚拟主机

为了这个快速开始的目的，我们将假设你在使用Apache web服务器。Zend Framework完美的工作在其他的web服务器——包括Microsoft IIS，lighttppd，ngix等等——但是多数的开发者最低程度的应该熟悉Apache。并且它提供一个容易的Zend Framework 的目录结构和重写能力的简单介绍。

为了创建你的vhost，你应该知道httpd.conf文件的位置，还有一些需要知道的其他的配置文件的位置（and potentially where other configuration files are located）。一些常见的地点：

• /etc/httpd/httpd.conf (Fedora, RHEL, and others)
• /etc/apache2/httpd.conf (Debian, Ubuntu, and others)
• /usr/local/zend/etc/httpd.conf (Zend Server on *nix machines)
• C:/Program Files/Zend/Apache2/conf (Zend Server on Windows machines)

在你的httpd.conf中（或者在一些系统的 httpd-vhosts.conf中），你需要去做两件事情。首先，确信NameVirtualHost被定义，典型的，你将把它设为“*:80”。其次，定义一个虚拟主机：

1. <VirtualHost *:80>
2.     ServerName quickstart.local
3.     DocumentRoot /path/to/quickstart/public
4.  
5.     SetEnv APPLICATION_ENV "development"
6.  
7.     <Directory /path/to/quickstart/public>
8.         DirectoryIndex index.php
9.         AllowOverride All
10.         Order allow,deny
11.         Allow from all
12.     </Directory>
13. </VirtualHost>

有几件事情要注意。首先，注意我们的项目中的DocumentRoot 设置要明确指定public子目录；这意味着只有在那个目录中的文件在任何时候能够被服务器直接服务。其次，注意“AllowOverride”的Order和Allow指令；我们在项目中可以使用htacess文件，在开发过程中，这是一个好的办法，因为它可以防止当你改变你的站点指令的时候不断重新启动web服务器。实际上，在产品中，你应该可能将你的htaccess文件的内容放到你的服务器设置中并且禁用htaccess。第三，注意SetEnv命令，它要做的是为你的虚拟主机设置环境变量，这个变量将在index.php中为我们的Zend Framework应用程序设置APPLICATION_ENV常量。在产品中，你能够省略这个指令（在这种情况下，将使用默认值“产品”）或者明确的设定它为“产品”。

最后，你需要在你的hosts文件中增加一个条目，对应于在ServerName指令中设定的值，在类Unix系统中，这个文件通常位于/etc/hosts;在windows中，你通常会在c:/windows/system32/drivers/etc中找到它。无论什么系统，这个条目看起来会是这样：

1. 127.0.0.1 quickstart.local

开始你的webserver（或者重新启动它），你就可以准备开始了。

检查

到目前为止，你应该能够启动你的初步Zend Framework应用。在浏览器中键入在前面的章节中配置的服务器名，你应该可以看到一个欢迎页面

 

创建布局

你可能已经注意到在前面章节中的视图脚本是HTML片段而非完整的页面代码。这是被设计成这样的。我们想让返回内容的动作只与动作本身相关，而不是与作为一个整体的应用程序相关。

现在我们必须组合产生的内容到完整的HTML页面。我们还希望应用程序有一个一致的外观和感觉。我们将使用一个全局的站点布局去完成这两个任务。

Zend Framework有两种设计模式去实施布局：» 两步视图法 和 » 组合视图法.两步视图法经常与»变换视图 模式联合使用。基本思想是你的应用程序视图创建内容（representation），然后把它注入到主视图以便最后的转换。组合视图模式处理一个或多个原子视图、应用程序视图。

在Zend Framework中，Zend Layout 结合这些模式的思想。不是每个动作视图脚本需要包括全站内容（artifacts），替代的是他们只要关注他们自己的责任。

偶然的，你可能在你的全站视图脚本中需要特定应用信息。幸运的是，Zend Framework提供了许多视图占位符以便在你的动作视图脚本中提供那些信息

要开始使用Zend_Layout，首先我们需要通知引导程序（bootstrap）去使用布局资源。这个可以使用“zf enable layout”命令：

1. % zf enable layout
2. Layouts have been enabled, and a default layout created at
3. application/layouts/scripts/layout.phtml
4. A layout entry has been added to the application config file.

正如命令所指出的那样，application/configs/application.ini 被更新了,现在在“production”节中包含如下内容

1. ; application/configs/application.ini
2.  
3. ; Add to [production] section:
4. resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"

最终的INI文件看起来像下面这样：

1. ; application/configs/application.ini
2.  
3. [production]
4. ; PHP settings we want to initialize
5. phpSettings.display_startup_errors = 0
6. phpSettings.display_errors = 0
7. includePaths.library = APPLICATION_PATH "/../library"
8. bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
9. bootstrap.class = "Bootstrap"
10. appnamespace = "Application"
11. resources.frontController.controllerDirectory = APPLICATION_PATH"/controllers"
12. resources.frontController.params.displayExceptions = 0
13. resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"
14.  
15. [staging : production]
16.  
17. [testing : production]
18. phpSettings.display_startup_errors = 1
19. phpSettings.display_errors = 1
20.  
21. [development : production]
22. phpSettings.display_startup_errors = 1
23. phpSettings.display_errors = 1

这个指令告诉你的应用程序在application/layouts/scripts去寻找布局视图脚本。如果你检查你的目录树，你会看到这个目录已经为你创建了layout.phtml文件。

我们也想确信我们的应用程序有一个XHTML文档类型（doctype）声明。为了确信这点，我们需要增加一个资源到我们的引导程序（bootstrap）中。

在引导程序（bootstrap）中增加资源的最简单方法是仅仅创建一个以_init短语开始的protected方法。在这种情况下，我们想去初始化文档类型（doctype），所以我们再初始（bootstrap）类中将创建一个_initDoctype()方法：

1. // application/Bootstrap.php
2.  
3. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
4. {
5.     protected function _initDoctype()
6.     {
7.     }
8. }

在这个方法里，我们需要提示视图使用恰当的文档类型（doctype）。但是视图对象从哪里来呢？简单的解决办法是去初始化视图资源。一旦我们有了，我们能够从引导程序（bootstrap）中取出（pull）视图对象并使用它。 为了初始化视图资源，在你的application/configs/application.ini 文件中“production”部分增加下面的行:

1. ; application/configs/application.ini
2.  
3. ; Add to [production] section:
4. resources.view[] =

这个告诉我们去初始化没有选项的视图（‘[]’说明视图键是一个数组，并且我们没有传递任何数据给它）。

既然我们有一个视图，让我们充实我们的_initDoctype()方法。在这个方法里面，我们将首先确信视图资源已经运行，提取视图对象，然后配置它

1. // application/Bootstrap.php
2.  
3. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
4. {
5.     protected function _initDoctype()
6.     {
7.         $this->bootstrap('view');
8.         $view = $this->getResource('view');
9.         $view->doctype('XHTML1_STRICT');
10.     }
11. }

现在我们已经初始化Zend_Layout并且已经设置了文档类型（Doctype）,让我们来创建我们全站的布局

1. <!-- application/layouts/scripts/layout.phtml -->
2. <?php echo $this->doctype() ?>
3. <html xmlns="http://www.w3.org/1999/xhtml">
4. <head>
5.   <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
6.   <title>Zend Framework Quickstart Application</title>
7.   <?php echo $this->headLink()->appendStylesheet('/css/global.css') ?>
8. </head>
9. <body>
10. <div id="header" style="background-color: #EEEEEE; height: 30px;">
11.     <div id="header-logo" style="float: left">
12.         <b>ZF Quickstart Application</b>
13.     </div>
14.     <div id="header-navigation" style="float: right">
15.         <a href="<?php echo $this->url(
16.             array('controller'=>'guestbook'),
17.             'default',
18.             true) ?>">Guestbook</a>
19.     </div>
20. </div>
21.  
22. <?php echo $this->layout()->content ?>
23.  
24. </body>
25. </html>

我们使用layout()视图助手获得我们的应用程序内容，并访问“content”键。如果你想，你可以渲染其他的响应片段，但是大多是情况下，必须做的就是这么多。

还要注意使用headLink()占位符。这是产生HTML<link>元素的简单方法，以及在你整个应用程序中跟踪它们。如果你需要增加另外的css表以支持一个动作，你可以这么做，并确保它将出现在最后被渲染的页面

注：检查点

现在到http://localhost，并检查源代码。你应该可以看到你XHTML的header、head、title和body部分。

创建模型和数据表

在我们开始之前，让我们来思考几点：这些类将放在什么地方，我们如何找到它们？我们创建的默认的项目实例化一个自动加载（autoloader）。我们可以给它附加其他的自动加载（autoloader），所以它知道在哪里可以找到不同的类。典型的，我们想让我们各种各样的MVC类归入同一个目录树——在这个例子中是application/ ——并且大多数经常使用共同的前缀（common prefix）。

Zend_Controller_Front 有一个“模块（modules）”概念，它是一个单独的小应用程序。模块模拟在application/目录下用zf工具建立的目录结构，且里面所有的类假定有相同的前缀——模块名。“Application/”本身就是一个模块——“default”或者“application”模块。因此，我们将去设置在此目录下资源的自动导入。

Zend_Application_Module_Autoloader提供将模块下各种资源映射到相应目录的功能，并且也提供一个标准的命名机制。在引导对象（bootstrap object）初始化时，这个类的实例被默认创建。你的应用程序引导程序（bootstrap）将默认的使用“Application”作为模块前缀。这样，我们的模型、表单和数据表类将以“Applicatin_”为前缀。

Now, let's consider what makes up a guestbook. Typically, they are simply a list of entries with a comment, timestamp, and, often, email address. Assuming we store them in a database, we may also want a unique identifier for each entry. We'll likely want to be able to save an entry, fetch individual entries, and retrieve all entries. As such, a simple guestbook model API might look something like this:

现在，我们来看看是什么组成了留言簿，典型的，他们简单的由评论（comment），戳（timestamp），经常还包括邮件地址的条目列表。假若将他们存储在数据库中，还要为每一个条目建立一个唯一的标识符。我们想要保存条目、查询单个条目，检索所有条目。因此，一个简单的留言薄模型API可能看起来像这样：

1. // application/models/Guestbook.php
2.  
3. class Application_Model_Guestbook
4. {
5.     protected $_comment;
6.     protected $_created;
7.     protected $_email;
8.     protected $_id;
9.  
10.     public function __set($name, $value);
11.     public function __get($name);
12.  
13.     public function setComment($text);
14.     public function getComment();
15.  
16.     public function setEmail($email);
17.     public function getEmail();
18.  
19.     public function setCreated($ts);
20.     public function getCreated();
21.  
22.     public function setId($id);
23.     public function getId();
24. }
25.  
26. class Application_Model_GuestbookMapper
27. {
28.     public function save(Application_Model_Guestbook $guestbook);
29.     public function find($id);
30.     public function fetchAll();
31. }

__get()和__set()将提供一个提供了一个便捷的机制去访问单个条目属性，代理其他的getter和setter方法（proxy to the other getters and setters），他们也帮助确保对象中只有白名单属性才是可用的

Find()和fetchAll()提供获取单个条目和能力，而save()负责将条目存储到数据库。

从现在开始，我们能够开始建立我们的数据库

首先我们需要初始化我们的数据源。就像布局和视图资源那样，可以为数据源提供配置。我们可以使用“zf configure db-adapter”命令：

1. % zf configure db-adapter /
2. > 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH "/../data/db/guestbook.db"' /
3. > production
4. A db configuration for the production has been written to the application config file.
5.  
6. % zf configure db-adapter /
7. > 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH "/../data/db/guestbook-testing.db"' /
8. > testing
9. A db configuration for the production has been written to the application config file.
10.  
11. % zf configure db-adapter /
12. > 'adapter=PDO_SQLITE&dbname=APPLICATION_PATH "/../data/db/guestbook-dev.db"' /
13. > development
14. A db configuration for the production has been written to the application config file.

现在编辑你的application/configs/application.ini file文件，在相应的部分你将会看到下面的行被加进去。

1. ; application/configs/application.ini
2.  
3. [production]
4. ; ...
5. resources.db.adapter = "PDO_SQLITE"
6. resources.db.params.dbname = APPLICATION_PATH"/../data/db/guestbook.db"
7.  
8. [testing : production]
9. ; ...
10. resources.db.adapter = "PDO_SQLITE"
11. resources.db.params.dbname = APPLICATION_PATH"/../data/db/guestbook-testing.db"
12.  
13. [development : production]
14. ; ...
15. resources.db.adapter = "PDO_SQLITE"
16. resources.db.params.dbname = APPLICATION_PATH"/../data/db/guestbook-dev.db"

最后的配置文件看起来像这样：

1. ; application/configs/application.ini
2.  
3. [production]
4. phpSettings.display_startup_errors = 0
5. phpSettings.display_errors = 0
6. bootstrap.path = APPLICATION_PATH "/Bootstrap.php"
7. bootstrap.class = "Bootstrap"
8. appnamespace = "Application"
9. resources.frontController.controllerDirectory = APPLICATION_PATH"/controllers"
10. resources.frontController.params.displayExceptions = 0
11. resources.layout.layoutPath = APPLICATION_PATH "/layouts/scripts"
12. resources.view[] =
13. resources.db.adapter = "PDO_SQLITE"
14. resources.db.params.dbname = APPLICATION_PATH"/../data/db/guestbook.db"
15.  
16. [staging : production]
17.  
18. [testing : production]
19. phpSettings.display_startup_errors = 1
20. phpSettings.display_errors = 1
21. resources.db.adapter = "PDO_SQLITE"
22. resources.db.params.dbname = APPLICATION_PATH"/../data/db/guestbook-testing.db"
23.  
24. [development : production]
25. phpSettings.display_startup_errors = 1
26. phpSettings.display_errors = 1
27. resources.db.adapter = "PDO_SQLITE"
28. resources.db.params.dbname = APPLICATION_PATH"/../data/db/guestbook-dev.db"

注意数据库将被存储在“data/db/”目录下。创建这些目录并且使它们是可写的。在类unix系统中，你可以像下面这么做：

1. % mkdir -p data/db; chmod -R a+rwX data

在wendows系统中，你需要在资源管理器中创建目录并设置对任何人的写权限。

这里我们有一个到数据库的连接，它连接到位于application/data/目录下的sqlite数据库。我们来设计一个简单的数据表用于存储我们的留言板条目。

1. -- scripts/schema.sqlite.sql
2. --
3. -- You will need load your database schema with this SQL.
4.  
5. CREATE TABLE guestbook (
6.     id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
7.     email VARCHAR(32) NOT NULL DEFAULT '[e-mail]',
8.     comment TEXT NULL,
9.     created DATETIME NOT NULL
10. );
11.  
12. CREATE INDEX "id" ON "guestbook" ("id");

为使我们的工作有创意的（so that we can have some working data out of the box），我们来创建一些数据行使我们的应用程序更加有趣

1. -- scripts/data.sqlite.sql
2. --
3. -- You can begin populating the database with the following SQL statements.
4.  
5. INSERT INTO guestbook (email, comment, created) VALUES
6.     ('[e-mail]',
7.     'Hello! Hope you enjoy this sample zf application!',
8.     DATETIME('NOW'));
9. INSERT INTO guestbook (email, comment, created) VALUES
10.     ('[e-mail]',
11.     'Baz baz baz, baz baz Baz baz baz - baz baz baz.',
12.     DATETIME('NOW'));

现在我们已经定义了数据表和数据。让我们一起来得到一个脚本，去建立这个数据库。当然，这个在产品中是不需要的，但是这个脚本将帮助开发者建立局部的数据库需求，以便有一个完整的应用程序。创建带有以下内容的“scripts/load.sqlite.php”脚本

1. // scripts/load.sqlite.php
2.  
3. /**
4. * Script for creating and loading database
5. */
6.  
7. // Initialize the application path and autoloading
8. defined('APPLICATION_PATH')
9.     || define('APPLICATION_PATH', realpath(dirname(__FILE__) .'/../application'));
10. set_include_path(implode(PATH_SEPARATOR, array(
11.     APPLICATION_PATH . '/../library',
12.     get_include_path(),
13. )));
14. require_once 'Zend/Loader/Autoloader.php';
15. Zend_Loader_Autoloader::getInstance();
16.  
17. // Define some CLI options
18. $getopt = new Zend_Console_Getopt(array(
19.     'withdata|w' => 'Load database with sample data',
20.     'env|e-s'    => 'Application environment for which to create database (defaults to development)',
21.     'help|h'     => 'Help -- usage message',
22. ));
23. try {
24.     $getopt->parse();
25. } catch (Zend_Console_Getopt_Exception $e) {
26.     // Bad options passed: report usage
27.     echo $e->getUsageMessage();
28.     return false;
29. }
30.  
31. // If help requested, report usage message
32. if ($getopt->getOption('h')) {
33.     echo $getopt->getUsageMessage();
34.     return true;
35. }
36.  
37. // Initialize values based on presence or absence of CLI options
38. $withData = $getopt->getOption('w');
39. $env      = $getopt->getOption('e');
40. defined('APPLICATION_ENV')
41.     || define('APPLICATION_ENV', (null === $env) ? 'development': $env);
42.  
43. // Initialize Zend_Application
44. $application = new Zend_Application(
45.     APPLICATION_ENV,
46.     APPLICATION_PATH . '/configs/application.ini'
47. );
48.  
49. // Initialize and retrieve DB resource
50. $bootstrap = $application->getBootstrap();
51. $bootstrap->bootstrap('db');
52. $dbAdapter = $bootstrap->getResource('db');
53.  
54. // let the user know whats going on (we are actually creating a
55. // database here)
56. if ('testing' != APPLICATION_ENV) {
57.     echo 'Writing Database Guestbook in (control-c to cancel): '. PHP_EOL;
58.     for ($x = 5; $x > 0; $x--) {
59.         echo $x . "/r"; sleep(1);
60.     }
61. }
62.  
63. // Check to see if we have a database file already
64. $options = $bootstrap->getOption('resources');
65. $dbFile  = $options['db']['params']['dbname'];
66. if (file_exists($dbFile)) {
67.     unlink($dbFile);
68. }
69.  
70. // this block executes the actual statements that were loaded from
71. // the schema file.
72. try {
73.     $schemaSql = file_get_contents(dirname(__FILE__) .'/schema.sqlite.sql');
74.     // use the connection directly to load sql in batches
75.     $dbAdapter->getConnection()->exec($schemaSql);
76.     chmod($dbFile, 0666);
77.  
78.     if ('testing' != APPLICATION_ENV) {
79.         echo PHP_EOL;
80.         echo 'Database Created';
81.         echo PHP_EOL;
82.     }
83.  
84.     if ($withData) {
85.         $dataSql = file_get_contents(dirname(__FILE__) .'/data.sqlite.sql');
86.         // use the connection directly to load sql in batches
87.         $dbAdapter->getConnection()->exec($dataSql);
88.         if ('testing' != APPLICATION_ENV) {
89.             echo 'Data Loaded.';
90.             echo PHP_EOL;
91.         }
92.     }
93.  
94. } catch (Exception $e) {
95.     echo 'AN ERROR HAS OCCURED:' . PHP_EOL;
96.     echo $e->getMessage() . PHP_EOL;
97.     return false;
98. }
99.  
100. // generally speaking, this script will be run from the command line
101. return true;

现在，我们来执行这个脚本，从一个终端或者DOS命令行做如下工作：

1. % php scripts/load.sqlite.php --withdata

你应该会看到像下面一样的输出：

1. path/to/ZendFrameworkQuickstart/scripts$ php load.sqlite.php --withdata
2. Writing Database Guestbook in (control-c to cancel):
3. 1
4. Database Created
5. Data Loaded.

现在，我们的留言板有了一个完整的工作数据库和表。我们下面几步准备去建立我们的应用程序代码。这包括建立一个数据源（我们的例子里，我们将使用Zend_Db_Table）和一个数据映射（data mapper）去连接数据源和数据模型（model）。最后，我们将建立与这个模型相互作用控制器去显示已经存在的和要发布的条目。

我们将使用» 表数据网关（Table Data Gateway）去连接我们的数据源；Zend_Db_Table提供这个功能。为了开始，我们创建一个基于Zend_Db_Table的表类，就像我们已经为布局和数据适配器做的那样，我们能够使用zf工具的“create db-table”命令，它需要至少两个参数，一个是你想要引用类的名称，另一个是要映射的数据表

1. % zf create db-table Guestbook guestbook
2. Creating a DbTable at application/models/DbTable/Guestbook.php
3. Updating project profile 'zfproject.xml'

看一下你的目录树，你会看到一个新的目录：application/models/DbTable/被创建，里面还有一个名为Guestbook.php的文件，若你打开这个文件，你会看到下面的内容：

1. // application/models/DbTable/Guestbook.php
2.  
3. /**
4. * This is the DbTable class for the guestbook table.
5. */
6. class Application_Model_DbTable_Guestbook extendsZend_Db_Table_Abstract
7. {
8.     /** Table name */
9.     protected $_name    = 'guestbook';
10. }

注意这个类的前缀：Application_Model_DbTable。我们模块名的类前缀“Application”是第一个部分，第二部分是“Model_DbTable”。后者是映射模块的目录“models/DbTable”。

扩展的Zend_Db_Table提供一个表名和可选的主键（如果它不是“id”），这都是有必要的。

现在我们来创建» 数据映射（Data Mapper）。Data Mapper映射域对象到数据库。在我们这个例子中，它将映射我们的模型（model）Application_Model_Guestbook到数据源Application_Model_DbTable_Guestbook. Data mapper典型的API像下面这样：

 

1. // application/models/GuestbookMapper.php
2.  
3. class Application_Model_GuestbookMapper
4. {
5.     public function save($model);
6.     public function find($id, $model);
7.     public function fetchAll();
8. }

除了这些方法之外，我们将增加设置和检索表数据网关（Table Data Gateway）的方法。使用“zf CLI”工具来创建初始的类：

1. % zf create model GuestbookMapper
2. Creating a model at application/models/GuestbookMapper.php
3. Updating project profile '.zfproject.xml'

现在，像下面这样编辑application/models/GuestbookMapper.php 中的Application_Model_GuestbookMapper类：

1. // application/models/GuestbookMapper.php
2.  
3. class Application_Model_GuestbookMapper
4. {
5.     protected $_dbTable;
6.  
7.     public function setDbTable($dbTable)
8.     {
9.         if (is_string($dbTable)) {
10.             $dbTable = new $dbTable();
11.         }
12.         if (!$dbTable instanceof Zend_Db_Table_Abstract) {
13.             throw new Exception('Invalid table data gateway provided');
14.         }
15.         $this->_dbTable = $dbTable;
16.         return $this;
17.     }
18.  
19.     public function getDbTable()
20.     {
21.         if (null === $this->_dbTable) {
22.             $this->setDbTable('Application_Model_DbTable_Guestbook');
23.         }
24.         return $this->_dbTable;
25.     }
26.  
27.     public function save(Application_Model_Guestbook $guestbook)
28.     {
29.         $data = array(
30.             'email'   => $guestbook->getEmail(),
31.             'comment' => $guestbook->getComment(),
32.             'created' => date('Y-m-d H:i:s'),
33.         );
34.  
35.         if (null === ($id = $guestbook->getId())) {
36.             unset($data['id']);
37.             $this->getDbTable()->insert($data);
38.         } else {
39.             $this->getDbTable()->update($data, array('id = ?' =>$id));
40.         }
41.     }
42.  
43.     public function find($id, Application_Model_Guestbook$guestbook)
44.     {
45.         $result = $this->getDbTable()->find($id);
46.         if (0 == count($result)) {
47.             return;
48.         }
49.         $row = $result->current();
50.         $guestbook->setId($row->id)
51.                   ->setEmail($row->email)
52.                   ->setComment($row->comment)
53.                   ->setCreated($row->created);
54.     }
55.  
56.     public function fetchAll()
57.     {
58.         $resultSet = $this->getDbTable()->fetchAll();
59.         $entries   = array();
60.         foreach ($resultSet as $row) {
61.             $entry = new Application_Model_Guestbook();
62.             $entry->setId($row->id)
63.                   ->setEmail($row->email)
64.                   ->setComment($row->comment)
65.                   ->setCreated($row->created);
66.             $entries[] = $entry;
67.         }
68.         return $entries;
69.     }
70. }

现在是时候创建我们模型类的时候了。我们将又一次使用“zf create model”命令来做这个事情：

1. % zf create model Guestbook
2. Creating a model at application/models/Guestbook.php
3. Updating project profile '.zfproject.xml'

我们将修改这个空的PHP类，通过传递一个数据数组到构造函数（constructor）或者setOptions()方法使它容易去填充模型：

1. // application/models/Guestbook.php
2.  
3. class Application_Model_Guestbook
4. {
5.     protected $_comment;
6.     protected $_created;
7.     protected $_email;
8.     protected $_id;
9.  
10.     public function __construct(array $options = null)
11.     {
12.         if (is_array($options)) {
13.             $this->setOptions($options);
14.         }
15.     }
16.  
17.     public function __set($name, $value)
18.     {
19.         $method = 'set' . $name;
20.         if (('mapper' == $name) || !method_exists($this,$method)) {
21.             throw new Exception('Invalid guestbook property');
22.         }
23.         $this->$method($value);
24.     }
25.  
26.     public function __get($name)
27.     {
28.         $method = 'get' . $name;
29.         if (('mapper' == $name) || !method_exists($this,$method)) {
30.             throw new Exception('Invalid guestbook property');
31.         }
32.         return $this->$method();
33.     }
34.  
35.     public function setOptions(array $options)
36.     {
37.         $methods = get_class_methods($this);
38.         foreach ($options as $key => $value) {
39.             $method = 'set' . ucfirst($key);
40.             if (in_array($method, $methods)) {
41.                 $this->$method($value);
42.             }
43.         }
44.         return $this;
45.     }
46.  
47.     public function setComment($text)
48.     {
49.         $this->_comment = (string) $text;
50.         return $this;
51.     }
52.  
53.     public function getComment()
54.     {
55.         return $this->_comment;
56.     }
57.  
58.     public function setEmail($email)
59.     {
60.         $this->_email = (string) $email;
61.         return $this;
62.     }
63.  
64.     public function getEmail()
65.     {
66.         return $this->_email;
67.     }
68.  
69.     public function setCreated($ts)
70.     {
71.         $this->_created = $ts;
72.         return $this;
73.     }
74.  
75.     public function getCreated()
76.     {
77.         return $this->_created;
78.     }
79.  
80.     public function setId($id)
81.     {
82.         $this->_id = (int) $id;
83.         return $this;
84.     }
85.  
86.     public function getId()
87.     {
88.         return $this->_id;
89.     }
90. }

最后，为了将所有这些部分连接在一起，我们来创建留言簿控制器（a guestbook controller），它将列出目前在数据库中已有的条目。

为了创建新的控制器，使用“zf create controller”命令：

1. % zf create controller Guestbook
2. Creating a controller at
3.     application/controllers/GuestbookController.php
4. Creating an index action method in controller Guestbook
5. Creating a view script for the index action method at
6.     application/views/scripts/guestbook/index.phtml
7. Creating a controller test file at
8.     tests/application/controllers/GuestbookControllerTest.php
9. Updating project profile '.zfproject.xml'

这将创建一个新的控制器，位于application/controllers/GuestbookController.php里的GuestbookController，它带有唯一的动作方法：indexAction。也会为这个控制器创建一个视图脚本目录，application/views/scripts/guestbook/,里面会有一个为index action创建的视图脚本

我们将使用“index”动作作为目标页面（landing page）去查看所有的留言簿条目

现在我们来使基本应用程序逻辑丰满起来，当进入indexAction()，我们将显示所有的留言簿条目，看起来像下面这样：

1. // application/controllers/GuestbookController.php
2.  
3. class GuestbookController extends Zend_Controller_Action
4. {
5.     public function indexAction()
6.     {
7.         $guestbook = new Application_Model_GuestbookMapper();
8.         $this->view->entries = $guestbook->fetchAll();
9.     }
10. }

当然，我们需要一个试图脚本和它一起运行。像下面这样编辑application/views/scripts/guestbook/index.phtml ：

1. <!-- application/views/scripts/guestbook/index.phtml -->
2.  
3. <p><a href="<?php echo $this->url(
4.     array(
5.         'controller' => 'guestbook',
6.         'action'     => 'sign'
7.     ),
8.     'default',
9.     true) ?>">Sign Our Guestbook</a></p>
10.  
11. Guestbook Entries: <br />
12. <dl>
13.     <?php foreach ($this->entries as $entry): ?>
14.     <dt><?php echo $this->escape($entry->email) ?></dt>
15.     <dd><?php echo $this->escape($entry->comment) ?></dd>
16.     <?php endforeach ?>
17. </dl>

Note: Checkpoint
Now browse to "http://localhost/guestbook". You should see the following in your browser:

注：检查点

现在浏览http://localhost/guestbook。你将看到下面的样子：

 

 

注: 使用数据导入脚本

在本节中介绍的数据导入脚本（scripts/load.sqlite.php）能够被用作创建你所定义的每个环境下的数据库，以及导入简单的样本数据。在内部，它使用Zend_Console_Getopt,它提供了许多命令行开关。如果你提供 “-h”或者“--help”开关，它将给你可用的选择：

1.  Usage: load.sqlite.php [ options ]

2.  --withdata|-w         Load database with sample data

3.  --env|-e [  ]         Application environment for which to create database

4.                        (defaults to development)

5.  --help|-h             Help -- usage message)]]

 “-e”开关允许你指定常量“APPLICATION_EVN”的值——它依次允许你去创建为每个环境定义的SQLLite数据库。确信当部署的时候为你的应用程序选择的环境运行脚本

创建表单

为了使留言簿有用，我们需要提交新条目的表单。

我们首先要做的是去创建实际的表单类。为创建空的表单类，执行：

1. % zf create form Guestbook
2. Creating a form at application/forms/Guestbook.php
3. Updating project profile '.zfproject.xml'

这将创建带有类文件Guestbook.php的application/forms/目录。打开Guestbook.php文件并更新它，你将会看到：

1. // application/forms/Guestbook.php
2.  
3. class Application_Form_Guestbook extends Zend_Form
4. {
5.     public function init()
6.     {
7.         // Set the method for the display form to POST
8.         $this->setMethod('post');
9.  
10.         // Add an email element
11.         $this->addElement('text', 'email', array(
12.             'label'      => 'Your email address:',
13.             'required'   => true,
14.             'filters'    => array('StringTrim'),
15.             'validators' => array(
16.                 'EmailAddress',
17.             )
18.         ));
19.  
20.         // Add the comment element
21.         $this->addElement('textarea', 'comment', array(
22.             'label'      => 'Please Comment:',
23.             'required'   => true,
24.             'validators' => array(
25.                 array('validator' => 'StringLength', 'options' =>array(0, 20))
26.                 )
27.         ));
28.  
29.         // Add a captcha
30.         $this->addElement('captcha', 'captcha', array(
31.             'label'      => 'Please enter the 5 letters displayed below:',
32.             'required'   => true,
33.             'captcha'    => array(
34.                 'captcha' => 'Figlet',
35.                 'wordLen' => 5,
36.                 'timeout' => 300
37.             )
38.         ));
39.  
40.         // Add the submit button
41.         $this->addElement('submit', 'submit', array(
42.             'ignore'   => true,
43.             'label'    => 'Sign Guestbook',
44.         ));
45.  
46.         // And finally add some CSRF protection
47.         $this->addElement('hash', 'csrf', array(
48.             'ignore' => true,
49.         ));
50.     }
51. }

上面的表单定义了五个元素：email address字段，评论字段，防止垃圾提交信息的CAPTCHA字段，提交按钮，和CSRF保护令牌（protection token）。

下一步，我们将增加signAction（）到我们的GuestbookController，它将处理提交后的表单。为了创建动作和相关视图脚本，执行下面内容：

1. % zf create action sign Guestbook
2. Creating an action named sign inside controller
3.     at application/controllers/GuestbookController.php
4. Updating project profile '.zfproject.xml'
5. Creating a view script for the sign action method
6.     at application/views/scripts/guestbook/sign.phtml
7. Updating project profile '.zfproject.xml'

就像你从输出中看到的，这将控制器中创建一个signAction（）方法，以及相关的视图脚本。

我们来加入一些逻辑到我们的留言簿控制器提交动作（sign action）。我们需要首先检查是否得到的是POST还是用GET请求；如果是后者，我们将简单的将表单显示出来。然而，如果我们得到一个POST请求，我们将要去验证表单提交的数据。如果通过认证，则创建一个新的条目并存储它。这个逻辑看起来会像下面这样：

1. // application/controllers/GuestbookController.php
2.  
3. class GuestbookController extends Zend_Controller_Action
4. {
5.     // snipping indexAction()...
6.  
7.     public function signAction()
8.     {
9.         $request = $this->getRequest();
10.         $form    = new Application_Form_Guestbook();
11.  
12.         if ($this->getRequest()->isPost()) {
13.             if ($form->isValid($request->getPost())) {
14.                 $comment = new Application_Model_Guestbook($form->getValues());
15.                 $mapper  = newApplication_Model_GuestbookMapper();
16.                 $mapper->save($comment);
17.                 return $this->_helper->redirector('index');
18.             }
19.         }
20.  
21.         $this->view->form = $form;
22.     }
23. }

当然，我们也需要编辑视图脚本，编辑application/views/scripts/guestbook/sign.phtml：

1. <!-- application/views/scripts/guestbook/sign.phtml -->
2.  
3. Please use the form below to sign our guestbook!
4.  
5. <?php
6. $this->form->setAction($this->url());
7. echo $this->form;

注: 使表单看起来更美观
任何时候，没有人会对于这个表单的美观说好，无论如何，表单的外观是完全可定制的，具体请看在参考指南的装饰一节。

注：检查点：
Now browse to "http://localhost/guestbook/sign". You should see the following in your browser:

现在，将浏览器定位到http://localhost/guestbook/sign，你将会看到下面的样子：

恭喜!

 

你现在已经使用最常用的Zend Framework组件建立一个非常简单的应用程序。Zend Framework给你提供许多可用的组件，它们在web应用中提供最常见的需求，除了包括web服务，搜索，PDF读写，认证，授权外还有许多组件。这个参考指南是一个去发现你已经使用的组件以及其他组件好地方。我们希望你发现Zend Framework是有用并接—更重要的—愉快的！