Zf2 phpquebec

ZF2 Modules and Services (And DI)
Maurice Kherlakian
Zend Technologies

© All rights reserved. Zend Technologies, Inc.

Who am I?
• Zend Professional Services consultant
• Worked with PHP for about 10 years
• Based in Montreal

Linkedin: http://ca.linkedin.com/in/mkherlakian
Twitter: http://twitter.com/mkherlakian
Email: maurice.k@zend.com

2 Zend Professional Services © All rights reserved. Zend Technologies, Inc.

ZF2 Modules – What are they?

• Discrete blocks of code
• Allow for code re-use (not only within ZF2 but with other
frameworks – Sf2 anyone?)
• Physically a namespaced directory
• If written well, distributable and re-usable
• Examples:
 User module (authentication – login/logout…)

 ACL module

 Blog module


Why are they better than ZF1’s modules

• ZF1 modules had serious problems
• Tightly coupled with MVC
• Could not be easily reused
• Bootstrapping expensive
• Not self-contained
• No dependency management

ZF2 addresses all of these problems


Requirements for a module – Module class
• A namespaced class called Module

<?php

namespace Mymod;
class Module {}

• That’s it!


Requirements for a module – Directory
structure
• There is, of course, a recommended directory structure


Requirements for a module - Registration
• In order for the application (Zend/Application) to run your module, it has
to be registered
<?php //application.config.php

return array(
'modules' => array( //Which modules are we loading?
'Application',
'Mymod',
),
'module_listener_options' => array(
'config_glob_paths' => array(
'config/autoload/{,*.}{global,local}.php',
),
'config_cache_enabled' => false,
'cache_dir' => 'data/cache',
'module_paths' => array( //What paths are we loading modules from?
'./module', //We will look for a Module.php file in subdirs
'./vendor', //one level down from this dir *by default*
),
),
'service_manager' => array( //More on that later
'use_defaults' => true,
'factories' => array(
),
),
);


Optional for a module – getConfig()
• Called automatically to get the module’s configuration and aggregate it
with the other modules
• Best is to include a config file that returns a php array (best practice in
ZF2 in general)
<?php
namespace Mymod;

use ZendModuleManagerModuleManager,
ZendMvcMvcEvent;

class Module {
public function getConfig() {
return include(__DIR__.'/config/module.config.php');
}
}


Optional for a module – init()
• A module can have an init() method that fires upon initialization
• The ModuleManager is passed to the init function as an argument
<?php
namespace Mymod;

ZendMvcMvcEvent;

class Module {
public function init(ModuleManager $e) {
$e->events()->attach(
'loadModules.post',
function($e) {
echo 'postLoad from MyMod';
},
100);
$e->events()->getSharedManager()->attach(
__NAMESPACE__,
'dispatch',
function($e) {
echo "Only if dispatched to Mymod";
},
100);
}
}


Optional for a module – onBootstrap()
• And if init() is too early, ModuleManager automatically registers the
onBootstrap method if found in the module
• An MvcEvent is passed as the argument
<?php
namespace Mymod;

ZendMvcMvcEvent;

class Module {
public function onBootstrap(MvcEvent $e) {
$request = $e->getRequest();
}
}


Optional for a module – Dep solving
• Thru getProvides() and getDependencies()
• Off by default, can be turned on
<?php

namespace Blog;
class Module {
public function getProvides()
{
return array(
'name' => 'Blog',
'version' => '0.1.0',
);
}

public function getDependencies()
{
return array(
'php' => array(
'required' => true,
'version' => '>=5.3.1',
),
'ext/mongo' => array(
'required' => true,
'version' => '>=1.2.0',
),
);
}
}


ModuleManager

• It’s automatically instantiated in your ZendApplication
• It fulfills 3 functions:
 Aggregates enabled modules (allows you to iterate over them)

 Aggregates the configuration from each module

 Triggers the module initialization

• There are many events for which the ModuleManager is
passed as an argument
• This allows you to provide listeners at practically any point
in the code to get access to the manager


An MVC module
• In most cases that’s what you will want
<?php //module.config.php
return array(
'router' => array(
'routes' => array(
'Mymod' => array(
'type' => 'ZendMvcRouterHttpLiteral',
'options' => array(
'route' => '/mymod',
'defaults' => array(
'controller' => 'mymod',
'action' => 'index',
),
),
),
),
),
'controller' => array(
'classes' => array(
'mymod' => 'MymodControllerIndexController',
),
),
'view_manager' => array(
'template_path_stack' => array(
__DIR__ . '/../view',
),
),
);


The missing link - bootstrapping – index.php
<?php // /public/index.php

