Главная / Zend Manual Core
Zend_Application - Быстрый старт

Теоретические основы работы с Zend_Application

Получение сконфигурированного MVC-приложения, готового к обработке запроса, требует наличия дополнительного кода, объем которого зависит от используемого функционала: установка соединения с базой данных, конфигурирование видов и их помощников, конфигурирование макетов (layouts), регистрация плагинов, регистрация помощников действий и так далее.

Кроме того, вы можете захотеть повторно использовать один и тот же код для загрузки тестов, сервисных скриптов, скриптов, предназначенных для запуска через крон. Можно просто добавлять свой скрипт загрузки, но часто встречаются инициализации, зависящие от окружения - например, для запуска через крон MVC может быть лишним, а для сервисного скрипта может быть достаточно только слоя баз данных.

Zend_Application облегчает управление начальной загрузкой и способствует повторному использованию путем инкапсуляции загрузки в соответствии с парадигмой ООП.

Zend_Application состоит из трех областей:

  • Zend_Application: загружает окружение PHP, включая include_paths и автозагрузку (autoloading), инстанцирует запрошенный загрузочный класс.

  • Zend_Application_Bootstrap: предоставляет интерфейсы для загрузочных классов. Zend_Application_Bootstrap_Bootstrap предоставляет общий функционал, удовлетворяющий большинство нужд по начальной загрузке, включающие в себя алгоритмы проверки зависимостей и возможность загрузки ресурсов по требованию.

  • Zend_Application_Resource предоставляет интерфейс для стандартных ресурсов загрузки, которые могут быть загружены по требованию через экземпляр загрузочного класса, и несколько реализаций ресурсов, используемых по умолчанию.

Разработчики могут создавать загрузочный класс для приложения, расширяя Zend_Application_Bootstrap_Bootstrap или, как минимум, реализуя интерфейс Zend_Application_Bootstrap_Bootstrapper. Входная точка (например, public/index.php) будет загружать Zend_Application и инстанцировать его путем передачи:

  • Текущего окружения

  • Опций для загрузки

Опции загрузки включают в себя путь к файлу, содержащему в себе загрузочный класс и, опционально:

  • Любые дополнительные пути для добавления в include_path

  • Любые дополнительные пространства имен автозагрузки, которые требуется зарегистрировать

  • Любые установки php.ini для инициализации

  • Имя класса загрузки (если используется имя, отличное от "Bootstrap")

  • Пары префикс-путь для ресурсов

  • Любые ресурсы для использования (указываются через имя класса или их короткое имя)

  • Дополнительный путь к загружаемому конфигурационному файлу

  • Дополнительные опции конфигурации

Опции могут быть массивом, объектом Zend_Config или путью к конфигурационному файлу.

Начальная загрузка

Второй областью отвественности компоненты Zend_Application является выполнение загрузки приложения. Загрузочные классы должны как минимум реализовывать интерфейс Zend_Application_Bootstrap_Bootstrapper, который определяет следующий API:

  1. interface Zend_Application_Bootstrap_Bootstrapper
  2. {
  3.     public function __construct($application);
  4.     public function setOptions(array $options);
  5.     public function getApplication();
  6.     public function getEnvironment();
  7.     public function getClassResources();
  8.     public function getClassResourceNames();
  9.     public function bootstrap($resource = null);
  10.     public function run();
  11. }

Этот API позволяет классу загрузки принимать окружение и конфигурацию из объекта приложения, определять ресурсы, за загрузку которых он отвечает, выполнять загрузку и запуск приложения.

Вы можете сами реализовывать этот интерфейс, расширять Zend_Application_Bootstrap_BootstrapAbstract или использовать Zend_Application_Bootstrap_Bootstrap.

Кроме этого функционала есть и другие требующие внимания области, с которыми вы должны ознакомиться.

Методы ресурсов

Zend_Application_Bootstrap_BootstrapAbstract предоставляет простое соглашение для определения методов ресурсов. Любой защищенный метод с именем, начинающимся с _init, будет считаться методом ресурса.

Для того, чтобы запустить один метод ресурса, вызывайте метод bootstrap() с именем ресурса в качестве аргумента. Именем ресурса будет имя метода без префикса _init.

