Spiga

Zend Framework Bootstrap file class

by Gabi Solomon

After starting working with zend framework i found all sorts of examples of bootstrap files, but a lot of them seem pretty messy to me since all the calls to zend components were basically thrown in there.

So after a lot of looking around i came up with a bootstrap files that is more to my liking. I found the initial class on a blog post when i was looking around but i don't remember where, so sorry for not giving it the credit.

First i will show you my index file.

PLAIN TEXT
PHP:
  1. require './init.php';
  2.  
  3. Bootstrap::run();

Pretty simple isnt it :D . And now the init file.

PLAIN TEXT
PHP:
  1. // Add /library and /application directory to our include path
  2. $siteRootDir = dirname(__FILE__);
  3.  
  4. define('APPLICATION_PATH', $siteRootDir . '/application');
  5.  
  7. APPLICATION_PATH . '/models' . PATH_SEPARATOR
  8. . APPLICATION_PATH . '/modules/default/controllers' . PATH_SEPARATOR
  9. . APPLICATION_PATH . '/controllers' . PATH_SEPARATOR
  10. . APPLICATION_PATH . PATH_SEPARATOR
  11. . $siteRootDir . '/library' . PATH_SEPARATOR
  13. );
  14.  
  15. require APPLICATION_PATH . '/bootstrap.php';

Ok now lets go into the bootstrap :) . I will firs just paste it here and then write some explinations to it.

PLAIN TEXT
PHP:
  1. function __autoload($className) {
  2. require $className = str_replace('_', '/', $className) . '.php';
  3. }
  4.  
  5. class Bootstrap{
  6.  
  7. public static $frontController = null;
  8.  
  9. public static $root = '';
  10.  
  11. public static $registry = null;
  12.  
  13. public static function run(){
  14. self::prepare();
  15.  
  16. $response = self::$frontController->dispatch();
  17. self::sendResponse($response);
  18. }
  19.  
  20. public static function prepare(){
  21. self::setupEnvironment();
  22.  
  23. self::setupRegistry();
  24. self::setupConfiguration();
  25.  
  26. self::setupFrontController();
  27. self::setupErrorHandler();
  28.  
  29. self::setupController();
  30. self::setupView();
  31. self::setupDatabase();
  32. self::setupSessions();
  33. self::setupTranslation();
  34. self::setupRoutes();
  35. self::setupAcl();
  36. }
  37.  
  38. public static function setupEnvironment(){
  39. error_reporting(E_ALL ^ E_NOTICE);
  40. ini_set('display_errors', true);
  41.  
  42. date_default_timezone_set('Europe/Bucharest');
  43.  
  44. self::$root = dirname(dirname(__FILE__));
  45.  
  46. $configType = (isset($_SERVER['SERVER_NAME']) && ($_SERVER['SERVER_NAME'] == '127.0.0.1' OR $_SERVER['SERVER_NAME'] == 'localhost')) ? 'development' : 'production';
  47. define('APPLICATION_ENVIRONMENT', $configType);
  48.  
  49. define('HTMLPURIFIER_PREFIX', self::$root . '/library');
  50. }
  51.  
  52. public static function setupRegistry() {
  53. self::$registry = new Zend_Registry(array(), ArrayObject::ARRAY_AS_PROPS);
  54. Zend_Registry::setInstance(self::$registry);
  55. }
  56.  
  57. public static function setupConfiguration() {
  58.  
  59. $config = new Zend_Config_Ini(
  60. self::$root . '/application/config/main.ini',
  61. APPLICATION_ENVIRONMENT
  62. );
  63.  
  64. self::$registry->configuration = $config;
  65.  
  66. //save $siteRootDir in registry:
  67. self::$registry->set('siteRootDir', self::$root );
  68. self::$registry->set('applicationRootDir', self::$root . '/application' );
  69.  
  70. self::$registry->set('siteRootUrl', 'http://' . $_SERVER['HTTP_HOST'] );
  71. }
  72.  
  73. public static function setupFrontController(){
  74. self::$frontController = Zend_Controller_Front::getInstance();
  75. self::$frontController->throwExceptions(true);
  76. self::$frontController->returnResponse(true);
  77.  
  78. self::$frontController->addModuleDirectory(self::$root . '/application/modules');
  79.  
  80. self::$frontController->setParam('registry', self::$registry);
  81.  
  82. self::$frontController->setParam('env', APPLICATION_ENVIRONMENT);
  83.  
  84. $response = new Zend_Controller_Response_Http; // Set default Content-Type
  85. $response->setHeader('Content-Type', 'text/html; charset=UTF-8', true);
  86. self::$frontController->setResponse($response);
  87. }
  88.  
  89. public static function setupErrorHandler() {
  90. self::$frontController->throwExceptions(false);
  91.  
  92. self::$frontController->registerPlugin(new Zend_Controller_Plugin_ErrorHandler(
  94. 'module'     => 'default',
  95. 'controller' => 'error',
  96. 'action'     => 'error')
  97. ));
  98.  
  99. $writer = new Zend_Log_Writer_Firebug();
  100. $logger = new Zend_Log($writer);
  101. Zend_Registry::set('logger',$logger);
  102. }
  103.  
  104. public static function setupController(){
  105. // place to put in your Controll Action Helpers
  106. // ex: Zend_Controller_Action_HelperBroker::addHelper(new GSD_Controller_Action_Helper_AuthUsers());
  107. }
  108.  
  109. public static function setupView() {
  110.  
  111. $view = new Zend_View(array('encoding'=>'UTF-8'));
  112. $view->addHelperPath('GSD/View/Helper', 'GSD_View_Helper_');
  113.  
  114. $viewRendered = new Zend_Controller_Action_Helper_ViewRenderer($view);
  115. Zend_Controller_Action_HelperBroker::addHelper($viewRendered);
  116.  
  117. Zend_Layout::startMvc(
  119. 'layoutPath' => self::$root . '/application/layouts',
  120. 'layout' => 'default'
  121. )
  122. );
  123. }
  124.  
  125. public static function sendResponse(Zend_Controller_Response_Http $response){
  126. $response->sendResponse();
  127. }
  128.  
  129. public static function setupDatabase(){
  130. $config = self::$registry->configuration;
  131.  
  132. $db = Zend_Db::factory($config->db->adapter, $config->db->toArray());
  133.  
  134. $profiler = new Zend_Db_Profiler_Firebug('All DB Queries');
  135. $profiler->setEnabled(true);
  136. $db->setProfiler($profiler);
  137.  
  138. $db->query("SET NAMES 'utf8'");
  139.  
  140. self::$registry->database = $db;
  141. Zend_Db_Table::setDefaultAdapter($db);
  142.  
  143. $frontendOptions = array(
  144. 'automatic_serialization' => true
  145. );
  146.  
  147. $backendOptions  = array(
  148. 'cache_dir'                => self::$root . '/data/cache/db_table'
  149. );
  150.  
  151. $cache = Zend_Cache::factory('Core',
  152. 'File',
  153. $frontendOptions,
  154. $backendOptions);
  155.  
  156. // Next, set the cache to be used with all table objects
  157. Zend_Db_Table_Abstract::setDefaultMetadataCache($cache);
  158. }
  159.  
  160. public static function setupSessions(){
  161.  
  162. // Now set session save handler to our custom class which saves the data in MySQL database
  163. $sessionManager = new GSD_Session_Manager();
  164. Zend_Session::setOptions(array(
  165. 'gc_probability' => 1,
  166. 'gc_divisor' => 5000
  167. ));
  168. Zend_Session::setSaveHandler($sessionManager);
  169.  
  170. $defSession = new Zend_Session_Namespace('Main', true);
  171. Zend_Registry::set('defSession', $defSession);
  172. }
  173.  
  174. public static function setupTranslation(){
  175. $options = array(
  176. 'scan' => Zend_Translate::LOCALE_FILENAME,
  177. 'disableNotices' => true,
  178. );
  179. $translate = new Zend_Translate('gettext', Zend_Registry::get('siteRootDir') . '/application/languages/', 'auto', $options);
  180. Zend_Registry::set('Zend_Translate', $translate);
  181.  
  182. if (self::$frontController) {
  183. self::$frontController->registerPlugin(new GSD_Controller_Plugin_Language());
  184. }
  185. }
  186.  
  187. public static function setupRoutes(){
  188. // define some routes (URLs)
  189. $router = self::$frontController->getRouter();
  190.  
  191. $config = new Zend_Config_Ini(
  192. self::$root . '/application/config/routes.ini',
  193. 'development'
  194. );
  195.  
  196. $router->addConfig($config, 'routes');
  197. }
  198.  
  199. public static function setupAcl(){
  200. self::$frontController->registerPlugin(new GSD_Controller_Plugin_Acl());
  201. }
  202. }

