Zend Framework 2.0 Patterns Tutorial

In the beginning. . .

ZF2 Patterns 3

A Brief History of ZF

Initial Announcements and Work

ZF2 Patterns 4

• October 2005: Announced the project


ZF2 Patterns 4

• October 2005: Announced the project• March 2006: First public preview release, 0.1.0


ZF2 Patterns 4

• October 2005: Announced the project• March 2006: First public preview release, 0.1.0• Fall 2006: Rewrite of the MVC

1.0.0 - July 2007

ZF2 Patterns 5

• First stable release• Basic MVC system, with plugins, action helpers,

automated view rendering etc.

1.0.0 - July 2007

ZF2 Patterns 5


automated view rendering etc.• Many web service API consumers

1.0.0 - July 2007

ZF2 Patterns 5


automated view rendering etc.• Many web service API consumers• Server classes for XML-RPC, REST

1.5.0 - March 2008

ZF2 Patterns 6

• First minor release

1.5.0 - March 2008

ZF2 Patterns 6

• First minor release• Zend_Form introduced

1.5.0 - March 2008

ZF2 Patterns 6

• First minor release• Zend_Form introduced• Zend_Layout introduced

1.5.0 - March 2008

ZF2 Patterns 6

• First minor release• Zend_Form introduced• Zend_Layout introduced• Layout-aware view helper system introduced

1.6.0 - September 2008

ZF2 Patterns 7

• Dojo integration


ZF2 Patterns 7

• Dojo integration• PHPUnit scaffolding for testing controllers


ZF2 Patterns 7

• Dojo integration• PHPUnit scaffolding for testing controllers• Introduction of the ContextSwitch action helper

1.7.0 - November 2008

ZF2 Patterns 8

• AMF support

1.7.0 - November 2008

ZF2 Patterns 8

• AMF support• Performance improvements

1.8.0 - April 2009

ZF2 Patterns 9

• Introduction of Zend_Tool

1.8.0 - April 2009

ZF2 Patterns 9

• Introduction of Zend_Tool• Introduction of Zend_Application

1.8.0 - April 2009

ZF2 Patterns 9

• Introduction of Zend_Tool• Introduction of Zend_Application• First widely usable release of ZF

1.9.0 - August 2009

ZF2 Patterns 10

• Addition of Zend_Feed_Reader

1.9.0 - August 2009

ZF2 Patterns 10

• Addition of Zend_Feed_Reader• PHP 5.3 support/compatibility

1.9.0 - August 2009

ZF2 Patterns 10

• Addition of Zend_Feed_Reader• PHP 5.3 support/compatibility• Primarily community-led additions

1.9.0 - August 2009

ZF2 Patterns 10

• Addition of Zend_Feed_Reader• PHP 5.3 support/compatibility• Primarily community-led additions• Beginning of monthly bug hunts in October

1.10.0 - January 2010

ZF2 Patterns 11

• Integration of ControllerTestCase withZend_Application

1.10.0 - January 2010

ZF2 Patterns 11


• Addition of Zend_Feed_Writer, markingcompletion of Zend_Feed refactoring

1.10.0 - January 2010

ZF2 Patterns 11



• Documentation changes: adoption of PhD to renderend-user manual, introduction of comment system,and new “Learning Zend Framework section”

1.10.0 - January 2010

ZF2 Patterns 11



• Documentation changes: adoption of PhD to renderend-user manual, introduction of comment system,and new “Learning Zend Framework section”

• Primarily community-led additions

1.11.0 November 2010

ZF2 Patterns 12

• Mobile support via Zend_Http_UserAgent

1.11.0 November 2010

ZF2 Patterns 12

• Mobile support via Zend_Http_UserAgent• SimpleCloud API via Zend_Cloud

Where do we go from here?

Zend Framework 2.0’s focusis on improving consistency

and performance

Incremental Improvements

Baby steps

ZF2 Patterns 18

• Convert code from vendor prefixes (e.g.“Zend_Foo”) to PHP 5.3 namespaces

Baby steps

ZF2 Patterns 18


• Refactor exceptions

Baby steps

ZF2 Patterns 18


• Refactor exceptions• Switch ZF to be autoload-only

Baby steps

ZF2 Patterns 18


• Refactor exceptions• Switch ZF to be autoload-only• Improve and standardize the plugin system

Namespaces

The Problem

ZF2 Patterns 21

• Lengthy class names

• Difficult to refactor

The Problem

ZF2 Patterns 21

• Lengthy class names

• Difficult to refactor• Difficult to retain semantics with shorter names

Basics

ZF2 Patterns 22

• Every class file declares a namespace

Basics

ZF2 Patterns 22

• Every class file declares a namespace• One namespace per file

Basics

ZF2 Patterns 22

• Every class file declares a namespace• One namespace per file• Any class used that is not in the current namespace

(or a subnamespace) is imported and typicallyaliased

Basics

ZF2 Patterns 22

• Every class file declares a namespace• One namespace per file• Any class used that is not in the current namespace

(or a subnamespace) is imported and typicallyaliased

• Global resolution is discouraged, except in the caseof classes referenced in strings

Namespace Example

ZF2 Patterns 23

namespace Zend\EventManager;

use Zend\Stdlib\CallbackHandler;

class EventManager implements EventCollection{

/* ... */}

Using Aliases

ZF2 Patterns 24

namespace Zend\Mvc;use Zend\Stdlib\Dispatchable,

Zend\Di\ServiceLocator as Locator;

class FrontController implements Dispatchable{

public function __construct(Locator $locator){

$this->serviceLocator = $locator;}

}

Recommendation for Migration

ZF2 Patterns 25

Use imports instead ofrequire_once calls in your

code!

