Category: zf3

Zend framework quick guide

Quick overview on Zend Framework 3 with enough details.

  • Zend\EventManager component allows to send events and register listeners to react to them.

  • Zend\ModuleManager. In ZF3, every application consists of modules and this component contains module loading functionality.

  • Zend\ServiceManager. This is the centralized registry of all services available in the application, making it possible to access services from any point of the web site.

  • Zend\Http provides an easy interface for performing Hyper-Text Transfer Protocol (HTTP) requests.

  • Zend\Mvc. Support of Model-View-Controller pattern and separation of business logic from presentation.

  • Zend\View. Provides a system of helpers, output filters, and variable escaping. Used in presentation layer.

  • Zend\Form. Web form data collection, filtering, validation and rendering.

  • Zend\InputFilter. Provides an ability to define form data validation rules.

  • Zend\Filter. Provides a set of commonly used data filters, like string trimmer.

  • Zend\Validator. Provides a set of commonly used validators.

Events & Application's Life Cycle

Each application life stage is initiated by the application by triggering an event (this event is represented by the MvcEvent class living in Zend\Mvc namespace). Other classes (either belonging to Zend Framework or specific to your application) may listen to events and react accordingly.

Below, the five main events (life stages) are presented:

Bootstrap. When this event is triggered by the application, a module has a chance to register itself as a listener of further application events in its onBootstrap() callback method.

Route. When this event is triggered, the request's URL is analyzed using a router class (typically, with Zend\Router\Http\TreeRouteStack class). If an exact match between the URL and a route is found, the request is passed to the site-specific controller class assigned to the route.

Dispatch. The controller class "dispatches" the request using the corresponding action method and produces the data that can be displayed on the web page.

Render. On this event, the data produced by the controller's action method are passed for rendering to Zend\View\Renderer\PhpRenderer class. The renderer class uses a view template file for producing an HTML page.

Finish. On this event, the HTTP response is sent back to client.

Life cycle


Common Services Name and it's short description


Application

Allows to retrieve the singleton of [Zend\Mvc\Application] class.

ApplicationConfig

Configuration array extracted from application.config.php file.

Config

Merged configuration array extracted from module.config.php files merged with autoload/global.php and autoload/local.php.

EventManager

Allows to retrieve a new instance of [Zend\EventManager\EventManager] class. The event manager allows to send (trigger) events and attach event listeners.

SharedEventManager

Allows to retrieve the singleton instance of [Zend\EventManager\SharedEventManager] class. The shared event manager allows to listen to events defined by other classes and components.

ModuleManager

Allows to retrieve the singleton of [Zend\ModuleManager\ModuleManager] class. The module manager is responsible for loading application modules.

Request

The singleton of [Zend\Http\Request] class. Represents HTTP request received from client.

Response

The singleton of [Zend\Http\Response] class. Represents HTTP response that will be sent to client.

Router

The singleton of [Zend\Router\Http\TreeRouteStack]. Performs URL routing.

ServiceManager

Service manager itself.

ViewManager

The singleton of [Zend\Mvc\View\Http\ViewManager] class. Responsible for preparing the view layer for page rendering.


Event & MvcEvent


An event is technically an instance of the Zend\EventManager\Event class. An event can basically have at least the following parts:

name - uniquely identifies the event
target - this is typically a pointer to the object which triggered the event
params - event-specific arguments passed to the event listeners.

It is possible to create custom types of events by extending the Event class. For example, the Zend\Mvc component defines the custom event type named Zend\Mvc\MvcEvent, which extends the Event class and adds several properties and methods needed for the Zend\Mvc component to work.


EventManager & SharedEventManager


It is important to understand the difference between the usual event manager and the shared event manager.

