Zend Framework Foundations

ZEND FRAMEWORK
FOUNDATIONS
CHUCK REEVES
@MANCHUCK

Zend Framework Foundations, Chuck Reeves @manchuck PHP[world] 2015
WHAT WE WILL COVER
▸ Intro to Zend Framework 2
▸ Modules
▸ Service Locator
▸ Event Manager
▸ MVC
▸ Forms
▸ Database
▸ Logging
2INTRO TO ZEND FRAMEWORK 2

http://framework.zend.com/manual/current/en/index.html
https://github.com/manchuck/phpworld-zf2

BASICS

INTRO TO ZEND FRAMEWORK 2
▸ Release in Fall 2012
▸ Updated modules from Zend Framework 1
▸ Collection of Individual components
▸ PSR-0 Compliant
SOME BASICS
5

GETTING STARTED
▸ Using the skeleton app
cd my/project/dir 
git clone git://github.com/zendframework/ZendSkeletonApplication.git 
cd ZendSkeletonApplication 
php composer.phar install
▸ God Mode (aka Composer):
"require": { 
"zendframework/zendframework": "~2.5" 
}
6

FILE STRUCTURE
▸ config - stores global config options
▸ data - cache, logs, session files
▸ module - your custom modules
▸ public - HTML, CSS, JS, Images
▸ test - Integration tests and test bootstrap
INTRO TO ZEND FRAMEWORK 2 7

APPLICATION BASICS
▸ At its core, ZF2 applications have 6 dependancies:
1. ZendConfig - a Traversable object containing merged config
2. ZendServiceManager - A Service Locator for loading/creating objects
3. ZendEventManager - An Event dispatcher for controlling application flow
4. ZendModuleManager - Used for loading/finding configured modules
5. Request - Helper for managing the incoming request
6. Response - Helper for returning a response
8

MODULES

MODULES
FILE STRUCTURE
▸ config - holds the config(s)
▸ language - PO language files (or other I18N
translations)
▸ src - source code for the modules
▸ test - module specific tests
▸ view - view scripts and layout
▸ autoload_classmap - maps classes to files
▸ Module.php - bootstrap for the module
10

MODULES
BOOTSTRAPPING MODULES
‣ The ModuleManager brokers loading ﬁles using the EventManager
‣ Allows initializing 3rd party libraries
‣ Three methods for bootstrapping:
‣ init
‣ modulesLoaded
‣ onBootstrap
11

MODULES
THE ONLY THING A MODULE NEEDS
12
 
use ZendModuleManagerFeatureAutoloaderProviderInterface; 
use ZendModuleManagerFeatureConfigProviderInterface; 
 
class Module implements ConfigProviderInterface, AutoloaderProviderInterface 
{ 
public function getConfig() 
{ 
return include __DIR__ . '/config/module.config.php'; 
} 
public function getAutoloaderConfig() 
{ 
return array( 
'ZendLoaderClassMapAutoloader' => array( 
__DIR__ . '/autoload_classmap.php', 
), 
'ZendLoaderStandardAutoloader' => array( 
'namespaces' => array( 
__NAMESPACE__ => __DIR__ . '/src/' . __NAMESPACE__, 
), 
), 
); 
} 
}

SERVICE MANAGER

SERVICE MANAGER
DEPENDENCY INJECTION - FOR THOSE WHO DON'T KNOW
▸ Instead of creating all the objects needed by a class, you "inject" a created
object that the class knows how to interact with it
▸ Makes testing easier (you are writing tests correct?)
▸ Code changes are a breeze
▸ Reduces class coupling
14

SERVICE MANAGER
DEPENDENCY INJECTION - METHOD
class MapService { 
public function getLatLong( 
GoogleMaps $map, 
$street, 
$city,  
$state 
) { 
return $map->getLatLong($street . ' ' . $city . ' '
. $state); 
} 
}
15

SERVICE MANAGER
DEPENDENCY INJECTION - __CONSTRUCT
class MapService  
{ 
protected $map; 
public function __construct(GoogleMaps $map) { 
$this->$map = $map; 
} 
 
public function getLatLong($street, $city, $state ) { 
return $this->map->getLatLong($street . ' ' . $city .
' ' . $state); 
} 
}
16

SERVICE MANAGER
DEPENDENCY INJECTION - SETTERS
class MapService 
{ 
protected $map; 
public function setMap(GoogleMaps $map) { 
$this->$map = $map; 
} 
 
public function getMap() { 
return $this->map; 
} 
 
public function getLatLong($street, $city, $state ) { 
return $this->getMap()->getLatLong($street . ' ' . $city . ' ' . $state); 
} 
}
17