Для того, чтобы запустить несколько методов ресурсов, передавайте массив имен. А для того, чтобы запустить все методы ресурсов, вызывайте метод без аргументов.

Возьмем следующий загрузочный класс:

  1. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
  2. {
  3.     protected function _initFoo()
  4.     {
  5.         // ...
  6.     }
  7.  
  8.     protected function _initBar()
  9.     {
  10.         // ...
  11.     }
  12.  
  13.     protected function _initBaz()
  14.     {
  15.         // ...
  16.     }
  17. }

Для того, чтобы запустить только метод _initFoo(), сделайте следующее:

  1. $bootstrap->bootstrap('foo');

Для того, чтобы запустить методы _initFoo() и _initBar(), сделайте следующее:

  1. $bootstrap->bootstrap(array('foo', 'bar'));

Для того, чтобы запустить все методы ресурсов, используйте bootstrap() без аргументов:

  1. $bootstrap->bootstrap();

Загрузки, использующие плагины ресурсов

Для того, чтобы вы могли сделать свои загрузки более пригодными для повторного использования, мы реализовали возможность помещать свои ресурсы в классы-плагины ресурсов. Это позволит вам легко комбинировать ресурсы, используя конфигурацию. Ниже будет описание того, как создавать ресурсы, в данном разделе мы только покажем, как использовать их.

Если ваша загрузка должна поддерживать плагины ресурсов, то вам нужно реализовать дополнительный интерфейс Zend_Application_Bootstrap_ResourceBootstrapper. Этот интерфейс определяет API для определения местонахождения, регистрации и загрузки плагинов ресурсов:

  1. interface Zend_Application_Bootstrap_ResourceBootstrapper
  2. {
  3.     public function registerPluginResource($resource, $options = null);
  4.     public function unregisterPluginResource($resource);
  5.     public function hasPluginResource($resource);
  6.     public function getPluginResource($resource);
  7.     public function getPluginResources();
  8.     public function getPluginResourceNames();
  9.     public function setPluginLoader(Zend_Loader_PluginLoader_Interface $loader);
  10.     public function getPluginLoader();
  11. }

Плагины ресурсов в основном дают возможность создавать инициализаторы ресурсов, которые могут повторно использоваться в различных приложениях. Это позволит вам поддерживать порядок в вашей действующей загрузке и внедрять новые ресурсы без необходимости внесения изменений в собственно загрузке.

Zend_Application_Bootstrap_BootstrapAbstract (и, следовательно, наследующий от него класс Zend_Application_Bootstrap_Bootstrap) реализуют этот интерфейс, позволяя вам использовать плагины ресурсов.

Для того, чтобы использовать плагины ресурсов, вы должны указывать их в опциях, передаваемых объектам приложения и/или загрузки. Эти опции могут указываться через конфигурационный файл или передаваться вручную. Опции будут массивом пар ключ/опции, где ключом является имя ресурса. Именем ресурса будет часть строки, следующая после префикса класса. Например, ресурсы, поставляемые c Zend Framework'ом, имеют префикс класса "Zend_Application_Resource_", все, что следует за ним, будет именем ресурса. Например:

  1. $application = new Zend_Application(APPLICATION_ENV, array(
  2.     'resources' => array(
  3.         'FrontController' => array(
  4.             'controllerDirectory' => APPLICATION_PATH . '/controllers',
  5.         ),
  6.     ),
  7. ));

Это означает, что должен использоваться ресурс "FrontController" с указанными опциями.

Если вы планируете писать собственные плагины ресурсов либо добавить сторонние, то нужно будет указать вашей загрузке, где их искать. Внутри себя загрузка использует Zend_Loader_PluginLoader, поэтому достаточно указать префикс класса и путь к директории с плагинами ресурсов.

Для примера предположим, что вы имеете свои плагины ресурсов в директории APPLICATION_PATH/resources/, и они используют общий префикс My_Resource. Вы можете передать эту информацию объекту приложения так, как показано ниже:

  1. $application = new Zend_Application(APPLICATION_ENV, array(
  2.     'pluginPaths' => array(
  3.         'My_Resource' => APPLICATION_PATH . '/resources/',
  4.     ),
  5.     'resources' => array(
  6.         'FrontController' => array(
  7.             'controllerDirectory' => APPLICATION_PATH . '/controllers',
  8.         ),
  9.     ),
  10. ));