Importing ZF1 Classes

ZF2 Patterns 26

use Zend_Controller_Action as Controller;class FooController extends Controller {}

// Later, this might become:use Zend\Controller\Action as Controller;class FooController extends Controller {}

Naming

ZF2 Patterns 27

• All code in the project is in the “Zend” namespace

Naming

ZF2 Patterns 27

• All code in the project is in the “Zend” namespace• Each component defines a unique namespace

Naming

ZF2 Patterns 27

• All code in the project is in the “Zend” namespace• Each component defines a unique namespace• Classes within a component all live in that

namespace or a subnamespace

Naming

ZF2 Patterns 27

• All code in the project is in the “Zend” namespace• Each component defines a unique namespace• Classes within a component all live in that

namespace or a subnamespace• Typically, a class named after the component is the

gateway class

Naming Examples

ZF2 Patterns 28

Zend/EventManager|-- EventCollection.php

‘-- EventManager.php

Naming Examples

ZF2 Patterns 28

Zend/EventManager|-- EventCollection.php

‘-- EventManager.php


class EventManager implementsEventCollection{}

Interfaces

ZF2 Patterns 29

• Interfaces are named after nouns or adjectives, anddescribe what they provide

Interfaces

ZF2 Patterns 29


• In most cases, concrete implementations ofinterfaces live in a subnamespace named after theinterface

Interfaces

ZF2 Patterns 29


• In most cases, concrete implementations ofinterfaces live in a subnamespace named after theinterface

• More solid Contract-Oriented paradigm

Interface Examples

ZF2 Patterns 30

Zend/Session|-- Storage.php‘-- Storage

|-- ArrayStorage.php

‘-- SessionStorage.php

Interface Examples

ZF2 Patterns 30

Zend/Session|-- Storage.php‘-- Storage

|-- ArrayStorage.php

‘-- SessionStorage.php

namespace Zend\Session;

use Traversable, ArrayAccess,Serializable, Countable;

interface Storageextends Traversable,

ArrayAccess, Serializable,Countable{

/* ... */}

Concrete Implementation

ZF2 Patterns 31

namespace Zend\Session\Storage;

use ArrayObject,Zend\Session\Storage,Zend\Session\Exception;

class ArrayStorage extends ArrayObject implements Storage{

/* ... */}

Exceptions

The Problem

ZF2 Patterns 33

• All exceptions derived from a common class

The Problem

ZF2 Patterns 33

• All exceptions derived from a common class• Inability to extend semantic exception types offered

in the SPL

The Problem

ZF2 Patterns 33


in the SPL• Limited catching strategies

The Problem

ZF2 Patterns 33


in the SPL• Limited catching strategies• Hard dependency for each and every component

ZF2 Approach

ZF2 Patterns 34

• We eliminated Zend_Exception entirely

ZF2 Approach

ZF2 Patterns 34

• We eliminated Zend_Exception entirely• Each component defines a marker Exception

interface

ZF2 Approach

ZF2 Patterns 34

• We eliminated Zend_Exception entirely• Each component defines a marker Exception

interface• Concrete exceptions live in an Exception

subnamespace, and extend SPL exceptions

What the solution provides

ZF2 Patterns 35

• Catch specific exception types


ZF2 Patterns 35

• Catch specific exception types• Catch SPL exception types


ZF2 Patterns 35

• Catch specific exception types• Catch SPL exception types• Catch component-level exceptions


ZF2 Patterns 35

• Catch specific exception types• Catch SPL exception types• Catch component-level exceptions• Catch based on global exception type

Exception Definitions

ZF2 Patterns 36

Zend/EventManager|-- Exception.php‘-- Exception

‘--InvalidArgumentException.php


ZF2 Patterns 36




interface Exception {}


ZF2 Patterns 36




interface Exception {}

namespace Zend\EventManager\Exception;

use Zend\EventManager\Exception;

class InvalidArgumentExceptionextends \InvalidArgumentExceptionimplements Exception

{}

Catching Exceptions

ZF2 Patterns 37

namespace Zend\EventManager\Exception;use Zend\EventManager\Exception;try {

$events->trigger(’foo.bar’, $object);} catch (InvalidArgumentException $e) {} catch (Exception $e) {} catch (\InvalidArgumentException $e) {} catch (\Exception $e) {}

Autoloading

The Problem

ZF2 Patterns 39

• Performance issues

• Many classes are used JIT, and shouldn’t beloaded until needed

The Problem

ZF2 Patterns 39

• Performance issues

• Many classes are used JIT, and shouldn’t beloaded until needed

• Missing require_once calls lead to errors

ZF2 Approach

ZF2 Patterns 40

• No more require_once calls!

ZF2 Approach

ZF2 Patterns 40

• No more require_once calls!• Deliver multiple autoloading approaches

• ZF1-style include_path autoloader• Per- namespace/vendor prefix autoloading• Class-Map autoloading

ZF1-Style Autoloading

ZF2 Patterns 41

require_once ’Zend/Loader/StandardAutoloader.php’;$loader = new Zend\Loader\StandardAutoloader(array(

’fallback_autoloader’ => true,));$loader->register();

ZF2 NS/Prefix Autoloading

ZF2 Patterns 42

require_once ’Zend/Loader/StandardAutoloader.php’;$loader = new Zend\Loader\StandardAutoloader();$loader->registerNamespace(’My’, __DIR__ . ’/../library/My’)

->registerPrefix(’Phly_’, __DIR__ . ’/../library/Phly’);$loader->register();

Class-Map Autoloading

ZF2 Patterns 43

return array(’My\Foo\Bar’ => __DIR__ . ’/Foo/Bar.php’,

);

Class-Map Autoloading