require_once 'Loader/StandardAutoloader.php';
use ZendLoaderStandardAutoloader,
ZendServiceManagerServiceManager,
ZendMvcServiceServiceManagerConfiguration;

$loader = new StandardAutoloader();
$loader->registerNamespace('Application', 'module/Application/src/Application');
$loader->registerNamespace('Mymod', 'module/Mymod/src/Application');

spl_autoload_register(array($loader, 'autoload'));

// Get application stack configuration
chdir(dirname(__DIR__));
$configuration = include 'config/application.config.php';

// Setup service manager
$serviceManager = new ServiceManager(new ServiceManagerConfiguration($configuration['service_manager']));
$serviceManager->setService('ApplicationConfiguration', $configuration);
$serviceManager->get('ModuleManager')->loadModules();

// Run application
$serviceManager->get('Application')->bootstrap()->run()->send();


The missing link - bootstrapping – index.php
• Autoloading – it is the responsibility of index.php to set up autoloading
• This is because modules have to be portable between different
frameworks (reusability)
• Any PSR-0 autoloader should work, it does not have to be ZF2’s
autoloader
 For example Rob Allen’s Skeleton module uses Composer’s autoloader

• The next lines are the ServiceManager’s setup (more on it later)


Modules distribution
• Any source you can think of
 Pyrus

 Git

 Http

 Tar & send

 Composer

• There is already a ZF2 modules site
http://modules.zendframework.com/
(We need help! Want to contribute?)


Modules packaging

• Tar/Zip
• Phar (being careful that writes occur in location external to
the archive)


Location, location, location
DI - short summary
• Since the presentation was originally about ZendDi it’s only fair that we
talk about it!
• DI is the practice of reducing coupling between classes by injecting
dependent classes in the subject instead of instantiating them

<?php //No DI
class DbAdapter {
public function __construct($host, $user, $pass, $db) {
//...
}
}

class Author {
protected $_db;

$this->_db = new DbAdapter($host, $user, $pass, $db);
}
}


DI - short summary
<?php //DI
class DbAdapter {
//...
}
}

class Author {
protected $_db;

public function __construct($db) {
$this->_db = $db;
}
}

$db = new DbAdapter();
$author = new Author($db);

• That’s all it is – Really! Makes it easy to substitute the DB class for mocking, or to change it all
together for instance, and promotes decoupling and reusability. The D in SOLID.


DI - short summary
• Consider the case that an Author needs a DbGateway, which needs a DbAdapter, and a logging
and caching class

<?php

$db = new DbAdapter();
$gateway = new DbGateway($db);
$cache = new Cache();
$log = new Log();

$author = new Author($db, $gateway, $cache, $log);
$authors = $author->fetchAll();

• 5 lines of code for initialization, but only one line for what we really need to do. Lots of
boilerplate code
• Enter Dependency Injection Containers, or DiC – ZendDi is one of them, so is the Symfony
DiC, and a number of others


DiC – ZendDiDi()
<?php

$config = array(
'instance' => array(
'Author' => array(
'parameters' => array(
'gateway' => 'DbGateway',
'cache' => 'Cache',
'log' => 'Log'
)
),
'DbGateway' => array(
'db' => 'DbAdapter',
)
),
'DbAdapter' => array(
'host' => 'somehost',
'user' => 'someuser',
'pass' => 'somepass',
'db' => ‘somedb'
)
),
'Cache' => array(
),
'Log' => array(
)
)
);

$di = new ZendDiDi();
$di->configure(new ZendDiConfiguration($config));

$author = $di->get('Author');


DiC – ZendDiDi()
• The last line on the previous slide:
$author = $di->get('Author');
Returns a fully configured Author object, following the definition we provided
• DiC does instantiation and auto-wiring
• ZendDi, although difficult to show here, is a complex solution for complex
problems – it can easily be abused
• For simpler problems, and more in line with the PHP philosophy, ServiceManager
replaced it


Location v/s Injection
• Service manager is a ServiceLocator !== DiC
• BUT DiC === Service Locator
• One main difference is that the subject requiring the dependencies is:
 Not aware of the DiC when using DI (the dependency is injected)

 Is aware of the locator in the case of SL, and asks the locator to obtain the dependency

• ServiceManager is a service locator
Think back to index.php:
$serviceManager->get('ModuleManager')->loadModules();

• Martin Fowler is the subject matter expert on this:
http://martinfowler.com/articles/injection.html


ZendServiceManagerServiceManager()
• Service manager uses factories to generate its services
• Factory can be a class implementing ZendServiceManagerFactoryInterface or a
php closure