SERVICE MANAGER
WHAT IS A SERVICE LOCATOR
▸ Purpose - "To implement a loosely coupled architecture in order to get better
testable, maintainable and extendable code. DI pattern and Service Locator
pattern are an implementation of the Inverse of Control pattern." *
▸ Keeps DI Simple and clean
▸ Only has two methods: get() and has()
18
* https://github.com/domnikl/DesignPatternsPHP/tree/master/More/ServiceLocator

SERVICE MANAGER
WHAT IS IN THE SERVICE MANAGER
▸ Invokables - Objects that can just be called via "new <class_name>"
▸ Factories - a class that creates another (follows the factory pattern)
▸ Abstract Factories - Factories that create many objects using a conﬁg
▸ Initializers - Used to add additional dependancies after the object is created
(ex. adding logging to classes with out having a huge dependency list)
▸ Delegators - wrappers that adds more functionality to existing objects
▸ Aliases - simpler names for services
19

SERVICE MANAGER
REGISTERING SERVICES - CONFIG
'service_manager' => [ 
'abstract_factories' => [ 
'ZendLogLoggerAbstractServiceFactory', 
], 
'factories' => [ 
'MyModuleMyService' => 'MyModuleMyServiceFactory' 
], 
'invokables' => [ 
'FooBar' => 'stdClass' 
], 
'delgators' => [ 
'MyModuleMyService' => [ 
'MyModuleMyServiceDelegator' 
] 
], 
'alises' => [ 
'MyService' => 'MyModuleMyService' 
] 
]
20

SERVICE MANAGER
REGISTERING SERVICES - THE WRONG WAY!
'factories' => [ 
'MyModuleMyService' => function
($sm) { 
// do crazy things to build 
// this class and slow down
// your application
 
return $service; 
} 
],
21

SERVICE MANAGER
REGISTERING SERVICES - THE WRONG WAY!
▸ SERIOUSLY DON'T USE CLOSURES TO REGISTER SERVICES
▸ YOU MIGHT AS WELL USE TABS
▸ LIKE EVER
22

SERVICE MANAGER
REGISTERING SERVICES - CONCRETE OBJECT
use ZendServiceManagerServiceManager; 
 
$serviceManager = new ServiceManager(); 
 
//sets the created object instead of having the SM buildone 
$fooBar = new stdClass(); 
$serviceManager->setService('FooBar', $fooBar);
23

SERVICE MANAGER
REGISTERING SERVICES - IN CODE
use ZendServiceManagerServiceManager; 
 
$serviceManager = new ServiceManager(); 
 
$serviceManager->setFactory('MyModuleMyService', 'MyModuleMyServiceFactory');
 
$serviceManager->setInvokableClass('FooBar', 'stdClass'); 
$serviceManager->addAbstractFactory('ZendLogLoggerAbstractServiceFactory'); 
$serviceManager->addDelegator('MyModuleMyService', 'MyModuleMyServiceDelegator'); 
$serviceManager->setAlias('MyService', 'MyModuleMyService');
24

SERVICE MANAGER
FACTORIES
▸ Contains the code to build the object
▸ The ServiceManager is passed in to the create function
▸ can either implement ZendServiceManagerFactoryInterface or just implement
__invoke
25

SERVICE MANAGER
ABSTRACT FACTORIES
▸ Allows one factory that builds multiple objects based on a config
▸ Prevents writing multiple factories that do similar functions based on a config
▸ MUST Implement ZendServiceManagerAbstractFactoryInterface
▸ defines canCreateServiceWithName() and createServiceWithName()
26

SERVICE MANAGER
ABSTRACT FACTORIES
use ZendDbTableGatewayTableGateway; 
use ZendServiceManagerFactoryInterface; 
use ZendServiceManagerServiceLocatorInterface; 
 
class ProjectsTableFactory implements FactoryInterface { 
public function createService(ServiceLocatorInterface $serviceLocator) { 
$adapter = new $serviceLocator->get('ZendDbAdapterAdapter'); 
return new TableGateway('projects', $adapter); 
} 
} 
 
class CategoriesTableFactory implements FactoryInterface { 
public function createService(ServiceLocatorInterface $serviceLocator) { 
$adapter = new $serviceLocator->get('ZendDbAdapterAdapter'); 
return new TableGateway('categories', $adapter); 
} 
}
27

SERVICE MANAGER
ABSTRACT FACTORIES
use ZendDbTableGatewayTableGateway; 
use ZendServiceManagerAbstractFactoryInterface; 
use ZendServiceManagerServiceLocatorInterface; 
 