ZF2 Patterns 43

return array(’My\Foo\Bar’ => __DIR__ . ’/Foo/Bar.php’,

);

require_once ’Zend/Loader/ClassMapAutoloader.php’;$loader = new Zend\Loader\ClassMapAutoloader();$loader->registerAutoloadMap(__DIR__ . ’/../library/.classmap.php’);$loader->register();

Class-Maps? Won’t those require work?

ZF2 Patterns 44

• Yes, they will. But we already have a tool,bin/classmap_generator.php.

Class-Maps? Won’t those require work?

ZF2 Patterns 44

• Yes, they will. But we already have a tool,bin/classmap_generator.php.

• Usage is trivial:

prompt> cd your/libraryprompt> php /path/to/classmap_generator.php -w# Class-Map now exists in .classmap.php

Why?

ZF2 Patterns 45

• Class-Maps show a 25% improvement on the ZF1autoloader when no acceleration is present

Why?

ZF2 Patterns 45

• Class-Maps show a 25% improvement on the ZF1autoloader when no acceleration is present• and 60-85% improvements when an opcode cache is in place!

Why?

ZF2 Patterns 45


• Pairing namespaces/prefixes with specific pathsshows >10% gains with no acceleration

Why?

ZF2 Patterns 45


• Pairing namespaces/prefixes with specific pathsshows >10% gains with no acceleration• and 40% improvements when an opcode cache is in place!

Autoloader Factory

ZF2 Patterns 46

• With multiple strategies comes the need for a factory

Autoloader Factory

ZF2 Patterns 46

• With multiple strategies comes the need for a factory• Choose several strategies

Autoloader Factory

ZF2 Patterns 46


• Class-Map for fastest lookup

Autoloader Factory

ZF2 Patterns 46


• Class-Map for fastest lookup• Namespace/prefix paths for common code

Autoloader Factory

ZF2 Patterns 46


• Class-Map for fastest lookup• Namespace/prefix paths for common code• ZF1/PSR0-style fallback autoloader for

development

Autoloader Factory Example

ZF2 Patterns 47

require_once ’Zend/Loader/AutoloaderFactory.php’;use Zend\Loader\AutoloaderFactory;AutoloaderFactory::factory(array(

’Zend\Loader\ClassMapAutoloader’ => array(__DIR__ . ’/../library/.classmap.php’,__DIR__ . ’/../application/.classmap.php’,

),’Zend\Loader\StandardAutoloader’ => array(

’namespaces’ => array(’Zend’ => __DIR__ . ’/../library/Zend’,

),’fallback_autoloader’ => true,

),));

Start Migrating

ZF2 Patterns 48

You can use the ZF2

autoloaders and class-map

generation facilities today;start migrating now!

Plugin Loading

Terminology

ZF2 Patterns 50

• For our purposes, a “plugin” is any class that isdetermined at runtime.

Terminology

ZF2 Patterns 50

• For our purposes, a “plugin” is any class that isdetermined at runtime.

• Action and view helpers• Adapters• Filters and validators

The Problem

ZF2 Patterns 51

• Varying approaches to dynamically discoveringplugin classes

The Problem

ZF2 Patterns 51


• Paths relative to the calling class• Prefix-path stacks (most common)• Setters to indicate classes

The Problem

ZF2 Patterns 51



• Most common approach is terrible

The Problem

ZF2 Patterns 51



• Most common approach is terrible

• Bad performance• Hard to debug• No caching of discovered plugins

ZF2 Approach: Plugin Broker

ZF2 Patterns 52

• Separate Plugin Location interface• Allows varying implementation of plugin lookup

ZF2 Approach: Plugin Broker

ZF2 Patterns 52

• Separate Plugin Location interface• Allows varying implementation of plugin lookup

• Separate Plugin Broker interface• Composes a Plugin Locator

Plugin Locator Interface

ZF2 Patterns 53

namespace Zend\Loader;interface ShortNameLocator{

public function isLoaded($name);public function getClassName($name);public function load($name);

}

Plugin broker interface

ZF2 Patterns 54

namespace Zend\Loader;

interface Broker{

public function load($plugin, array $options = null);public function getPlugins();public function isLoaded($name);public function register($name, $plugin);public function unregister($name);public function setClassLoader(ShortNameLocator $loader);public function getClassLoader();

}

How do I use it?

ZF2 Patterns 55

• Create a default plugin loader

How do I use it?

ZF2 Patterns 55

• Create a default plugin loader• Create a default plugin broker

How do I use it?

ZF2 Patterns 55

• Create a default plugin loader• Create a default plugin broker• Compose a broker into your class

How do I use it?

ZF2 Patterns 55

• Create a default plugin loader• Create a default plugin broker• Compose a broker into your class• Optionally, define static configuration

How do I use it?

ZF2 Patterns 55

• Create a default plugin loader• Create a default plugin broker• Compose a broker into your class• Optionally, define static configuration• Optionally, pass broker and loader configuration

How do I use it?

ZF2 Patterns 55

• Create a default plugin loader• Create a default plugin broker• Compose a broker into your class• Optionally, define static configuration• Optionally, pass broker and loader configuration• Optionally, register plugins with locator and/or broker

Plugin Locator Implementation

ZF2 Patterns 56

namespace Zend\View;use Zend\Loader\PluginClassLoader;class HelperLoader extends PluginClassLoader{

/*** @var array Pre-aliased view helpers

*/protected $plugins = array(

’action’ => ’Zend\View\Helper\Action’,’base_url’ => ’Zend\View\Helper\BaseUrl’,/* ... */

);}

Plugin broker implementation

ZF2 Patterns 57