The usual event manager is not stored as a singleton in the service manager. Every time you request the EventManager service from the service manager, you receive a new instance of it. This is done for privacy and performance reasons:

  • It is assumed by default that the class triggering events will request and save somewhere its own private event manager, because it doesn't want other classes to automatically listen to those events. Events triggered by the class are assumed to belong to that class privately.

  • If anyone would be able to listen to any event triggered by any class, there would be performance hell - too many event listeners would be invoked, thus increasing page load time. It is better to avoid this by keeping events private.

But, in case if someone intentionally needs to listen to other's events, there is a special shared event manager. The SharedEventManager service is stored in the service manager as a singleton, so you can be sure everyone will have the same instance of it.

With the SharedEventManager, you can attach a listener to private events triggered by certain class (or several classes). You specify the unique class identifier(s) to which you would like to listen. That simple!


Model-View-Controller


  • Zend\Mvc - Support of MVC pattern. Implements base controller classes, controller plugins, etc.
  • Zend\View - Implements the functionality for variable containers, rendering a web page and common view helpers.
  • Zend\Http - Implements a wrapper around HTTP request and response.
Method Name Description
getRequest() Retrieves the @Zend\Http\Request object, which is the
representation of HTTP request data.
getResponse() Retrieves the @Zend\Http\PhpEnvironment\Response object
allowing to set data of HTTP response.
getEventManager() Returns the @Zend\EventManager\EventManager object,
allowing to trigger events and listen to events.
getEvent() Returns the @Zend\Mvc\MvcEvent object, which represents
the event the controller responds to.
getPluginManager() Returns the @Zend\Mvc\Controller\PluginManager object,
which can be used for registering controller plugins.
plugin($name, $options) This method allows to access certain controller plugin
with the given name.
__call($method, $params) Allows to call a plugin indirectly using the PHP __call
magic method.

Retrieving Data from HTTP Request $this->request()


Method Name Description
isGet() Checks if this is a GET request.
isPost() Checks if this is a POST request.
isXmlHttpRequest() Checks if this request is an AJAX request.
isFlashRequest() Check if this request is a Flash request.
getMethod() Returns the method for this request.
getUriString() Returns the URI for this request object as a string.
getQuery($name, $default) Returns the query parameter by name, or all query parameters.
If a parameter is not found, returns the $default value.
getPost($name, $default) Returns the parameter container responsible for post
parameters or a single post parameter.
getCookie() Returns the Cookie header.
getFiles($name, $default) Returns the parameter container responsible for file
parameters or a single file.
getHeaders($name, $default) Returns the header container responsible for headers
or all headers of a certain name/type.
getHeader($name, $default) Returns a header by $name. If a header is not found,
returns the $default value.
renderRequestLine() Returns the formatted request line (first line) for
this HTTP request.
fromString($string) A static method that produces a Request object from a
well-formed Http Request string
toString() Returns the raw HTTP request as a string.

Retrieving GET and POST Variables


To simply get a GET or POST variable from an HTTP request, you use the following code:

// Get a variable from GET
$getVar = $this->params()->fromQuery('var_name', 'default_val');

// Get a variable from POST
$postVar = $this->params()->fromPost('var_name', 'default_val');

Putting Data to HTTP Response $this->response()


Although you rarely interact with HTTP response data directly, you can do that with the help of getResponse() method provided by the @AbstractActionController[Zend\Mvc\Controller\AbstractActionController] base class. The getResponse() method returns the instance of @Zend\Http\PhpEnvironment\Response class.

Method Name Description
fromString($string) Populate response object from string.
toString() Renders entire response as HTTP response string.
setStatusCode($code) Sets HTTP status code and (optionally) message.
getStatusCode() Retrieves HTTP status code.
setReasonPhrase($reasonPhrase) Sets the HTTP status message.
getReasonPhrase() Gets HTTP status message.
isForbidden() Checks if the response code is 403 Forbidden.
isNotFound() Checks if the status code indicates the resource is not found (404 status code).
isOk() Checks whether the response is successful.
isServerError() Checks if the response is 5xx status code.
isRedirect() Checks whether the response is 303 Redirect.
isSuccess() Checks whether the response is 200 Successful.
setHeaders(Headers $headers) Allows to set response headers.
getHeaders() Returns the list of response headers.
getCookie() Retrieves Cookie header.
setContent($value) Sets raw response content.
getContent() Returns raw response content.
getBody() Gets and decodes the content of the response.

