Zend Framework - Application Structure

In this chapter, let us understand the structure of the Zend Framework application. The structure of the myapp application is as follows −

 composer.json 
 composer.lock 
 CONDUCT.md 
 config 
    application.config.php 
    autoload 
       development.local.php 
       development.local.php.dist 
       global.php 
       local.php.dist 
       README.md 
       zend-developer-tools.local-development.php 
    development.config.php 
    development.config.php.dist 
    modules.config.php 
 CONTRIBUTING.md 
 data 
    cache 
        module-classmap-cache.application.module.cache.php  docker-compose.yml 
 Dockerfile 
 LICENSE.md 
 module 
    Application 
        config 
        src 
        test 
        view 
 phpcs.xml 
 phpunit.xml.dist 
 public
    css 
       bootstrap.css 
       bootstrap.css.map 
       bootstrap.min.css 
       bootstrap.min.css.map 
       bootstrap-theme.css 
       bootstrap-theme.css.map 
       bootstrap-theme.min.css 
       bootstrap-theme.min.css.map 
       style.css 
    fonts 
       glyphicons-halflings-regular.eot 
       glyphicons-halflings-regular.svg 
       glyphicons-halflings-regular.ttf 
       glyphicons-halflings-regular.woff 
       glyphicons-halflings-regular.woff2 
    img 
       favicon.ico 
       zf-logo-mark.svg 
    index.php 
    js 
       bootstrap.js 
       bootstrap.min.js 
       jquery-3.1.0.min.js 
    web.config 
 README.md 
 TODO.md 
 Vagrantfile 
 vendor     
 autoload.php     
 bin     
    phpunit -> ../phpunit/phpunit/phpunit     
    templatemap_generator.php -> ../zendframework/zend-
view/bin/templatemap_generator.php
    zf-development-mode -> ../zfcampus/zf-development-mode/bin/zf-
development-mode 
 composer     
    autoload_classmap.php     
    autoload_namespaces.php     
    autoload_psr4.php     
    autoload_real.php     
    ClassLoader.php     
    installed.json 
    LICENSE     
 container-interop 
    container-interop     
 doctrine 
    instantiator     
 myclabs 
    deep-copy     
 phpdocumentor     
    reflection-common     
    reflection-docblock 
    type-resolver     
 phpspec 
    prophecy     
 phpunit     
    php-code-coverage     
    php-file-iterator     
    php-text-template     
    php-timer     
    php-token-stream     
    phpunit 
    phpunit-mock-objects     
 sebastian     
    code-unit-reverse-lookup     
    comparator     
    diff     
    environment     
    exporter     
    global-state     
    object-enumerator
    recursion-context     
    resource-operations 
    version     
 symfony 
    yaml     
 webmozart 
    assert     
 zendframework     
    zend-component-installer     
    zend-config     
    zend-console     
    zend-dom     
    zend-escaper     
    zend-eventmanager     
    zend-http     
    zend-loader     
    zend-modulemanager     
    zend-mvc     
    zend-router     
    zend-servicemanager     
    zend-stdlib     
    zend-test     
    zend-uri     
    zend-validator 
    zend-view 
 zfcampus 
 zf-development-mode  

73 directories, 55 files

The Zend Framework application consists of different folders. They are as follows −

• Application − This directory contains your application. It will house the MVC system, as well as configurations, services used and your bootstrap file.

• Config − This directory contains the configuration files of an application.

• Data − This directory provides a place to store application data that is volatile and possibly temporary.

• Module − Modules allow a developer to group a set of related controllers into a logically organized group.

• Public − This is the applications document root. It starts the Zend application. It also contains the assets of the application like JavaScript, CSS, Images, etc.

• Vendor − This directory contains composer dependencies.

Structure of the Application Modules

This is the main directory of your application. Zend Framework 2 introduces a powerful and flexible module system to organize the application efficiently. The Application module of the skeleton application (myapp) provides bootstrapping, error and routing configuration to the whole application. The structure of the Application module is as shown below −

 module 
    Application 
        config 
           module.config.php 
        src 
           Controller 
              IndexController.php 
           Module.php 
        test 
           Controller 
               IndexControllerTest.php 
        view 
            application 
               index 
                   index.phtml 
            error 
               404.phtml 
               index.phtml 
            layout 
                layout.phtml

Let us cover each of these module directories in detail −

• Application − This is root directory of the module. The name of the folder will match the name of the module and the name is also used as the PHP namespace of all the class defined inside the module. It will house the MVC system, as well as configurations, services used, and your bootstrap file.

• Config − Independent configuration of the module.

• Src − Main business logic of the application.

• View − Contains design / presentation (HTML) files. For example, index.phtml.

• src/Module.php − It is the heart of the module. It works as a front controller for the module. The Zend process src/Module.php file before processing any PHP Classes in this module.

• Application/config/module.config.php − It is implemented for the router configuration and auto loading files.

• Application/view/layout − Layouts represent the common parts of multiple views. For example, page header and footer. By default, layouts should be stored in the views/layoutsfolder.

All modules share the same or similar structure as that of the above Application module.