class HelperBroker extends PluginBrokerprotected $defaultClassLoader = ’Zend\View\HelperLoader’;public function load($plugin, array $options = null){

$helper = parent::load($plugin, $options);if (null !== ($view = $this->getView())) {

$helper->setView($view);}return $helper;

}protected function validatePlugin($plugin){

if (! $plugin instanceof Helper) {throw new InvalidHelperException();

}return true;

}}

Composing a broker

ZF2 Patterns 58

use Zend\View\HelperLoader;class Foo{

protected $broker;

public function broker($spec = null, array $options = array()){

if ($spec instanceof Broker) {$this->broker = $spec;return $spec;

} elseif (null === $this->broker) {$this->broker = new PluginBroker();

}if (null === $spec) {

return $this->broker;} elseif (!is_string($spec)) {

throw new \Exception();}return $this->broker->load($spec, $options);

}}

Locator Precedence

ZF2 Patterns 59

(From least specific to most specific)

• Map defined in concrete plugin loader

Locator Precedence

ZF2 Patterns 59


• Map defined in concrete plugin loader• Static maps (latest registration having precedence)

Locator Precedence

ZF2 Patterns 59


• Map defined in concrete plugin loader• Static maps (latest registration having precedence)• Mapping passed via instantiation

Locator Precedence

ZF2 Patterns 59


• Map defined in concrete plugin loader• Static maps (latest registration having precedence)• Mapping passed via instantiation• Explicit mapping provided programmatically

Defining static maps

ZF2 Patterns 60

use Zend\View\HelperLoader;

HelperLoader::addStaticMap(array(’url’ => ’My\Helper\Url’,’base_url’ => ’Project\Helper\BaseUrl’,

));$loader = new HelperLoader();$class = $loader->load(’url’); // "My\Helper\Url"

Passing maps via configuration

ZF2 Patterns 61


$config = array(’url’ => ’My\Helper\Url’,’base_url’ => ’Project\Helper\BaseUrl’,

);

$loader = new HelperLoader($config);$class = $loader->load(’url’); // "My\Helper\Url"

Passing maps to maps!

ZF2 Patterns 62

use Zend\View\HelperLoader,Zend\Loader\PluginClassLoader;

class HelperMap extends PluginClassLoader{

protected $plugins = array(’url’ => ’My\Helper\Url’,’base_url’ => ’Project\Helper\BaseUrl’,

);}$helpers = new HelperMap();$loader = new HelperLoader($helpers);$class = $loader->load(’url’); // "My\Helper\Url"

Extending loaders

ZF2 Patterns 63


class HelperMap extends HelperLoader{

public function __construct($options = null){

// Addes to and/or overrides map in HelperLoader$this->registerPlugins(array(

’url’ => ’My\Helper\Url’,’base_url’ => ’Project\Helper\BaseUrl’,

));parent::__construct($options);

}}

$helpers = new HelperMap();$class = $loader->load(’url’); // "My\Helper\Url"

Passing maps via broker

ZF2 Patterns 64

use Zend\View\HelperBroker;

$broker = new HelperBroker(array(’class_loader’ => array(

’class’ => ’HelperMap’,’options’ => array(

’base_url’ => ’App\Helper\BaseUrl’,),

),));$plugin = $broker->load(’base_url’); // "App\Helper\BaseUrl"

Creating maps manually

ZF2 Patterns 65


$loader = new HelperLoader();$loader->registerPlugin(’url’, ’My\Helper\Url’)

->registerPlugins(array(’base_url’ => ’Project\Helper\BaseUrl’,

));$class = $loader->load(’url’); // "My\Helper\Url"

Managing plugins via a broker

ZF2 Patterns 66

• By default, it consults the loader for a classname,and instantiates that class with the given arguments

Managing plugins via a broker

ZF2 Patterns 66

• By default, it consults the loader for a classname,and instantiates that class with the given arguments

• Optionally, you can also seed the broker, manuallyregistering plugin objects under a given name

Registering a plugin with the broker

ZF2 Patterns 67

use My\Helper\Url;

// Assumes:// - $request == Request object// - $router == Router object// - $broker == HelperBroker

$url = new Url($request, $router);$broker->registerPlugin(’url’, $url); // OR:$broker->registerPlugins(array(

’url’ => $url,));

$url = $broker->load(’url’); // === $url from above

What about lazy-loading?

ZF2 Patterns 68

• Often you need to configure plugins


ZF2 Patterns 68

• Often you need to configure plugins• But you don’t want an instance hanging around until

it’s actually requested


ZF2 Patterns 68

• Often you need to configure plugins• But you don’t want an instance hanging around until

it’s actually requested• Enter the Zend\Loader\LazyLoadingBroker

LazyLoadingBroker Interface

ZF2 Patterns 69

namespace Zend\Loader;interface LazyLoadingBroker extends Broker{

public function registerSpec($name, array $spec = null);public function registerSpecs($specs);public function unregisterSpec($name);public function getRegisteredPlugins();public function hasPlugin($name);

}

Using the LazyLoadingBroker

ZF2 Patterns 70

• Register “specs” with the broker


ZF2 Patterns 70

• Register “specs” with the broker• When that plugin is requested, the provided options

will be used unless new options are provided


ZF2 Patterns 70

• Register “specs” with the broker• When that plugin is requested, the provided options

will be used unless new options are provided• In all other ways, it behaves like other brokers,

including allowing explicit registration of plugins

LazyLoadingBroker Usage

ZF2 Patterns 71

$broker->registerSpec(’url’, array($request, $router));$broker->registerSpecs(array(

’url’ => array($request, $router),));

if (!$broker->hasPlugin(’url’)) {// no spec!

}

$plugins = $broker->getRegisteredPlugins(); // array(’url’)