For example, use the following code to set 404 status code for the response:

$this->getResponse()->setStatusCode(404);

Use the following code to add a header to response:

$headers = $this->getResponse()->getHeaders();
$headers->addHeaderLine(
    "Content-type: application/octet-stream");

Use the following code to set response content:

$this->getResponse()->setContent('Some content');

Variable Containers $view = new ViewModel()


The @ViewModel[Zend\View\Model\ViewModel] class provides several methods that you can additionally use to set variables to @ViewModel[Zend\View\Model\ViewModel] and retrieve variables from it.

Method name Description
getVariable($name, $default) Returns a variable by name (or default value if the variable does not exist).
setVariable($name, $value) Sets a variable.
setVariables($variables, $overwrite) Sets a group of variables, optionally overwriting the existing ones.
getVariables() Returns all variables as an array.
clearVariables() Removes all variables.

Controller Plugins


A controller plugin is a class which extends the functionality of all controllers in some way.

Standard Plugin Class Description
@Params Allows to retrieve variables from HTTP request,
including GET and POST variables.
@Url[Zend\Mvc\Controller\Plugin\Url] Allows to generate absolute or relative URLs
from inside controllers.
@Layout[Zend\Mvc\Controller\Plugin\Layout] Gives access to layout view model for passing data to
layout template.
@Identity[Zend\Mvc\Plugin\Identity\Identity] Returns the identity of the user who has logged into the
website.
@FlashMessenger[Zend\Mvc\Plugin\FlashMessenger\FlashMessenger] Allows to define "flash" messages which are stored in
session and can be displayed on a different web page.
@Redirect[Zend\Mvc\Controller\Plugin\Redirect] Allows to redirect the request to another controller's
action method.
@PostRedirectGet[Zend\Mvc\Plugin\Prg\PostRedirectGet] Redirects the POST request, converting all POST variables
to GET ones.
@FilePostRedirectGet[Zend\Mvc\Plugin\FilePrg\FilePostRedirectGet] Redirects the POST request, preserving uploaded files.

Inside of the controller's action method, you access a plugin in the following way:

// Access Url plugin
$urlPlugin = $this->url();

// Access Layout plugin
$layoutPlugin = $this->layout();

// Access Redirect plugin
$redirectPlugin = $this->redirect();

As an alternative, you can invoke a plugin by its fully qualified name with the plugin() method provided by the base controller class, as follows:

use Zend\Mvc\Controller\Plugin\Url; 

// Inside your controller's action use the plugin() method.
$urlPlugin = $this->plugin(Url::class);

Writing Own Controller Plugin


In your websites, you will likely need to create custom controller plugins. For example, assume you need that all your controller classes to be able to check whether a site user is allowed to access certain controller action. This can be implemented with the AccessPlugin class.

The controller plugin should be derived from the @AbstractPlugin[Zend\Mvc\Controller\Plugin\AbstractPlugin] class. Plugins typically live in their own namespace Plugin, which is nested in Controller namespace:

<?php
namespace Application\Controller\Plugin; 

use Zend\Mvc\Controller\Plugin\AbstractPlugin;

// Plugin class
class AccessPlugin extends AbstractPlugin 
{
    // This method checks whether user is allowed
    // to visit the page 
    public function checkAccess($actionName)
    {
        // ...
    }
}

To let Zend Framework 3 know about your plugin, you need to register it in your module.config.php file under the controller_plugins key. See below for example:

<?php
return [
    // ... 

    'controller_plugins' => [
        'factories' => [
            Controller\Plugin\AccessPlugin::class => InvokableFactory::class,
        ],
        'aliases' => [
            'access' => Controller\Plugin\AccessPlugin::class,
        ]
    ],

    // ...
];

