Module Manager di Zend Framework 2 adalah cara yang ampuh untuk membuat kode program yang re-usable yang dapat digunakan kembali di project yang lain dengan mudah.

Di Zend Framework 2, Module adalah sebuah group dari kode program yang biasanya ditujukan untuk menghandle bagian tertentu dari sebuah aplikasi. Module ini bisa berisi Service, Konfigurasi, Controller dan View Script. Karena Module ini bisa berisi konfigurasi, maka Module juga bisa digunakan untuk membuat Route, memuat Service ke dalam Service Manager dan memasang Listener untuk sebuah Event.

Module Manager

Module Manager adalah salah satu komponen yang sangat penting dalam Zend Framework 2 yang berfungsi untuk memuat Module yang sudah didaftarkan, dan men-trigger event - event yang ada di dalam Module . Seringnya developer tidak menggunakan Module Manager ini secara langsung. Untuk itu di sini saya membahas bagaimana sebenarnya sebuah Module bisa dimuat pada Zend Framework 2.

Zend\ModuleManager\ModuleManager adalah implementasi dari Zend\ModuleManager\Interface yang bertanggung jawab untuk memuat module dan membuat Namespace dari Module tersebut bisa digunakan di dalam aplikasi. Module Manager menggunakan array sebagai konfigurasi, yang kemudian dijadikan parameter untuk Constructor. Konfigurasi bisa berisi daftar Module yang akan dimuat, lokasi dari Module, dan lokasi dari konfigurasi file Autoload.

$moduleManager = new ModuleManager([     'modules' => [          'Application',          'Blog',          'Catalog',          'Cart',          'Checkout',     ],     'module_listener_options' => [          'module_paths' => [               'config/autoload/{,*.}{global,local}.php',          ]

    ] ]); $moduleManager->loadModules();

Atau biasanya dibuat sebagai konfigurasi di file config/application.config.php yang akan dimasukkan ke dalam Module Manager sewaktu instansiasi.

Class Module.php

Syarat minimal dari sebuah Module di Zend Framework 2 adalah harus memiliki sebuah file yang diberi nama Module.php. Module.php ini adalah Class yang sangat simpel yang hanya cukup diberi nama Module yang diletakkan di dalam Namespace Module tersebut. Di dalamnya kita bisa membuat array yang mendefenisikan konfigurasi dari module (method getConfig()) dan lokasi dari Class yang digunakan sebagai Autoloaded pada Module ini (method getAutoloaderConfig()).

Dan ketika module dimuat maka yang pertama kali dipanggil adalah method onBootstrap(). Ini merupakan method yang cukup ampuh dan kita bisa menggunakannya untuk memasang Listener dari Event. Ataupun mendefenisikan Routing yang baru dan menambahkan kode yang akan diproses pada setiap request.

Sedangkan method init() dipanggil sebelum Module di-bootstrap, dan bisa digunakan untuk membuat konfigurasi yang dibutuhkan Module tersebut sewaktu proses Bootstrap.

<?php namespace Order;

class Module { }

Zend Framework 2 menyediakan beberapa Interface yang bisa digunakan oleh Class Module yang di dalamnya tersedia fitur - fitur yang bisa digunakan oleh Module tersebut. Interface tersebut mendeskripsikan method - method yang diimplementasikan, walaupun begitu Interface tersebut tidak perlu sepenuhnya diimplementasikan (cukup menuliskan nama Method saja).

Penggabungan Konfigurasi

Konfigurasi dapat diletakkan di beberapa tempat, namun semua konfigurasi itu digabunggakn secara rekursif ke dalam sebuah konfigurasi oleh Zend\Stdlib\ArrayUtils::merge(). Karena konfigurasi digabungkan secara rekursif, urutan penggabungan konfigurasi tersebut harus dipahami untuk menghindari overwriting yang tidak diinginkan.

Konfigurasi digabungkan dengan urutan berikut ini.

Array yang dikembalikan oleh method getConfig() yang ada pada Class Module

config/autoload/global.*.php File Autoload Global

config/autoload/local.*.php  File Autoload Lokal

Method - method yang dideskripsikan di dalam Interface yang sudah disediakan get*Config()

Ketika point A - C selesai, maka konfigurasi gabungan yang belum sempurna ini dapat di-cache oleh Module Manager. Jadi, jika ingin menggunakan konfigurasi menggunakan Closure, seharusnya diletakkan di method - method (point D) konfigurasi kustom, bukan di method getConfig() (point A).

Event di Dalam Module

Agar membuat Module se-fleksibel mungkin, ModuleManager men-trigger sejumlah Event selama proses memuat Module. Pada awalnya, event loadModules di-trigger, kemudian event - event lainnya. Sejumlah event tersebut di-trigger setiap Module dimuat. Adapun urutan dari event - event tersebut

loadModules             (ModuleEvent::EVENT_LOAD_MODULES)