$url = $broker->load(’url’); // With $request, $router injected

LazyLoadingBroker Usage Via Configuration

ZF2 Patterns 72

use Zend\View\HelperBroker;

$config = array(’specs’ => array(

’url’ => array($request, $rourter),),

);

$broker = new HelperBroker($config);$url = $broker->load(’url’); // With $request, $router injected

New Components

New Components

ZF2 Patterns 75

• Zend\EventManager• Zend\Di

The EventManager

The Problem

ZF2 Patterns 77

• How do we introduce logging/debug points inframework code?

The Problem

ZF2 Patterns 77


• How do we allow users to introduce caching withoutneeding to extend framework code?

The Problem

ZF2 Patterns 77



• How do we allow users to introduce validation,filtering, ACL checks, etc., without needing to extendframework code?

The Problem

ZF2 Patterns 77




• How do we allow users to manipulate the order inwhich plugins, intercepting filters, events, etc.,trigger?

The Problem

ZF2 Patterns 77




• How do we allow users to manipulate the order inwhich plugins, intercepting filters, events, etc.,trigger?

• How can we provide tools for userland code tobenefit from the above?

Solution: Aspect Oriented Programming

ZF2 Patterns 78

• Code defines various “aspects” that may beinteresting to observe and/or attach to from aconsumer

Solution: Aspect Oriented Programming

ZF2 Patterns 78

• Code defines various “aspects” that may beinteresting to observe and/or attach to from aconsumer

• Basically, all of the solutions we’ll look at can beused to implement AOP in a code base.

Requirements

ZF2 Patterns 79

• Reasonably easy to understand design

Requirements

ZF2 Patterns 79

• Reasonably easy to understand design• Allow static or per-instance attachment of handlers,

preferably both

Requirements

ZF2 Patterns 79


preferably both• Preferably while retaining non-global state or allowing overriding

Requirements

ZF2 Patterns 79



• Allow interruption of execution

Requirements

ZF2 Patterns 79



• Allow interruption of execution• Allow prioritization of handlers

Requirements

ZF2 Patterns 79



• Allow interruption of execution• Allow prioritization of handlers• Predictability of arguments passed to handlers

Requirements

ZF2 Patterns 79



• Allow interruption of execution• Allow prioritization of handlers• Predictability of arguments passed to handlers• Ability to attach to many event-emitting components

at once

Solution: Subject-Observer

ZF2 Patterns 80

• Pros• Simple to understand


ZF2 Patterns 80

• Pros• Simple to understand• SPL interfaces are well-known (but limited)


ZF2 Patterns 80


• Cons• Typically, cannot interrupt execution of remaining observers


ZF2 Patterns 80


• Cons• Typically, cannot interrupt execution of remaining observers• Requires a system for each component and/or class


ZF2 Patterns 80


• Cons• Typically, cannot interrupt execution of remaining observers• Requires a system for each component and/or class• Typically, no ability to prioritize handlers

Solution: PubSub/Events

ZF2 Patterns 81

• Pros• Subscribe to arbitrary notices


ZF2 Patterns 81

• Pros• Subscribe to arbitrary notices• Typically per-component + global usage; in many languages, a

single, global aggregator


ZF2 Patterns 81


single, global aggregator• Well-known paradigm in UI programming (think: JavaScript)


ZF2 Patterns 81


single, global aggregator• Well-known paradigm in UI programming (think: JavaScript)• Tends to be Turing complete


ZF2 Patterns 81



• Cons• Often, need to test the Event provided to ensure you can handle

it


ZF2 Patterns 81




it• Global usage means static aggregation and/or static

dependencies


ZF2 Patterns 81





dependencies• . . . but per-component means boiler-plate to compose in each

class using it


ZF2 Patterns 81






class using it• Typically, no ability to prioritize handlers


ZF2 Patterns 81






class using it• Typically, no ability to prioritize handlers

• more on this later. . .

Solution: SignalSlots

ZF2 Patterns 82

• Pros• Well-known in computer science circles


ZF2 Patterns 82

• Pros• Well-known in computer science circles• Code emits signals, which are intercepted by slots (aka handlers)


ZF2 Patterns 82


• Typically, compose a signal manager into a class, but canintegrate with a global manager as well


ZF2 Patterns 82



• Usually has some abilities for prioritizing handlers


ZF2 Patterns 82




• Cons• Verbiage is not well-known amongst PHP developers


ZF2 Patterns 82




• Cons• Verbiage is not well-known amongst PHP developers• Arguments will vary between signals


ZF2 Patterns 82




• Cons• Verbiage is not well-known amongst PHP developers• Arguments will vary between signals• Same issues with composition per-class and static usage as

seen in event systems

Solution: Intercepting Filters

ZF2 Patterns 83

• Pros• Similar to previous solutions, except that each handler receives

the filter chain as an argument, and is responsible for calling thenext in the chain


ZF2 Patterns 83



• Often, the entire “work” of a method is simply a filter


ZF2 Patterns 83



• Often, the entire “work” of a method is simply a filter• Depending on the design, can allow static/global access


ZF2 Patterns 83




• Cons• Sometimes difficult to accomplish complex workflows


ZF2 Patterns 83




• Cons• Sometimes difficult to accomplish complex workflows• Same issues with composition per-class and static usage as

seen in event systems


ZF2 Patterns 83





seen in event systems• Easy to forget to invoke next filter in chain


ZF2 Patterns 83





seen in event systems• Easy to forget to invoke next filter in chain• Typically, no ability to prioritize filters

ZF2: EventManager Component

ZF2 Patterns 84

• Cherry-picks from each of PubSub, SignalSlot, andIntercepting Filters to provide a comprehensivesolution


ZF2 Patterns 84


