Introduction to Zend Framework

 Learning Zend Framework

appendix

 Zend Framework Reference


  •  Zend_Gdata
  •  Zend_Http
  •  Zend_InfoCard
  •  Zend_Json
  •  Zend_Layout
  •  Zend_Ldap
  •  Zend_Loader
  •  Zend_Locale
  •  Zend_Log
  •  Zend_Mail
  •  Zend_Markup
  •  Zend_Measure
  •  Zend_Memory
  •  Zend_Mime
  •  Zend_Navigation
  •  Zend_Oauth
  •  Zend_OpenId
  •  Zend_Paginator
  •  Zend_Pdf
  •  Zend_ProgressBar
  •  Zend_Queue
  •  Zend_Reflection
  •  Zend_Registry
  •  Zend_Rest

  •  Zend_Search_Lucene
  •  Zend_Serializer
  •  Zend_Server
  •  Zend_Service
  •  Zend_Session
  •  Zend_Soap
  •  Zend_Tag
  •  Zend_Test
  •  Zend_Text
  •  Zend_TimeSync
  •  Zend_Tool
  •  Zend_Tool_Framework
  •  Zend_Tool_Project
  •  Zend_Translate
  •  Zend_Uri
  •  Zend_Validate
  •  Zend_Version
  •  Zend_View
  •  Zend_Wildfire
  •  Zend_XmlRpc
  • ZendX_Console_Process_Unix
  • ZendX_JQuery
  • Update 2011-11-16 - Revision 24438 - Version ZF 1.11.x

    Chapter 24. Zend_Controller

    Table of Contents

    24.1. Zend_Controller Quick Start
    24.1.1. Introduction
    24.1.2. Quick Start
    24.1.2.1. Create the Filesystem Layout
    24.1.2.2. Set the Document Root
    24.1.2.3. Create the Rewrite Rules
    24.1.2.4. Create the Bootstrap File
    24.1.2.5. Create the Default Action Controller
    24.1.2.6. Create the View Script
    24.1.2.7. Create the Error Controller
    24.1.2.8. View the Site!
    24.2. Zend_Controller Basics
    24.3. The Front Controller
    24.3.1. Overview
    24.3.2. Primary Methods
    24.3.2.1. getInstance()
    24.3.2.2. setControllerDirectory() and addControllerDirectory
    24.3.2.3. addModuleDirectory() and getModuleDirectory()
    24.3.2.4. dispatch()
    24.3.2.5. run()
    24.3.3. Environmental Accessor Methods
    24.3.4. Front Controller Parameters
    24.3.5. Extending the Front Controller
    24.4. The Request Object
    24.4.1. Introduction
    24.4.2. HTTP Requests
    24.4.2.1. Accessing Request Data
    24.4.2.2. Base Url and Subdirectories
    24.4.2.3. Determining the Request Method
    24.4.2.4. Detecting AJAX Requests
    24.4.3. Subclassing the Request Object
    24.5. The Standard Router
    24.5.1. Introduction
    24.5.2. Using a Router
    24.5.3. Basic Rewrite Router Operation
    24.5.4. Default Routes
    24.5.5. Base URL and Subdirectories
    24.5.6. Global Parameters
    24.5.7. Route Types
    24.5.7.1. Zend_Controller_Router_Route
    24.5.7.1.1. Variable Defaults
    24.5.7.1.2. Variable Requirements
    24.5.7.1.3. Translated segments
    24.5.7.2. Zend_Controller_Router_Route_Static
    24.5.7.3. Zend_Controller_Router_Route_Regex
    24.5.7.4. Zend_Controller_Router_Route_Hostname
    24.5.7.5. Zend_Controller_Router_Route_Chain
    24.5.7.5.1. Chain Routes via Zend_Config
    24.5.7.6. Zend_Rest_Route
    24.5.7.6.1. Zend_Rest_Route Usage
    24.5.7.6.2. Zend_Rest_Route with Zend_Config_Ini
    24.5.7.6.3. Zend_Rest_Controller
    24.5.8. Using Zend_Config with the RewriteRouter
    24.5.9. Subclassing the Router
    24.6. The Dispatcher
    24.6.1. Overview
    24.6.2. Subclassing the Dispatcher
    24.7. Action Controllers
    24.7.1. Introduction
    24.7.2. Object Initialization
    24.7.3. Pre- and Post-Dispatch Hooks
    24.7.4. Accessors
    24.7.5. View Integration
    24.7.5.1. View Initialization
    24.7.5.2. Rendering Views
    24.7.6. Utility Methods
    24.7.7. Subclassing the Action Controller
    24.8. Action Helpers
    24.8.1. Introduction
    24.8.2. Helper Initialization
    24.8.3. The Helper Broker
    24.8.4. Built-in Action Helpers
    24.8.4.1. ActionStack
    24.8.4.2. AutoComplete
    24.8.4.2.1. AutoCompletion with Dojo
    24.8.4.2.2. AutoCompletion with Scriptaculous
    24.8.4.3. ContextSwitch and AjaxContext
    24.8.4.3.1. Default Contexts Available
    24.8.4.3.2. Creating Custom Contexts
    24.8.4.3.3. Setting Contexts Per Action
    24.8.4.3.4. Initializing Context Switching
    24.8.4.3.5. Additional Functionality
    24.8.4.3.6. AjaxContext Functionality
    24.8.4.4. FlashMessenger
    24.8.4.4.1. Introduction
    24.8.4.4.2. Basic Usage Example
    24.8.4.5. JSON
    24.8.4.6. Redirector
    24.8.4.6.1. Introduction
    24.8.4.6.2. Basic Usage Examples
    24.8.4.7. ViewRenderer
    24.8.4.7.1. Introduction
    24.8.4.7.2. API
    24.8.4.7.3. Basic Usage Examples
    24.8.4.7.4. Advanced Usage Examples
    24.8.5. Writing Your Own Helpers
    24.9. The Response Object
    24.9.1. Usage
    24.9.2. Manipulating Headers
    24.9.3. Named Segments
    24.9.4. Testing for Exceptions in the Response Object
    24.9.5. Subclassing the Response Object
    24.10. Plugins
    24.10.1. Introduction
    24.10.2. Writing Plugins
    24.10.3. Using Plugins
    24.10.4. Retrieving and Manipulating Plugins
    24.10.5. Plugins Included in the Standard Distribution
    24.10.5.1. ActionStack
    24.10.5.2. Zend_Controller_Plugin_ErrorHandler
    24.10.5.2.1. Using the ErrorHandler as a 404 Handler
    24.10.5.2.2. Handling Previously Rendered Output
    24.10.5.2.3. Plugin Usage Examples
    24.10.5.2.4. Error Controller Example
    24.10.5.3. Zend_Controller_Plugin_PutHandler
    24.11. Using a Conventional Modular Directory Structure
    24.11.1. Introduction
    24.11.2. Specifying Module Controller Directories
    24.11.3. Routing to Modules
    24.11.4. Module or Global Default Controller
    24.12. MVC Exceptions
    24.12.1. Introduction
    24.12.2. Handling Exceptions
    24.12.3. MVC Exceptions You May Encounter

    24.1. Zend_Controller Quick Start

    24.1.1. Introduction

    Zend_Controller is the heart of Zend Framework's MVC system. MVC stands for Model-View-Controller and is a design pattern targeted at separating application logic from display logic. Zend_Controller_Front implements a Front Controller pattern, in which all requests are intercepted by the front controller and dispatched to individual Action Controllers based on the URL requested.

    The Zend_Controller system was built with extensibility in mind, either by subclassing the existing classes, writing new classes that implement the various interfaces and abstract classes that form the foundation of the controller family of classes, or writing plugins or action helpers to augment or manipulate the functionality of the system.

    24.1.2. Quick Start

    If you need more in-depth information, see the following sections. If you just want to get up and running quickly, read on.

    24.1.2.1. Create the Filesystem Layout

    The first step is to create your file system layout. The typical layout is as follows:

    application/
        
    controllers/
            
    IndexController.php
        models
    /
        
    views/
            
    scripts/
                
    index/
                    
    index.phtml
            helpers
    /
            
    filters/
    html/
        .
    htaccess
        index
    .php

    24.1.2.2. Set the Document Root

    In your web server, point your document root to the html/ directory of the above file system layout.

    24.1.2.3. Create the Rewrite Rules

    Edit the html/.htaccess file above to read as follows:

    RewriteEngine On
    RewriteCond 
    %{REQUEST_FILENAME} -[OR]
    RewriteCond %{REQUEST_FILENAME} -[OR]
    RewriteCond %{REQUEST_FILENAME} -d
    RewriteRule 
    ^.*$ - [NC,L]
    RewriteRule ^.*$ index.php [NC,L]
    [Note] Learn about mod_rewrite

    The above rewrite rules allow access to any file under your virtual host's document root. If there are files you do not want exposed in this way, you may want to be more restrictive in your rules. Go to the Apache website to learn more about mod_rewrite.

    If using IIS 7.0, use the following as your rewrite configuration:

    <?xml version="1.0" encoding="UTF-8"?>
    <configuration>
         <system.webServer>
             <rewrite>
                 <rules>
                     <rule name="Imported Rule 1" stopProcessing="true">
                         <match url="^.*$" />
                         <conditions logicalGrouping="MatchAny">
                             <add input="{REQUEST_FILENAME}"
                                 matchType="IsFile" pattern=""
                                 ignoreCase="false" />
                             <add input="{REQUEST_FILENAME}"
                                 matchType="IsDirectory"
                                 pattern="" ignoreCase="false" />
                         </conditions>
                         <action type="None" />
                     </rule>
                     <rule name="Imported Rule 2" stopProcessing="true">
                         <match url="^.*$" />
                         <action type="Rewrite" url="index.php" />
                     </rule>
                 </rules>
             </rewrite>
         </system.webServer>
    </configuration>

    The above rules will route requests to existing resources (existing symlinks, non-empty files, or non-empty directories) accordingly, and all other requests to the front controller.

    [Note] Note

    The above rewrite rules are for Apache; for examples of rewrite rules for other web servers, see the router documentation.

    24.1.2.4. Create the Bootstrap File

    The bootstrap file is the page all requests are routed through -- html/index.php in this case. Open up html/index.php in the editor of your choice and add the following:

    Zend_Controller_Front::run('/path/to/app/controllers');

    This will instantiate and dispatch the front controller, which will route requests to action controllers.

    24.1.2.5. Create the Default Action Controller

    Before discussing action controllers, you should first understand how requests are routed in Zend Framework. By default, the first segment of a URL path maps to a controller, and the second to an action. For example, given the URL http://framework.zend.com/roadmap/components, the path is /roadmap/components, which will map to the controller roadmap and the action components. If no action is provided, the action index is assumed, and if no controller is provided, the controller index is assumed (following the Apache convention that maps a DirectoryIndex automatically).

    Zend_Controller's dispatcher then takes the controller value and maps it to a class. By default, it Title-cases the controller name and appends the word Controller. Thus, in our example above, the controller roadmap is mapped to the class RoadmapController.

    Similarly, the action value is mapped to a method of the controller class. By default, the value is lower-cased, and the word Action is appended. Thus, in our example above, the action components becomes componentsAction(), and the final method called is RoadmapController::componentsAction().

    So, moving on, let's now create a default action controller and action method. As noted earlier, the default controller and action called are both index. Open the file application/controllers/IndexController.php, and enter the following:

    /** Zend_Controller_Action */
    class IndexController extends Zend_Controller_Action
    {
        public function 
    indexAction()
        {
        }
    }

    By default, the ViewRenderer action helper is enabled. What this means is that by simply defining an action method and a corresponding view script, you will immediately get content rendered. By default, Zend_View is used as the View layer in the MVC. The ViewRenderer does some magic, and uses the controller name (e.g., index) and the current action name (e.g., index) to determine what template to pull. By default, templates end in the .phtml extension, so this means that, in the above example, the template index/index.phtml will be rendered. Additionally, the ViewRenderer automatically assumes that the directory views/ at the same level as the controller directory will be the base view directory, and that the actual view scripts will be in the views/scripts/ subdirectory. Thus, the template rendered will be found in application/views/scripts/index/index.phtml.

    24.1.2.6. Create the View Script

    As mentioned in the previous section, view scripts are found in application/views/scripts/; the view script for the default controller and action is in application/views/scripts/index/index.phtml. Create this file, and type in some HTML:

    <!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
    >
    <
    html>
    <
    head>
      <
    meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
      <
    title>My first Zend Framework App</title>
    </
    head>
    <
    body>
        <
    h1>HelloWorld!</h1>
    </
    body>
    </
    html>

    24.1.2.7. Create the Error Controller

    By default, the error handler plugin is registered. This plugin expects that a controller exists to handle errors. By default, it assumes an ErrorController in the default module with an errorAction() method:

    class ErrorController extends Zend_Controller_Action
    {
        public function 
    errorAction()
        {
        }
    }

    Assuming the already discussed directory layout, this file will go in application/controllers/ErrorController.php. You will also need to create a view script in application/views/scripts/error/error.phtml; sample content might look like:

    <!DOCTYPE html
    PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"
    >
    <
    html>
    <
    head>
      <
    meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
      <
    title>Error</title>
    </
    head>
    <
    body>
        <
    h1>An error occurred</h1>
        <
    p>An error occurredplease try again later.</p>
    </
    body>
    </
    html>

    24.1.2.8. View the Site!

    With your first controller and view under your belt, you can now fire up your browser and browse to the site. Assuming example.com is your domain, any of the following URLs will get to the page we've just created:

    • http://example.com/

    • http://example.com/index

    • http://example.com/index/index

    You're now ready to start creating more controllers and action methods. Congratulations!

    digg delicious meneame google twitter technorati facebook

    Comments

    Loading...