class TableAbstractFactory implements AbstractFactoryInterface { 
public function canCreateServiceWithName(ServiceLocatorInterface $sl, $name, $requestedName)
{ 
return preg_match("/Table$/", $requestedName); 
} 
 
public function createServiceWithName(ServiceLocatorInterface $sl, $name, $requestedName) { 
$adapter = $sl->get('ZendDbAdapterAdapter'); 
$tableName = str_replace('Table', '', $requestedName); 
$tableName = strtolower($tableName); 
 
return new TableGateway($tableName, $adapter); 
} 
}
28

SERVICE MANAGER
INITIALIZERS
▸ Applied to every object that the ServiceManager created
▸ Useful to inject other dependancies
▸ Do not over use them (50 Initializers with 300 objects means 15,000 calls)
29

SERVICE MANAGER
DELEGATORS
▸ Add functionality to a class
▸ Transfers process to another object based on conditions
▸ Technically ZF2 delegators are decorators
▸ https://en.wikipedia.org/wiki/Delegation_pattern
30

SERVICE MANAGER
DELEGATORS - HOW THEY WORK
▸ A delegator factory (MUST implement ZendServiceManager
DelegatorFactoryInterface)
▸ FactoryClass MUST BE registered as separate service in the ServiceManager
▸ Note: the delegator will not be passed through initializers
31

SERVICE MANAGER
OTHER SERVICE MANAGERS
▸ ZF2 builds other service managers that will be injected with the main service
manager
▸ ControllerManager, InputFilterManager, RouterPluginManager, and
FormElementManager are just some
32

EVENT MANAGER

EVENT MANAGER
EVENT MANAGER
▸ Aspect Oriented Programming (AOP)
▸ What it is useful for:
▸ Logging
▸ Caching
▸ Authorization
▸ Sanitizing
▸ Auditing
▸ Notifying the user when something happens (or fails)
34

EVENT MANAGER
ASPECT ORIENTED PROGRAMMING 101 - TERMS
▸ Aspect - The object being interacted
with
▸ Advice - What should be done with
each method of the aspect
▸ Joinpoint - Places where Advice can be
created
▸ Pointcut - Matches Joinpoint to an
Advice
35

EVENT MANAGER
ASPECT ORIENTED PROGRAMMING 101 - ADVICE TYPES
▸ Before advice - Applied before the advice is called
▸ After returning advice - Applied after the advice is called
▸ After throwing advice - Applied when an error happens
▸ Around advice - combines the Before and After returning advice*
36
http://www.sitepoint.com/explore-aspect-oriented-programming-with-codeigniter-1/

EVENT MANAGER
HOW IT WORKS IN ZF2
▸ Events chain until no more listeners are registered or a listener stops
propagation of events
▸ Listeners are called in order of priority. From the higher number to lower
number
▸ Responses from each listener is stored in a collection and returned back to the
calling code
37

EVENT MANAGER
REGISTERING EVENTS - CALLBACKS
use ZendEventManagerEventManager; 
use ZendEventManagerEvent; 
use ZendLogLogger; 
 
$log = new Logger(['writers' => [['name' => 'noop']]]); 
$events = new EventManager(); 
$events->attach('my_event', function (Event $event) use ($log) { 
$event = $event->getName(); 
$target = get_class($event->getTarget()); 
$params = json_encode($event->getParams()); 
 
$log->info(sprintf( 
'%s called on %s, using params %s', 
$event, 
$target, 
$params 
)); 
}); 
 
$target = new stdClass(); 
$params = ['foo' => 'bar']; 
$events->trigger('my_event', $target, $params);
38

EVENT MANAGER
REGISTERING EVENTS - AGGREGATE
class Listener implements ListenerAggregateInterface, LoggerAwareInterface 
{ 
use LoggerAwareTrait; 
 
protected $listeners = []; 
 
public function attach(EventManagerInterface $events) { 
$this->listeners[] = $events->attach('my_event', [$this, 'logEvent'], 1000); 
} 
 
public function detach(EventManagerInterface $events) { 
foreach ($this->listeners as $index => $callback) { 
if ($events->detach($callback)) { 
unset($this->listeners[$index]); 
} 
} 
} 
} 
 
$events->attach(new Listener());
39

EVENT MANAGER
REGISTERING EVENTS - OTHER
▸ Register a listener to multiple events using an array
$events->attach(['my_event_1', 'my_event_2'], [$this, 'logEvent']);
▸ Or using a wildcard
$events->attach('*', [$this, 'logEvent']);
40