Please note that we also register an alias for the plugin to be able to get the plugin by its short name.

After that, you'll be able to access your custom plugin from all of your controller's actions in this way:

// Check if site user is allowed to visit the "index" page
$isAllowed = $this->access()->checkAccess('index');

View Helpers


A view helper is typically a (relatively) simple PHP class whose goal is to render some part of a view. You can invoke view helpers from any view template. With view helpers, you can create reusable widgets (like menus, navigation bars, etc.) for your web pages.

View helpers are analogous to controller plugins: the controller plugins allow to "extend" the functionality of controllers, and view helpers allow to "extend" the functionality of view templates.

ZF3 provides many standard view helpers out of the box.

Standard Plugin Class Description
@BasePath Allows to retrieve the base path to the web application,
which is the absolute path to APP_DIR.
@Url[Zend\View\Helper\Url] Allows to generate absolute or relative URL addresses
from inside view templates.
@ServerUrl Retrieves the current request's URL.
@Doctype Helper for setting and retrieving the doctype HTML element
of the web page.
@HeadTitle Helper for setting the title HTML element
of the web page.
@HtmlList Helper for generating ordered and unordered HTML lists.
@ViewModel[Zend\View\Helper\ViewModel] Helper for storing and retrieving the view model
@Layout[Zend\View\Helper\Layout] Retrieves the layout template view.
@Partial Allows to render a "partial" view template.
@InlineScript Helper for setting and retrieving script elements for
inclusion in HTML body section.
@Identity[Zend\View\Helper\Identity] View helper to retrieve the authenticated user's identity.
@FlashMessenger[Zend\View\Helper\FlashMessenger] Allows to retrieve the "flash" messages stored in
session.
@EscapeHtml Allows to escape a variable outputted to a web page.

To demonstrate the usage of a view helper, below we will show how to set a title for a web page. Typically, it is required to give a different title per each web page. You can do this with the @HeadTitle view helper. For example, you can set the title for the About page by adding the following PHP code in the beginning of the about.phtml view template:

<?php
$this->headTitle('About');

In the code above, we call the @HeadTitle view helper and pass it the page title string ("About") as the argument. The @HeadTitle view helper internally sets the text for the <title> HTML element of your web page. Then, if you open the About page in your web browser, the page title will look like "About - ZF Skeleton Application" (see the figure 4.9 below for an example):


Overriding Default View Template Name


The @ViewModel[Zend\View\Model\ViewModel] can also be used to override the default view template resolving. Actually the @ViewModel[Zend\View\Model\ViewModel] class is more than just a variable container. Additionally, it allows to specify which view template should be used for page rendering. The summary of methods provided for this purpose is shown in table

Method name Description
setTemplate() Sets the view template name.
getTemplate() Returns the view template name.
// Index action renders the Home page of your site.
public function indexAction() 
{    
    // Use a different view template for rendering the page.
    $viewModel = new ViewModel();
    $viewModel->setTemplate('application/index/about');
    return $viewModel;
}

Routing


When a site user enters a URL in a web browser, the HTTP request is finally dispatched to controller's action in your ZF3-based website. we will learn about how ZF3-based application maps page URLs to controllers and their actions. This mapping is accomplished with the help of routing. Routing is implemented as a part of @Zend\Router component.

Component Description
@Zend\Router Implements support of routing.
@Zend\Barcode Auxiliary component implementing barcodes.

Route Types


Route Type Description
Literal Exact matching against the path part of a URL.
Segment Matching against a path segment (or several segments) of a URL.
Regex Matching the path part of a URL against a regular expression template.
Hostname Matching the host name against some criteria.
Scheme Matching URL scheme against some criteria.
Method Matching an HTTP method (e.g. GET, POST, etc.) against some criteria.

View Helper


Placeholder View Helper

The @Placeholder[Zend\View\Helper\Placeholder] is another useful view helper allowing for capturing HTML content and storing it for later use. Thus, analogous to the @Partial view helper, it allows to compose your page of several pieces.