• Cannot completely solve the composition/staticusage issues• We can solve the composition problem in PHP 5.4 via Traits


ZF2 Patterns 84


• Cannot completely solve the composition/staticusage issues• We can solve the composition problem in PHP 5.4 via Traits• There are some elegant ways to handle static usage

EventCollection Interface

ZF2 Patterns 85

namespace Zend\EventManager;use Zend\Stdlib\CallbackHandler;

interface EventCollection{

public function trigger($event, $context, $argv = array());public function triggerUntil($event, $context, $argv, $callback);public function attach($event, $callback, $priority = 1);public function detach(CallbackHandler $handle);public function getEvents();public function getHandlers($event);public function clearHandlers($event);

}

Triggering Events

ZF2 Patterns 86

use Zend\EventManager\EventManager;

$events = new EventManager();$events->trigger($eventName, $object, $params);/* Where:

* - $eventName is the name of the event; usually the current

* method name

* - $object is the object triggering the event

* - $params are the parameters the handler might need to access,

* usually the method arguments

*/

CallbackHandler

ZF2 Patterns 87

$handler = $events->attach(’some-event’, function($e) use ($log) {$event = $e->getName();$context = get_class($e->getTarget());$params = json_encode($e->getParams());$log->info(sprintf("%s: %s: %s", $event, $context, $params));

});

CallbackHandler with priority

ZF2 Patterns 88

$handler = $events->attach(’some-event’, function($e) use ($log) {/* same as before */

}, 100); // Prioritize! (higher numbers win)

Interrupting execution: testing results

ZF2 Patterns 89

$results = $events->triggerUntil(’some-event’, $o, $argv,function($result) {

return ($result instanceof SomeType);});if ($results->stopped()) {

return $results->last();}

Interrupting execution: via handlers

ZF2 Patterns 90

$events->attach(’some-event’, function($e) {$result = new Result;$e->stopPropagation(true);return $result;

});$results = $events->trigger(’some-event’, $object, $params);if ($results->stopped()) {

return $results->last();}

Composing an EventManager

ZF2 Patterns 91

use Zend\EventManager\EventCollection as Events,Zend\EventManager\EventManager;

class Foo{

protected $events;

public function events(Events $events = null){

if (null !== $events) {$this->events = $events;

} elseif (null === $this->events) {$this->events = new EventManager(__CLASS__);

}return $this->events;

}

public function doSomething($param1, $param2){

$params = compact(’param1’, ’param2’);$this->events()->trigger(__FUNCTION__, $this, $params);

}}

Using a Trait!

ZF2 Patterns 92

use Zend\EventManager\EventCollection as Events,Zend\EventManager\EventManager;

trait Eventful{

public function events(Events $events = null){

if (null !== $events) {$this->events = $events;

} elseif (null === $this->events) {$this->events = new EventManager(__CLASS__);

}return $this->events;

}}

class Foo{

use Eventful;protected $events;

}

Connecting handlers statically

ZF2 Patterns 93

use Zend\EventManager\StaticEventManager;

$events = StaticEventManager::getInstance();$events->connect(’Foo’, ’some-event’, function ($e) {

/* ... */});

Recommendations

ZF2 Patterns 94

• Name your events using __FUNCTION__• If triggering multiple events in the same method, suffix with a

“.(pre|post|etc.)”

Recommendations

ZF2 Patterns 94



• Provide the EventManager constructor with both theclass name and one or more “service” names, tomake static attachment more semantic

Recommendations

ZF2 Patterns 94



• Provide the EventManager constructor with both theclass name and one or more “service” names, tomake static attachment more semantic• This allows a single callback to listen to many components!

Dependency Injection

What is Dependency Injection?

ZF2 Patterns 96

Quite simply: defining ways to passdependencies into an object.

What is Dependency Injection?

ZF2 Patterns 96

Quite simply: defining ways to passdependencies into an object.

namespace My\Helper;class Url{

public function __construct(Request $request){

$this->request = $request;}

public function setRouter(Router $router){

$this->router = $router;}

}

So, why do people fear it?

ZF2 Patterns 97

• They don’t.

So, why do people fear it?

ZF2 Patterns 97

• They don’t.• They fear Dependency Injection Containers.

What’s a Dependency Injection Container?

ZF2 Patterns 98

Put simply:

an object graph for mapping

dependency relationsbetween objects.

Again, why do people fear it?

ZF2 Patterns 99

It looks like magic.

Object with Dependencies

ZF2 Patterns 100

namespace My\Helper;class Url{

public function __construct(Request $request){

$this->request = $request;}

public function setRouter(Router $router){

$this->router = $router;}

}

Another Object with Dependencies

ZF2 Patterns 101

namespace mwop\Mvc;class Router{

public function addRoute(Route $route){

$this->routes->push($route);}

}

Grabbing an object and using it

ZF2 Patterns 102

$urlHelper = $di->get(’url-helper’);echo $url->generate(’/css/site.css’);echo $url->generate(array(’id’ => $id), array(’name’ => ’blog’));

The questions

ZF2 Patterns 103

• How can I be sure I have my dependencies?

The questions

ZF2 Patterns 103

• How can I be sure I have my dependencies?• You define them explicitly.

The questions

ZF2 Patterns 103

• How can I be sure I have my dependencies?• You define them explicitly.• You retrieve the object via the container, which ensures the

definitions are used.

The questions

ZF2 Patterns 103



• Where do I define these?

The questions

ZF2 Patterns 103



• Where do I define these?• Either programmatically, via configuration, or using a tool.

The questions

ZF2 Patterns 103




• If I call $object = new Foo(), how do I forceusing different dependencies?

The questions

ZF2 Patterns 103