As you can see basicly i just grouped toghether similar comands and make it all look much more nicer and cleaner. And also i added the autoload function since i really think this is a much faster way then the Zend_Loader option. As for what is run, lets take it one by one:
function run
This is the main function that calls the prepare function and starts up the whole Zend Framework.

function prepare
Calls all the internal methods that setup the framework to start dispatching the request.

function setupEnvironment
Here i added the error reporting options and also i define some constants like configuration type ( development - production )

function setupRegistry()
Start the Zend Registry.

function setupConfiguration
Get the config file ( contains the db conection data etc. ) and save the configuration in Zend_Registry

function setupFrontController
Starts the front controller and setup the modular aproach.

function setupErrorHandler
Registers the Error handler plugins and logger.

function setupController
Here is the place to put your Controll Action Helpers

function setupView
start the Zend_View and MVC structure, add the custom HelperPath

function setupDatabase
start your db connection bassed on the configuration we stored in the registry. Also started the Zend_Db_Table cache system.

function setupSessions
Start you session, i used a custom Session Manager that uses a mysql database as storage.

And that is about it. I skipped some of them because i thought they were pretty obvious.

Hope you will find this usefully, and await your comments.
Cheers

Related Posts

  • I think the idea of separating bootstrap into a class something like yours is good, but the code you show doesn't seem particularily different from just sticking it outside a class. You could group the code by say delimiting by comments etc. and it would be pretty much the same. Not to mention that the class is just extraneous code that makes it look more complex.

    Have you looked at Zym_App? I think that's a pretty good way to implement this kind of bootstrapping class, which actually ends up doing something else than just wrapping code into methods ( http://www.zym-project.com/docs/reference/zym.a... )

    I guess yours doe have one advantage over the no-class approach: it's easier to remove selected behavior by commenting out the method call, instead of commenting out the whole code-block.
  • @Jani Hartikainen

    Yes its true that is doesnt have too much of an advantage over just writing the code, but for me its a little more organized and it has one more advantage. I can write a new prepare method for crons that will not start all of the zend framework ( for example it doesnt need the fron controller ) and i can do it in the same file and not have to do another bootstrapfile.
  • very pleasure to visit this site. nice post. thanks for sharing.
blog comments powered by Disqus