For example, you can use the @Placeholder[Zend\View\Helper\Placeholder] view helper in pair with the @Partial view helper to "decorate" the content of a view template with another view template. A useful practical application for this is layout "inheritance".

Put the following code in the layout2.phtml template file:

<?php $this->placeholder('content')->captureStart(); ?>

<div class="row">
    <div class="col-md-8">
    <?= $this->content; ?>
    </div>
    <div class="col-md-4">
        <div class="panel panel-default">
          <div class="panel-heading">
            <h3 class="panel-title">Ads</h3>
          </div>
          <div class="panel-body">
            <strong>Zend Framework 3 Book</strong>
            <p>Learn how to create modern web applications with PHP 
                and Zend Framework 3</p>            
            <a target="_blank" 
               href="https://github.com/olegkrivtsov/using-zend-framework-3-book">
               Learn More
            </a>
          </div>
        </div>
    </div>
</div>

<?php 
  $this->placeholder('content')->captureEnd(); 
  echo $this->partial('layout/layout', 
          ['content'=>$this->placeholder('content')]); 
?>

And than use bellow code into controller file to send data to layout2 file

/**
     * We override the parent class' onDispatch() method to
     * set an alternative layout for all actions in this controller.
     */
    public function onDispatch(MvcEvent $e)
    {
        // Call the base class' onDispatch() first and grab the response
        $response = parent::onDispatch($e);

        // Set alternative layout
        $this->layout()->setTemplate('layout/layout2');
        $layoutData = [
            'company' => 'XYZ Co.'
        ];
        $this->layout()->setVariables($layoutData);

        // Return the response
        return $response;
    }

Adding Scripts to a Layout


Let say you want to add bellow code into footer of the layout.

<script type="text/javascript">
  // Show a simple alert window with the "Hello World!" text.
  $(document).ready(function() { 
    alert('Hello World!');
  });
</script>
Method name Description
appendFile() Puts a link to external JS file after all others.
offsetSetFile() Inserts a link to external JS file in a given list position.
prependFile() Puts a link to external JS file before all others.
setFile() Clears the list of scripts and puts the single external JS file in it.
appendScript() Puts an inline script after all others.
offsetSetScript() Inserts an inline script to a given list position.
prependScript() Puts an inline script before all others.
setScript() Clears the list of inline scripts and puts the single inline
script in it.
<?php
$this->headScript()->appendFile('/js/yourscript.js', 'text/javascript');
<?php 
$script = <<<EOT
  $(document).ready(function() {
    alert('Hello World!');
  });
EOT;
$this->inlineScript()->appendScript($script);

Adding Style (CSS) to a Layout


<?php
$this->headLink()->appendStylesheet('/css/style.css'); 
$this->headLink()->appendStylesheet(
       '//code.jquery.com/ui/1.10.3/themes/smoothness/jquery-ui.css'); 
Method name Description
appendStylesheet() Puts a link to CSS stylesheet file after all others.
offsetSetStylesheet() Inserts a link to CSS stylesheet file in a given list position.
prependStylesheet() Puts a link to external CSS stylesheet file before all others.
setStylesheet() Clears the list and puts the single CSS file instead.

If you want to add an inline <style> element in the head section of the document, you can use the @HeadStyle view helper.

Method name Description
appendStyle() Adds a CSS stylesheet inline after all others.
offsetSetStyle() Inserts a CSS stylesheet inline in a given list position.
prependStyle() Puts a CSS stylesheet inline before all others.
setStyle() Clears the list and puts the single CSS stylesheet inline instead.

User Input with Forms


Component Description
@Zend\Form Contains base form model classes.
@Zend\Filter Contains various filters classes.
@Zend\Validator Implements various validator classes.
@Zend\InputFilter Implements a container for filters/validators.
@Zend\Mail Contains E-mail sending functionality.

Foot Note