• If I call $object = new Foo(), how do I forceusing different dependencies?• Calling new doesn’t use the container. In fact, nothing forces you

to use one!

Why use one?

ZF2 Patterns 104

If instantiation of your object is not under yourdirect control (e.g. controllers), how do youretain control over your dependencies?

Why use one?

ZF2 Patterns 104

If instantiation of your object is not under yourdirect control (e.g. controllers), how do youretain control over your dependencies?• Different data access based on application

environment

Why use one?

ZF2 Patterns 104

If instantiation of your object is not under yourdirect control (e.g. controllers), how do youretain control over your dependencies?• Different data access based on application

environment• Substituting mock/stub implementations during

testing

ZF2 Approach

ZF2 Patterns 105

• Standardize on a Service Locator interface

ZF2 Approach

ZF2 Patterns 105

• Standardize on a Service Locator interface• Provide a performant DI solution, and integrate it into

a Service Locator

ZF2 Approach

ZF2 Patterns 105

• Standardize on a Service Locator interface• Provide a performant DI solution, and integrate it into

a Service Locator• Provide tooling to aid in creating DI definitions during

development

Service Locator interface

ZF2 Patterns 106

namespace Zend\Di;

interface ServiceLocation{

public function set($name, $service);public function get($name, array $params = null);

}

Dependency Injector interface

ZF2 Patterns 107

namespace Zend\Di;

interface DependencyInjection{

public function get($name, array $params = null);public function newInstance($name, array $params = null);public function setDefinitions($definitions);public function setDefinition(

DependencyDefinition $definition, $serviceName = null);public function setAlias($alias, $serviceName);public function getDefinitions();public function getAliases();

}

Definitions

ZF2 Patterns 108

namespace Zend\Di;

interface DependencyDefinition{

public function __construct($className);public function getClass();public function setConstructorCallback($callback);public function getConstructorCallback();public function hasConstructorCallback();public function setParam($name, $value);public function setParams(array $params);public function setParamMap(array $map);public function getParams();public function setShared($flag = true);public function isShared();public function addTag($tag);public function addTags(array $tags);public function getTags();public function hasTag($tag);public function addMethodCall($name, array $args);public function getMethodCalls();

}

References

ZF2 Patterns 109

namespace Zend\Di;

interface DependencyReference{

public function __construct($serviceName);public function getServiceName();

}

Class Definition

ZF2 Patterns 110

use Zend\Di\Definition,Zend\Di\Reference;

$mongo = new Definition(’Mongo’);

$mongoDB = new Definition(’MongoDB’);$mongoDB->setParam(’conn’, new Reference(’mongo’))

->setParam(’name’, ’test’);

$coll = new Definition(’MongoCollection’);$coll->setParam(’db’, new Reference(’mongodb’))

->setParam(’name’, ’resource’);

$di->setDefinitions(array(’mongo’ => $mongo,’mongodb’ => $mongoDB,’resource’ => $coll,

));

$resource = $di->get(’resource’);

Setter Injection

ZF2 Patterns 111

use Zend\Di\Definition,Zend\Di\Reference;

$service = new Definition(’mwop\Service\Resources’);$service->addMethod(’setResource’, array(

new Reference(’resource’)));

$di->setDefinition(’resources’, $service);

$resources = $di->get(’resources’);

Making it faster

ZF2 Patterns 112

• Specify constructor parameter maps in definitions

Making it faster

ZF2 Patterns 112

• Specify constructor parameter maps in definitions• Generate Service Locators from a DI container

Parameter maps

ZF2 Patterns 113

$mongoDB->setParam(’conn’, new Reference(’mongo’))->setParam(’name’, ’test’)->setParamMap(array(

’conn’ => 0,’name’ => 1,

));// Ensures parameters are in order, without needing// to resort to Reflection API.

Generating a Service Locator from DI

ZF2 Patterns 114

use Zend\Di\ContainerBuilder as DiBuilder;

$builder = new DiBuilder($injector);$builder->setContainerClass(’AppContext’);$container = $builder->getCodeGenerator(

__DIR__ . ’/../application/AppContext.php’); // Returns instance of Zend\CodeGenerator\Php\PhpFile$container->write(); // Write to disk

Example of a generated locator

ZF2 Patterns 115

use Zend\Di\DependencyInjectionContainer;class AppContext extends DependencyInjectionContainer{

public function get($name, array $params = array()){

switch ($name) {case ’request’:case ’Zend\Http\Request’:

return $this->getZendHttpRequest();default:

return parent::get($name, $params);}

}public function getZendHttpRequest(){

if (isset($this->services[’Zend\Http\Request’])) {return $this->services[’Zend\Http\Request’];

}$object = new \Zend\Http\Request();$this->services[’Zend\Http\Request’] = $object;return $object;

}}

Using a generated locator

ZF2 Patterns 116

$context = new AppContext();$request = $context->get(’request’);// Same as using a Service Locator or DI Container!

Making it simpler

ZF2 Patterns 117

• Use configuration files

Making it simpler

ZF2 Patterns 117

• Use configuration files• Can use any format supported by Zend\Config

Configuration (JSON)

ZF2 Patterns 118

{"production": { "definitions": [

{ "class": "Mongo" },{ "class": "MongoDB","params": {

"conn": {"__reference": "mongocxn"},"name": "mwoptest"

},"param_map": { "conn": 0, "name": 1 }

},{ "class": "MongoCollection","params": {

"db": {"__reference": "MongoDB"},"name": "entries"

},"param_map": { "db": 0, "name": 1 }

}], "aliases": {

"mongocxn": "Mongo","mongo-collection-entries": "MongoCollection"

}}

}

What are the use cases in ZF2?

ZF2 Patterns 119