loadModule.resolve (ModuleEvent::EVENT_LOAD_MODULE_RESOLVE)

loadModule               (ModuleEvent::EVENT_LOAD_MODULE)

mergeConfig             (ModuleEvent::EVENT_MERGE_CONFIG)

loadModules.post     (ModuleEvent::EVENT_LOAD_MODULES_POST)

Untuk lebih detail dari tujuan event - event tersebut di atas, bisa melihat dokumentasi Zend Framework di sini 

Referensi:

Zend Framework 2 Certification Study Guide

I hoped to add Doctrine to my Zend Framework 2 project.

One crucial oversight I ran into was that the module's config file (config/module.config.php) needs to have 'namespace ____' before returning an array if you want to use the abstract doctrine settings below:

'doctrine' => array(

'driver' => array(

__NAMESPACE__ . '_entity' => array(

'class' => 'Doctrine\ORM\Mapping\Driver\AnnotationDriver',

'cache' => 'array',

'paths' => array(__DIR__ . '/../src/' . __NAMESPACE__ . '/Entity')

),

'orm_default' => array(

'drivers' => array(

__NAMESPACE__ . '\Entity' => __NAMESPACE__ . '_entity'

)

)

),

),

Aside from that, I also needed to add

'enable_default_entities' => false,

to the zfcuser.global.php config file located in the project root's config/autoload folder. Aside from that, a typical entity looks like

In ZF1 I would generally include 3rd party API wrappers (Facebook, MailChimp, Google, etc) in Bootstrap.php using something like:

protected function _initIncludes(){ include_once( 'MobileDetect/Mobile-Detect-2.php' ); include_once( 'Facebook/php-sdk-v3.1.1-27/src/facebook.php' ); include_once( 'Google/google-api-php-client-0.5.0/src/apiClient.php' ); include_once( 'MailChimp/MCAPI-1.3.class.php' ); } //_initIncludes

However there isn't really anywhere appropriate to 'include' things this way in ZF2. Ideally we want to include the 3rd party class in the (/all) module(s) that actually use it, but without trying to include it more than once.

The best way I've found of doing this is to add the 3rd party class into Zend's Class Map Autoloader like this:

public function getAutoloaderConfig() { return array( 'Zend\Loader\ClassMapAutoloader' => array( __DIR__ . '/autoload_classmap.php', array( 'Facebook' => 'vendor/facebook/php-sdk/src/facebook.php', ), ), 'Zend\Loader\StandardAutoloader' => array( 'namespaces' => array( __NAMESPACE__ => __DIR__ . '/src/' . __NAMESPACE__, ), ), ); }

This shows how I'm including the 'Facebook' class. Remember that ZF2 chdir()'s to the application's root directory, so the path is relative to that. I can then just create a Facebook instance with:

$facebook = new \Facebook(array( 'appId' => 'xxx', 'secret' => 'xxx', ));

Adding things via this method has a few advantages:

The class is included lazily.

The same entry can be included in multiple modules without there being a risk of conflict.

This wasn't initially obvious to me, but when creating a generic module to use across multiple ZF2 projects (thus putting it in /vendor) you can include a Module.php file in the root of the module's directory to make registering the namespace with Zend's StandardAutoloader simple. (I had assumed this was just how it worked under the /module directory).

So for example - I have a module with the namespace 'Nas', so I store it under: /zf2/vendor/Nas

And then I have Module.php here: /zf2/vendor/Nas/Module.php containing...

namespace Nas; class Module { public function getAutoloaderConfig() { return array( 'Zend\Loader\StandardAutoloader' => array( 'namespaces' => array( __NAMESPACE__ => __DIR__, ), ), ); } }

Finally I needed to add the module into /zf2/config/application.config.php:

'modules' => array( 'Application', 'Album', 'Nas', ),

As you probably know, Zend Framework 2 basically forces you to use a module structure. This is fine, but for small projects it seems overkill and I'd rather just use a single - more ZF1 like - module that contains my whole application. This is actually quite easy to do. If you base your application on Zend's ZendSkeletonApplication, then you can build everything under the included 'Application' module. The only thing I changed was the router so that it acted as per the default router in ZF1. i.e. /:controller/:action

To do this you just need to amend the 'router' entry in Application/config/module.config.php so that it read as follows:

'router' => array( 'routes' => array( 'home' => array( 'type' => 'Segment', 'options' => array( 'route' => '/[:controller[/:action]]', 'constraints' => array( 'controller' => '[a-zA-Z][a-zA-Z0-9_-]*', 'action' => '[a-zA-Z][a-zA-Z0-9_-]*', ), 'defaults' => array( '__NAMESPACE__' => 'Application\Controller', 'controller' => 'Index', 'action' => 'index', ), ), ), ), ),

I just finished adapting my old Zend Model Creator for Zend Framework 2. We're using it at Coursio for quick prototyping - and it's a good base to start with if you just want to get things done.

If you have any feedback, create an issue at github.