Zend Framework 2 quick start

Zend Framework 2
quick start
by Enrico Zimuel (enrico@zend.com)

Senior Software Engineer
Zend Framework Core Team
Zend Technologies Ltd

ZFConf – 21th April 2012 Moscow
© All rights reserved. Zend Technologies, Inc.

About me

• Enrico Zimuel (@ezimuel)
• Software Engineer since 1996
– Assembly x86, C/C++, Java, Perl, PHP
• Enjoying PHP since 1999
• PHP Engineer at Zend since 2008
• Zend Framework Core Team from
2011
• B.Sc. Computer Science and
Economics from University of
Pescara (Italy)


Summary

● Overview of ZF2
● The new autoloading system
● Dependency Injection
● Event manager
● The new MVC
● Quick start: ZendSkeletonApplication
● Package system
● From ZF1 to ZF2


ZF2 key features

● New architecture (MVC, Di, Events)
● Requirement: PHP 5.3
● No more CLA (Contributor License Agreement)
● Git (GitHub) instead of SVN
● Better performance
● Module management
● Packaging system


A new core

● The ZF1 way:
▶ Singleton, Registry, and
Hard-Coded Dependencies
● The ZF2 approach:
▶ Aspect Oriented Design
and Dependency Injection


New architectural approach

● Methodologies used in the development
– Decoupling (ZendDi)
– Event driven (ZendEventManager)
– Standard classes (ZendStdlib)
● Take advantage of PHP 5.3
▶ Namespace
▶ Lambda Functions and Closures
▶ Better performance


Autoloading


Autoloading

● No more require_once calls!
● Multiple approaches:
– ZF1-style include_path autoloader
– Per-namespace/prefix autoloading
– Class-map autoloading


Classmap generator

● How to generate the .classmap.php?
We provided a command line tool:
bin/classmap_generator.php
● Usage is trivial:

$ cd your/library
$ php /path/to/classmap_generator.php -w

● Class-Map will be created in .classmap.php


Performance improvement

● Class-Maps show a 25% improvement on the
ZF1 autoloader when no acceleration is
present
▶ 60-85% improvements when an opcode cache
is in place!

● Pairing namespaces/prefixes with specific
paths shows >10% gains with no
acceleration
▶ 40% improvements when an opcode cache is in
place!

Note: The new autoloading system of ZF2 has been ported to ZF 1.12


Dependency
Injection


Dependency injection

● How to manage dependencies between
objects?
● Dependency injection (Di) is
a design pattern whose
purpose is to reduce the
coupling between software
components

It's time for your dependency injection!


Di by construct

Without Di With Di (construct)

class Foo { class Foo {
protected $bar; protected $bar;
… …
public function __construct() { public function
$this->bar= new Bar(); __construct(Bar $bar) {
} $this->bar = $bar;
… }
} …
}

Cons: Pros:
Difficult to test Easy to test
No isolation Decoupling
Difficult to reuse code Flexible architecture

Di by setter

class Foo
{
protected $bar;
…
public function setBar(Bar $bar)
{
$this->bar = $bar;
}
…
}


ZendDi

● Supports the 3 different injection patterns:
– Constructor
– Interface
– Setter
● Implements a Di Container:
– Manage the dependencies using configuration
and annotation
– Provide a compiler to autodiscover classes in a
path and create the class definitions, for
dependencies


Sample definition

$definition = array(
'Foo' => array(
'setBar' => array(
'bar' => array(
'type' => 'Bar',
'required' => true,
),
),
),
);


Using the Di container

use ZendDiDi,
ZendDiConfiguration;

$di = new Di;
$config = new Configuration(array(
'definition' => array('class' => $definition)
));
$config->configure($di);

$foo = $di->get('Foo'); // contains Bar!


Di by annotation

namespace Example {
use ZendDiDefinitionAnnotation as Di;

class Foo {
public $bam;
/**
* @DiInject()
*/
public function setBar(Bar $bar){
$this->bar = $bar;
}
}

class Bar {
}
}


Di by annotation (2)

$compiler = new ZendDiDefinitionCompilerDefinition();
$compiler->addDirectory('File path of Foo and Bar');
$compiler->compile();

$definitions = new ZendDiDefinitionList($compiler);
$di = new ZendDiDi($definitions);

$baz = $di->get('ExampleFoo'); // contains Bar!

More use cases of ZendDi:
https://github.com/ralphschindler/zf2-di-use-cases


Event Manager


Event Manager

● An Event Manager is an object that
aggregates listeners for one or more
named events, and which triggers events.
● A Listener is a callback that can react to
an event.
● An Event is an action.


Example

use ZendEventManagerEventManager;

$events = new EventManager();
$events->attach('do', function($e) {
$event = $e->getName();
$params = $e->getParams();
printf(
'Handled event “%s”, with parameters %s',
$event,
json_encode($params)
);
});
$params = array('foo' => 'bar', 'baz' => 'bat');
$events->trigger('do', null, $params);


MVC


Event driven architecture

● Flow: bootstrap, route, dispatch, response
● Everything is an event in MVC of ZF2