One big one.

What are the use cases in ZF2?

ZF2 Patterns 119

One big one.

Pulling MVC controllersfrom the container

An Action Controller

ZF2 Patterns 120

namespace Blog\Controller;class Entry implements Dispatchable{

public function setResource(Resource $resource){

$this->resource = $resource;}

public function dispatch(Request $request, Response $response =null)

{/* ... */$entry = $this->resource->get($id);/* ... */

}}

The Front Controller

ZF2 Patterns 121

class FrontController implements Dispatchable{

public function __construct(DependencyInjection $di){

$this->di = $di;}

public function dispatch(Request $request, Response $response =null)

{/* ... */$controller = $this->di->get($controllerName);$result = $controller->dispatch($request, $response);/* ... */

}}

Benefits to using DI this way

ZF2 Patterns 122

• Performance


ZF2 Patterns 122

• Performance• Code de-coupling


ZF2 Patterns 122

• Performance• Code de-coupling• Simplification of controller code

More to come!

ZF2 Patterns 123

• First-run compilation

More to come!

ZF2 Patterns 123

• First-run compilation• Tools for scanning classes or namespaces to build

definitions

More to come!

ZF2 Patterns 123


definitions• Interface injection

More to come!

ZF2 Patterns 123


definitions• Interface injection• . . . and likely more.

MVC Patterns

The Problems

ZF2 Patterns 125

• How do controllers get dependencies?

The Problems

ZF2 Patterns 125

• How do controllers get dependencies?• How do we accommodate different controller

patterns?• What if we want to fine-tune action selection after routing, based

on other data in the request environment?

The Problems

ZF2 Patterns 125



on other data in the request environment?• What if we want to pass arguments to action names, or

prevalidate arguments?

The Problems

ZF2 Patterns 125




prevalidate arguments?• What if we don’t like the “Action” suffix in action methods?

The Problems

ZF2 Patterns 125




prevalidate arguments?• What if we don’t like the “Action” suffix in action methods?• What if . . . ?

• How can we better use server components withinthe MVC?

The Problems

ZF2 Patterns 125




prevalidate arguments?• What if we don’t like the “Action” suffix in action methods?• What if . . . ?

• How can we better use server components withinthe MVC?

• How can we make the MVC more performant?

ZF2 Patterns 126

The basic structure of a webapplication is that of a

Request/Response lifecycle

The Dispatchable Interface

ZF2 Patterns 127

namespace Zend\Stdlib;

interface Dispatchable{

public function dispatch(Request $request, Response $response = null

);}

Request and Response

ZF2 Patterns 128

• Both the Request and Response simply aggregatemetadata and content


ZF2 Patterns 128


• The Response also has the ability to send itself


ZF2 Patterns 128


• The Response also has the ability to send itself• HTTP-specific variants will be the core of the MVC

• To provide convenience around superglobals, cookies, andcommon tasks such as determining Accept and Content-Typeheaders

Anything dispatchable can attach to the MVC

ZF2 Patterns 129

Dispatchable is simply a formalization ofthe Command pattern


ZF2 Patterns 129

Dispatchable is simply a formalization ofthe Command pattern• Controllers


ZF2 Patterns 129

Dispatchable is simply a formalization ofthe Command pattern• Controllers• Servers


ZF2 Patterns 129

Dispatchable is simply a formalization ofthe Command pattern• Controllers• Servers• Whatever you may dream of! Just implement

Dispatchable!

Simple Front Controller Prototype

ZF2 Patterns 130

public function dispatch(Request $request, Response $response = null){

$params = compact(’request’, ’response’);$this->events()->trigger(__FUNCTION__ . ’.route.pre’, $this,

$params);$result = $this->getRouter()->route($request);if (!$result) {

$result = array(’controller’ => ’page’, ’page’ => 404);}$params[’routing’] = (object) $result;$this->events()->trigger(__FUNCTION__ . ’.route.post’, $params);

$controller = $this->di->get($params[’routing’]->controller);if (!$controller instanceof Dispatchable) {

$controller = new NotFoundController();}$result = $controller->dispatch($request, $response);$params[’__RESULT__’] = $result;$this->events()->trigger(__FUNCTION__ . ’.dispatch.post’,

$params);

return $response;}

Getting Involved

Contribute to ZF2!

ZF2 Patterns 133

• ZF2 wiki:http://bit.ly/zf2wiki

• zf-contributors mailing list:[email protected]

• IRC:#zftalk.dev on Freenode

http://bit.ly/zf2wiki

ZF2 Git Repository

ZF2 Patterns 134

• Git guide:http://bit.ly/zf2gitguide

• GitHub:http://github.com/zendframework/zf2

• Official repo:git://git.zendframework.com/zf.githttp://git.zendframework.com/

• You still need to sign a CLA!

http://bit.ly/zf2gitguide

http://github.com/zendframework/zf2

http://git.zendframework.com/

References

ZF2 Patterns 135

• ZF2 Dependency Injection Proposalhttp://bit.ly/zf2diproposalhttp://bit.ly/zf2diprototype

• ZF2 DI/MVC prototype sandboxhttp://bit.ly/zf2sandbox(mobile-layout branch is latest)

http://bit.ly/zf2diproposal

http://bit.ly/zf2diprototype

http://bit.ly/zf2sandbox

Thank You!

ZF2 Patterns 136

• Feedback:http://joind.in/3339

• Twitter:http://twitter.com/weierophinney

• Zend Framework:http://framework.zend.com/

http://joind.in/3339

http://twitter.com/weierophinney

http://framework.zend.com/

Zend Framework 2.0 Patterns Tutorial

Technology

Transcript of Zend Framework 2.0 Patterns Tutorial