EVENT MANAGER
SHARED EVENT MANAGER
▸ Segregates events from other classes that could interfere with the listeners
▸ JIT loading of listeners to keep the event manager lightweight
41

EVENT MANAGER
SHARED EVENT MANAGER - REGISTERING LISTENERS
public function setEventManager(EventManagerInterface
$eventManager) 
{ 
$eventManager->addIdentifiers(array( 
get_called_class() 
)); 
 
$this->eventManager = $eventManager; 
}
43

EVENT MANAGER
SHARED EVENT MANAGER - REGISTERING LISTENERS
public function onBootstrap(MvcEvent $event) 
{ 
$eventManager = $event->getApplication()-
>getEventManager(); 
$sharedEventManager = $eventManager->getSharedManager(); 
 
$sharedEventManager->attach('MyService', 'my_event',
function($e) { 
var_dump($e); 
}, 100); 
}
44

MVC

MVC
MODELS
▸ Nothing special they are just classes
46

MVC
MVC_EVENT
▸ Created during application bootstrap
▸ Provides helpers to access the Application, Request, Response, Router, and the
View. (all these are injected during the bootstrap event
47

MVC
MVC_EVENT - EVENTS
▸ MvcEvent::EVENT_BOOTSTRAP - Prepares the application
▸ MvcEvent::EVENT_ROUTE - Matches the request to a controller
▸ MvcEvent::EVENT_DISPATCH - Call the matched controller
▸ MvcEvent::EVENT_DISPATCH_ERROR - Error happens during dispatch
▸ MvcEvent::EVENT_RENDER - Prepares the data to be rendered
▸ MvcEvent::EVENT_RENDER_ERROR - Error during rendering
▸ MvcEvent::EVENT_FINISH - Finial task
48

MVC
ROUTING
▸ Provides a means to match a request to a controller
▸ Matching can be made on any part of the URL
▸ Three router types: ConsoleSimpleRouteStack, HttpSimpleRouterStack and
HttpTreeRouterStack
49

MVC
CONTROLLERS
▸ Controllers are dispatched from a Router
▸ A Controller just needs to implement ZendStdlibDispatchableInterface
▸ Other common interfaces for controllers:
▸ ZendMvcInjectApplicationEventInterface
▸ ZendServiceManagerServiceLocatorAwareInterface
▸ ZendEventManagerEventManagerAwareInterface
50

MVC
CONTROLLERS - DEFAULT
▸ ZendMvcControllerAbstractController
▸ ZendMvcControllerAbstractActionController
▸ ZendMvcControllerAbstractRestfulController
▸ ZendMvcControllerAbstractConsoleController
51

MVC
CONTROLLERS - PLUGINS
▸ Provides helper functions to controllers
▸ Default Plugins (More to come later)
▸ FlashMessenger
▸ Forward
▸ Params
▸ PostRedirectGet
▸ Redirect
▸ Url
52

MVC
CONTROLLER PLUGINS - CUSTOM PLUGINS IN 3 STEPS
▸ Create plugin
▸ Register in conﬁg
▸ Call in controller
53

MVC
VIEWS
▸ Views incorporate multiple levels to render a response
▸ By default uses the PHP template system (but can use your templating system
of choice)
▸ Layouts are also possible since ViewModels can be nested
▸ Your controllers do not need to return a ViewModel
54

MVC
VIEW - ONE VIEW MANY LAYERS
▸ Containers - holds variables and or callbacks (typically a model or the array
representation of the model)
▸ View Model - Connects the Container to a template (if applicable)
▸ Renders - Takes the Model and returns the representation of the model (Three are
included by default: PhpRenderer, JsonRenderer, FeedRenderer)
▸ Resolvers - Uses a strategy to resolve a template for the renderer
▸ Rendering Strategies - Decides which renderer to use
▸ Response Strategies - Handles setting the headers responses
55

MVC
VIEWS - HOW TO USE
▸ From controller:
$view = new ViewModel(array( 
'message' => 'Hello world', 
)); 
$view->setTemplate('my/template'); 
return $view;
▸ Or
return array( 
'message' => 'Hello world', 
);
56

MVC
VIEW - HELPERS
▸ Used with the PhpRenderer
▸ Handles common functions within a view
▸ Check out the manual for complete list visit: http://framework.zend.com/
manual/current/en/modules/zend.view.helpers.html
57

MVC
VIEW - CREATING CUSTOM HELPERS
▸ Have your helper implement ZendViewHelperHelperInterface
▸ or just extend ZendViewHelperAbstractHelper
▸ Register the helper
▸ in the conﬁg under 'view_helpers'
▸ in the module by implementing ZendModuleManagerFeature
ViewHelperProviderInterface
58

MVC
REQUEST AND RESPONSE
▸ Abstracts the HTTP (or console) Request and response
▸ Can also be used with the ZendHttp when you need to make CURL requests
▸ ViewModels can also understand the response based on different PHP
runtimes (console or web requests)
59

MVC
RESPONSE
use ZendHttpResponse;
$response = new Response(); 
$response->setStatusCode(Response::STATUS_CODE_200); 
$response->getHeaders()->addHeaders(array( 
'HeaderField1' => 'header-field-value', 
'HeaderField2' => 'header-field-value2', 
)); 
$response->setContent("Hello Word");
60

MVC
REQUEST
use ZendHttpRequest; 
 
$request = new Request(); 
$request->setMethod(Request::METHOD_POST); 
$request->setUri('/foo'); 
$request->getHeaders()->addHeaders(array( 
)); 
$request->getPost()->set('foo', 'bar');
61

MVC
ACCESSING FROM THE CONTROLLER
▸ God Mode:
$this->getEvent()->getRequest();
$this->getEvent()->getResponse();
▸ The easy way:
$this->getRequest();
$this->getResponse();
62

FORMS, VALIDATORS
AND INPUTFILTERS

FORMS, VALIDATORS AND INPUTFILTERS
FORMS
▸ Used to bridge Views to Models (epically useful when following DOM)
▸ Takes elements, ﬁlters and validators to ensure data integrity.
▸ Creates element objects just-in-time to help keep for classes light
64

INPUTFILTERS
▸ Filters and validates sets of data by using filters and validators
▸ Can be independent objects, specified in the config or built on the fly in code
▸ Passed by reference, keeps data from being munged elsewhere
65

FILTERS AND VALIDATORS
▸ Transform data (trim, uppercase, lowercase etc)
▸ Filters are applied before validation
▸ Multiple ﬁlters and validators can be applied for each ﬁeld
▸ Validators get passed the full data set to help validate
66

RENDERING FORMS
▸ View helpers for each ﬁled type
▸ or simply use the formElement view helper
▸ setting values to the form will display the value by the user
67

DATABASE

DATABASE
OVERVIEW
▸ ZendDb provides simple abstraction for working with RDBMS
▸ Can be used as an ORM
▸ Can use PDO or basic drivers
69

DATABASE
STATEMENTS
▸ Used to Programmatically create SQL statements
▸ Agnostic towards different systems
▸ Normalizes out queries (as best they can) to handle the differences between
RDBMS
▸ Returns Results Statements which can create your models using a hydrator
70

DATABASE
HYDRATORS
▸ Transform an object to an array
▸ Take and array and set those values on the
object (or hydrates an object)
▸ ArraySerializable
▸ ClassMethods
▸ Can also ﬁlter values before passing into the
object
71

DATABASE
TABLE/ROW GATEWAY
▸ Represents a row or table in the database
▸ Does all the heavy lifting for building a SQL query.
▸ A Must have when following the Active Record pattern
▸ Deﬁnition of the row and table is deﬁned using the ZendDbMetadata*
classes
72

LOGGING

LOGGING
BASICS
▸ Allows writing to multiple log locations
▸ Allows ﬁltering out log levels or text
▸ Can be used to log PHP errors and exceptions
▸ Complies with RFC-3164
▸ Not PSR-3 compliant! (but you can use this
module)
74

LOGGING
HOW IT WORKS
▸ ZendLogLogger is constructed with writers
▸ Writers can get formatters to format the message to your hearts desire
▸ Messages are normally written during shutdown
▸ Logger can also take a ﬁlter which messages are logged
▸ Log Level
▸ Regex
▸ Following a Filter or Validator
75

LOGGING
USING LOGS
$logger = new ZendLogLogger; 
$writer = new ZendLogWriterStream('php://output'); 
 
$logger->addWriter($writer); 
 
$logger->info('This is an info');
76

QUESTIONS?

THANK YOU
THANK YOU
▸ Documentation - http://framework.zend.com/manual/current/en/index.html
▸ Marco Pivetta Blogs - http://ocramius.github.io/
▸ Mathew Weier O'Phinney - https://mwop.net/
▸ Design Patterns in PHP - https://github.com/domnikl/DesignPatternsPHP
▸ Images: The internet
78

Zend Framework Foundations

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Zend Framework Foundations (20)

More from Chuck Reeves (9)

Recently uploaded (20)

Zend Framework Foundations