Modules

● The basic unit in a ZF2 MVC application is a Module
● A module is a collection of code and other files that
solves a more specific atomic problem of the larger
business problem
● Modules are simply:
▶ A namespace
▶ Containing a single classfile, Module.php


Quick start
ZendSkeletonApplication


ZendSkeletonApplication

● A simple, skeleton application using the ZF2
MVC layer and module systems
● On GitHub:
▶ git clone --recursive
git://github.com/zendframework/ZendSkeletonApplication.git
● This project makes use of Git submodules
● Works using ZF2.0.0beta3


Folder tree
config autoload
application.config.php
data

module Application
config
vendor
src
public Application

css Controller
IndexController.php
images
view
js
Module.php
.htaccess autoload_classmap.php
index.php autoload_function.php
autoload_register.php


Output


index.php

chdir(dirname(__DIR__));
require_once (getenv('ZF2_PATH') ?:
'vendor/ZendFramework/library') .
'/Zend/Loader/AutoloaderFactory.php';
ZendLoaderAutoloaderFactory::factory();

$appConfig = include 'config/application.config.php';

$listenerOptions = new ZendModuleListenerListenerOptions(
$appConfig['module_listener_options']);
$defaultListeners = new
ZendModuleListenerDefaultListenerAggregate($listenerOptions);
$defaultListeners->getConfigListener()
->addConfigGlobPath("config/autoload/{,*.}
{global,local}.config.php");
...


index.php (2)

...
$moduleManager = new ZendModuleManager($appConfig['modules']);
$moduleManager->events()->attachAggregate($defaultListeners);
$moduleManager->loadModules();

// Create application, bootstrap, and run
$bootstrap = new ZendMvcBootstrap(
$defaultListeners->getConfigListener()->getMergedConfig());
$application = new ZendMvcApplication;
$bootstrap->bootstrap($application);
$application->run()->send();


config/application.config.php

return array(
'modules' => array(
'Application'
),
'module_listener_options' => array(
'config_cache_enabled' => false,
'cache_dir' => 'data/cache',
'module_paths' => array(
'./module',
'./vendor',
),
),
);


config/autoload

● global.config.php
● local.config.php.dist (.gitignore)
● By default, this application is configured to load all
configs in:
./config/autoload/{,*.}{global,local}.config.php.
● Doing this provides a location for a developer to drop in
configuration override files provided by modules, as
well as cleanly provide individual, application-wide
config files for things like database connections, etc.


Application/config/module.config.php

return array(
'di' => array(
'instance' => array(
…
)
)
);

Here you configure the components
of your application (i.e. routing,
controller, view)


IndexController.php

namespace ApplicationController;

use ZendMvcControllerActionController,
ZendViewModelViewModel;

class IndexController extends ActionController
{
public function indexAction()
{
return new ViewModel();
}
}


Modules are “plug and play”

● Easy to reuse a module, only 3 steps:
1) Copy the module in module (or vendor) folder
2) Enable the module in your application.config.php
▶ Add the name of the module in “modules”
3) Copy the config file of the module in
/config/autoload/module.<module's name>.config.php


modules.zendframework.com


Package system


Package system
● We use Pyrus, a tool to manage PEAR
packages. Pyrus simplifies and improves the
PEAR experience.
● Source packages (download + github):
▶ http://packages.zendframework.com/
● Install and configure pyrus:
▶ wget http://packages.zendframework.com/pyrus.phar
▶ pyrus.phar .
▶ pyrus.phar . channel-discover packages.zendframework.com

● Install a Zend_<component>:
▶ pyrus.phar . install zf2/Zend_<component>


From ZF1 to ZF2


Migrate to ZF2

● Goal: migrate without rewriting much code!
● Main steps
– Namespace: Zend_Foo => ZendFoo
– Exceptions: an Interface for each
components, no more Zend_Exception
– Autoloading: 3 possible options (one is
ZF1)
▶ MVC: module, event based, dispatchable


ZF1 migration prototype

● Source code: http://bit.ly/pvc0X1
● Creates a "Zf1Compat" version of the ZF1
dispatcher as an event listener.
● The bootstrap largely mimics how ZF1's
Zend_Application bootstrap works.
● The default route utilizes the new ZF2 MVC
routing, but mimics what ZF1 provided.


Helping out

● http://framework.zend.com/zf2
● http://github.com/zendframework
● https://github.com/zendframework/ZendSkeletonApplication
● Getting Started with Zend Framework 2 by Rob
Allen, http://www.akrabat.com
● Weekly IRC meetings (#zf2-meeting on Freenode)
● #zftalk.2 on Freenode IRC


Questions?


Thank you!

● Comments and feedbacks:
– Email: enrico@zend.com
– Twitter: @ezimuel


Zend Framework 2 quick start

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Zend Framework 2 quick start

Similar to Zend Framework 2 quick start (20)

More from Enrico Zimuel

More from Enrico Zimuel (20)

Recently uploaded

Recently uploaded (20)

Zend Framework 2 quick start