После этого вы можете использовать ресурсы из этой директории.

Так же, как и в случае с методами ресурсов, вы используете метод bootstrap() для выполнения плагинов ресурсов. И точно так же вы можете указывать один плагин ресурса, несколько плагинов ресурсов (через массив), либо запускать все плагины сразу. Кроме того, вы можете комбинировать их с методами ресурсов.

  1. // Выполнить один:
  2. $bootstrap->bootstrap('FrontController');
  3.  
  4. // Выполнить несколько:
  5. $bootstrap->bootstrap(array('FrontController', 'Foo'));
  6.  
  7. // Выполнить все ресурсы и плагины:
  8. $bootstrap->bootstrap();

Реестр ресурсов

Большинство, если не все, методы и плагины ресурсов будут инициализировать объекты, и во многих случаях эти объекты будут нужны где-то еще в приложении. Как получить к ним доступ?

Zend_Application_Bootstrap_BootstrapAbstract предоставляет локальный реестр для этих объектов. Для того, чтобы сохранять свои объекты в нем, просто возвращайте их из своего ресурса.

Для большей гибкости этот реестр внутри себя ссылается на "контейнеры"; единственное требование состоит в том, чтобы это был объект. Ресурсы регистрируются как свойства, имена которых совпадают с именами ресурсов. По умолчанию используется экземпляр Zend_Registry, но вы можете при желании указывать любой другой объект. Для работы с контейнерами могут использоваться методы setContainer() и getContainer(). Метод getResource($resource) может использоваться для извлечения ресурса из контейнера, а hasResource($resource) - для проверки того, был ли зарегистрирован данный ресурс.

Для примера рассмотрим базовый ресурс вида:

  1. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
  2. {
  3.     protected function _initView()
  4.     {
  5.         $view = new Zend_View();
  6.         // дальнейшая инициализация...
  7.  
  8.         return $view;
  9.     }
  10. }

Вы можете затем проверять его наличие и/или извлекать его как показано ниже:

  1. // Использование пары has/getResource()
  2. if ($bootstrap->hasResource('view')) {
  3.     $view = $bootstrap->getResource('view');
  4. }
  5.  
  6. // Через контейнер:
  7. $container = $bootstrap->getContainer();
  8. if (isset($container->view)) {
  9.     $view = $container->view;
  10. }

Следует заметить, что реестр и контейнер не являются глобальными. Это означает, что вам нужно иметь доступ к объекту загрузки с тем, чтобы можно было извлекать ресурсы. Zend_Application_Bootstrap_Bootstrap предоставляет некоторые удобства для этого: во время выполнения run() он регистрирует себя в качестве параметра "bootstrap" во фронт-контроллере, это позволяет извлекать его внутри маршрутизатора, диспетчера, плагинов и контроллеров действий.

Например, если вы хотите внутри своего контроллера действий получить доступ к ресурсу вида из примеров выше, то можете сделать следующее:

  1. class FooController extends Zend_Controller_Action
  2. {
  3.     public function init()
  4.     {
  5.         $bootstrap = $this->getInvokeArg('bootstrap');
  6.         $view = $bootstrap->getResource('view');
  7.         // ...
  8.     }
  9. }

Отслеживание зависимостей

Кроме выполнения методов и плагинов ресурсов, необходимо также гарантировать, что они выполняются один и только один раз. Они предназначены для загрузки приложения, и выполнение их больше одного раза может привести к непроизводительному расходованию ресурсов.

В то же время некоторые ресурсы могут зависеть от других и требовать их предварительной загрузки до начала своего выполнения. Для решения этих двух проблем Zend_Application_Bootstrap_BootstrapAbstract предоставляет простой и эффективный механизм для отслеживания зависимостей.

Как было сказано ранее, все ресурсы - как методы, так и плагины, - загружаются путем вызова bootstrap($resource), где $resource является именем ресурса или массивом ресурсов. Если параметр $resource опущен, то это означает, что все ресурсы должны быть запущены.