<?php
class ServiceConfiguration extends Configuration
{
public function configureServiceManager(ServiceManager $serviceManager)
{
$serviceManager->setFactory('author', function(ServiceManager $sm) {
$dbGateway = $sm->get('db_gateway');
$cache = $sm->get('cache');
$log = $sm->get('log');
return new Author($dbGateway, $cache, $log);
} );
$serviceManager->setShared('author', false);
$serviceManager->setFactory('db_gateway', function(ServiceManager $sm){
$dbAdapter = $sm->get('db_adapter');
return new DbGateway($dbAdapter);
} );
$serviceManager->setFactory('db_adapter', function(ServiceManager $sm) {
//Using hard-coded values for the example, but normally you would either create a factory
//and inject the values from a config file
//or get the configuration from the ServiceManager and read the valuees in
return new DbAdapter('somehost', 'someuser', 'somepass', 'somedb');
} );
$serviceManager->setFactory('cache', function(ServiceManager $sm) { return new Cache(); } );
$serviceManager->setFactory('log', function(ServiceManager $sm) { return new Log(); } );
}
}

$config = new ServiceConfiguration();
$sm = new ServiceManager();
$config->configureServiceManager($sm);

$author = $sm->get('author');


• The example above purposely uses closures to illustrate that a full-fledged
factory is not needed
• But in a lot of cases, implementing a factory makes sense - rewriting DbAdapter
from the above example as a factory:

<?php
use ZendServiceManagerFactoryInterface;

//The factory class
class AuthorFactory implements FactoryInterface {
public function createService(ZendServiceManagerServiceLocatorInterface $sl) {
$dbGateway = $sl->get('db_gateway');
$cache = $sl->get('cache');
$log = $sl->get('log');
}
}

//And the configuration class
{
{
//...
$serviceManager->setFactory('author', 'AuthorFactory');
//...
}
}


• The example above purposely uses closures to illustrate that a full-fledged
factory is not needed
• But in a lot of cases, implementing a factory makes sense - rewriting DbAdapter
form the above example as a factory:

<?php
use ZendServiceManagerFactoryInterface;

//The factory class
class AuthorFactory implements FactoryInterface {
public function createService(ZendServiceManagerServiceLocatorInterface $sl) {
$dbGateway = $sl->get('db_gateway');
$cache = $sl->get('cache');
$log = $sl->get('log');
}
}

//And the configuration class
{
{
//...
$serviceManager->setFactory('author', 'AuthorFactory');
//...
}
}


Setting and retrieving the locator
• In most MVC components (e.g.Controllers) the ServiceManager
component is composed automatically by the MVC stack
• The interface ZendServiceManagerServiceLocatorAwareInterface can
be implemented to ensure that a service locator is composed in the
subject class
• Two methods, SetServiceLocator(ServiceLocatorInterface $locator) and
getServiceLocator() must be implemented
• Notice that the Component is ServiceManager(), but the interface is
ServiceLocatorInterface. This is to allow you to provide an alternative
implementation of service locator.


Setting and retrieving the locator
• Controllers implement ServiceLocatorAwareInterface therefore

<?php

namespace MymodController;

use ZendMvcControllerActionController,
ZendViewModelViewModel;

class IndexController extends ActionController
{
public function indexAction()
{
$sl = $this->getServiceLocator();
$sl->get('author');
return new ViewModel();
}
}


Locating the injector or injecting the
locator?
• Although ServiceManager is now the goto dependency management
component in ZF2, Di actually still exists as a fallback (by default)
• One can specify a collection AbstractFactories to ServiceManager on
which it will fall back if it does not find the target class
• Therefore, ZendServiceManagerDiDiAbstractFactory is an abstract
factory to which the name of the object is passed if it is not found by
ServiceManager (the order can be changed)
• You can also, of course, provide your own service factory (Proxy class to
other frameworks maybe?)


Some references
• ZF2 module site: http://modules.zendframework.com/
• Rob Allen’s Skeleton:
https://github.com/zendframework/ZendSkeletonApplication
• Matthew’s discussion on Modules: http://mwop.net/blog/267-Getting-
started-writing-ZF2-modules.html
• Ralph on the decisions that drove to ServiceManager: http://zend-
framework-community.634137.n4.nabble.com/Services-Instances-
Dependencies-in-ZF2-td4584632.html
• SOLID OO design: http://en.wikipedia.org/wiki/SOLID_(object-
oriented_design)


• Download ZF2 and happy coding!
http://zendframework.com/zf2

Thank You!
http://twitter.com/mkherlakian


Zf2 phpquebec

More Related Content

What's hot

Viewers also liked

Similar to Zf2 phpquebec

Recently uploaded

Zf2 phpquebec