Resource Autoloaders

Resource autoloaders are intended to manage namespaced library code that follow Zend Framework coding standard guidelines, but which do not have a 1:1 mapping between the class name and the directory structure. Their primary purpose is to facilitate autoloading application resource code, such as application-specific models, forms, and ACLs.

Resource autoloaders register with the autoloader on instantiation, with the namespace to which they are associated. This allows you to easily namespace code in specific directories, and still reap the benefits of autoloading.

Resource autoloader usage

Let's consider the following directory structure:

  1. path/to/some/directory/
  2.     acls/
  3.         Site.php
  4.     forms/
  5.         Login.php
  6.     models/
  7.         User.php

Within this directory, all code is prefixed with the namespace "My_". Within the "acls" subdirectory, the component prefix "Acl_" is added, giving a final class name of "My_Acl_Site". Similarly, the "forms" subdirectory maps to "Form_", giving "My_Form_Login". The "models" subdirectory has no component namespace, giving "My_User".

You can use a resource autoloader to autoload these classes. To instantiate the resource autoloader, you are required to pass at the minimum the base path and namespace for the resources it will be responsible for:

  1. $resourceLoader = new Zend_Loader_Autoloader_Resource(array(
  2.     'basePath'  => 'path/to/some/directory',
  3.     'namespace' => 'My',
  4. ));

Note: Base namespace
In Zend_Loader_Autoloader, you are expected to provide the trailing underscore ("_") in your namespace if your autoloader will use it to match the namespace. Zend_Loader_Autoloader_Resource makes the assumption that all code you are autoloading will use an underscore separator between namespaces, components, and classes. As a result, you do not need to use the trailing underscore when registering a resource autoloader.

Now that we have setup the base resource autoloader, we can add some components to it to autoload. This is done using the addResourceType() method, which accepts three arguments: a resource "type", used internally as a reference name; the subdirectory path underneath the base path in which these resources live; and the component namespace to append to the base namespace. As an example, let's add each of our resource types.

  1. $resourceLoader->addResourceType('acl', 'acls/', 'Acl')
  2.                ->addResourceType('form', 'forms/', 'Form')
  3.                ->addResourceType('model', 'models/');

Alternately, you could pass these as an array to addResourceTypes(); the following is equivalent to the above:

  1. $resourceLoader->addResourceTypes(array(
  2.     'acl' => array(
  3.         'path'      => 'acls/',
  4.         'namespace' => 'Acl',
  5.     ),
  6.     'form' => array(
  7.         'path'      => 'forms/',
  8.         'namespace' => 'Form',
  9.     ),
  10.     'model' => array(
  11.         'path'      => 'models/',
  12.     ),
  13. ));

Finally, you can specify all of this when instantiating the object, by simply specifying a "resourceTypes" key in the options passed and a structure like that above:

  1. $resourceLoader = new Zend_Loader_Autoloader_Resource(array(
  2.     'basePath'      => 'path/to/some/directory',
  3.     'namespace'     => 'My',
  4.     'resourceTypes' => array(
  5.         'acl' => array(
  6.             'path'      => 'acls/',
  7.             'namespace' => 'Acl',
  8.         ),
  9.         'form' => array(
  10.             'path'      => 'forms/',
  11.             'namespace' => 'Form',
  12.         ),
  13.         'model' => array(
  14.             'path'      => 'models/',
  15.         ),
  16.     ),
  17. ));

The Module Resource Autoloader

Zend Framework ships with a concrete implementation of Zend_Loader_Autoloader_Resource that contains resource type mappings that cover the default recommended directory structure for Zend Framework MVC applications. This loader, Zend_Application_Module_Autoloader, comes with the following mappings:

  1. forms/       => Form
  2. models/      => Model
  3.     DbTable/ => Model_DbTable
  4.     mappers/ => Model_Mapper
  5. plugins/     => Plugin
  6. services/    => Service
  7. views/
  8.     helpers  => View_Helper
  9.     filters  => View_Filter

As an example, if you have a module with the prefix of "Blog_", and attempted to instantiate the class "Blog_Form_Entry", it would look in the resource directory's "forms/" subdirectory for a file named "Entry.php".

When using module bootstraps with Zend_Application, an instance of Zend_Application_Module_Autoloader will be created by default for each discrete module, allowing you to autoload module resources.

Using Resource Autoloaders as Object Factories

Resource Autoloader Reference

blog comments powered by Disqus