Если ресурс зависит от других ресурсов, то он должен вызывать метод bootstrap() в своем коде для обеспечения выполнения этих ресурсов. Последующие вызовы для этих ресурсов будут проигнорированы.

В методе ресурса такой вызов будет выглядеть следующим образом:

  1. class Bootstrap extends Zend_Application_Bootstrap_Bootstrap
  2. {
  3.     protected function _initRequest()
  4.     {
  5.         // Обеспечение инициализации контроллера
  6.         $this->bootstrap('FrontController');
  7.  
  8.         // Извлечение фронт-контроллера из реестра загрузки
  9.         $front = $this->getResource('FrontController');
  10.  
  11.         $request = new Zend_Controller_Request_Http();
  12.         $request->setBaseUrl('/foo');
  13.         $front->setRequest($request);
  14.  
  15.         // Обеспечение сохранения запроса в реестре загрузки
  16.         return $request;
  17.     }
  18. }

Плагины ресурсов

Как было сказано ранее, хорошим способом создания повторно используемых ресурсов загрузки и выделения кода в отдельные классы является использование плагинов ресурсов. Хотя Zend Framework поставляется с набором стандартных плагинов ресурсов, замысел состоит в том, что разработчики должны писать собственные плагины с целью инкапсуляции собственного кода, предназначенного для инициализации.

Ресурсы должны только реализовывать интерфейс Zend_Application_Resource_Resource или, что является более простым вариантом, расширять абстрактный класс Zend_Application_Resource_ResourceAbstract. Базовый интерфейс довольно прост:

  1. interface Zend_Application_Resource_Resource
  2. {
  3.     public function __construct($options = null);
  4.     public function setBootstrap(
  5.         Zend_Application_Bootstrap_Bootstrapper $bootstrap
  6.     );
  7.     public function getBootstrap();
  8.     public function setOptions(array $options);
  9.     public function getOptions();
  10.     public function init();
  11. }

Он определяет только, что ресурс должен принимать опции через конструктор, иметь механизмы для установки/получения опций, механизмы для установки/получения объекта загрузочного класса и метод инициализации.

Для примера предположим, что вы имеете инициализацию вида, одинаковую для нескольких ваших приложений. Вы используете в них одну и ту же декларацию DOCTYPE, одни и те же CSS-стили, скрипты JavaScript, а также хотите иметь возможность задавать базовый заголовок документа через конфигурацию. Ресурс, выполняющий такую инициализацию, может выглядеть следующим образом:

  1. class My_Resource_View extends Zend_Application_Resource_ResourceAbstract
  2. {
  3.     protected $_view;
  4.  
  5.     public function init()
  6.     {
  7.         // Возвращает вид, таким образом, он будет сохранен в реестре
  8.         return $this->getView();
  9.     }
  10.  
  11.     public function getView()
  12.     {
  13.         if (null === $this->_view) {
  14.             $options = $this->getOptions();
  15.             $title   = '';
  16.             if (array_key_exists('title', $options)) {
  17.                 $title = $options['title'];
  18.                 unset($options['title']);
  19.             }
  20.  
  21.             $view = new Zend_View($options);
  22.             $view->doctype('XHTML1_STRICT');
  23.             $view->headTitle($title);
  24.             $view->headLink()->appendStylesheet('/css/site.css');
  25.             $view->headScript()->appendfile('/js/analytics.js');
  26.  
  27.             $viewRenderer =
  28.                 Zend_Controller_Action_HelperBroker::getStaticHelper(
  29.                     'ViewRenderer'
  30.                 );
  31.             $viewRenderer->setView($view);
  32.  
  33.             $this->_view = $view;
  34.         }
  35.         return $this->_view;
  36.     }
  37. }

Зарегистрировав путь к этому плагину ресурса, вы можете использовать его в своем приложении. Сверх того, благодаря использованию загрузчика плагинов вы эффективно переопределите идущий в поставке плагин ресурса "View", тем самым обеспечивая использование своего плагина вместо него.


Zend_Application - Быстрый старт