BIGtheme.net http://bigtheme.net/ecommerce/opencart OpenCart Templates
Home / Sviluppo Software / CMS / Symfony Struttura delle cartelle di una applicazione

Symfony Struttura delle cartelle di una applicazione

Oggi dopo tanta teoria incominciamo a vedere bene come è composta la struttura di un’applicazione realizzata con Symfony.

L’ impostazione predefinita, di ogni applicazione ha in Symfony Struttura delle cartelle raccomandata:

app/: Questa cartella contiene la configurazione dell’applicazione;
src/: Tutto il codice PHP del progetto sta all’interno di questa cartella;
vendor/: Ogni libreria dei venditori è inserita qui, per convenzione;
web/: Questa è la cartella radice del web e contiene ogni file accessibile pubblicamente;

symfony-struttura-cartelle-1-211x300

La cartella WEB ….

La cartella web contiene tutti i file pubblici e statici, inclusi immagini, fogli di stile, file JavaScript. È anche li posto in cui stanno tutti i front controller:

            // web/app.php
             require_once __DIR__.'/../app/bootstrap.php.cache';
             require_once __DIR__.'/../app/AppKernel.php';
             use Symfony\Component\HttpFoundation\Request;
             $kernel = new AppKernel('prod', false);
             $kernel->loadClassCache();
             $kernel->handle(Request::createFromGlobals())->send();

Il file del front controller (app.php in questo esempio) è il file PHP che viene eseguito quando si usa un’applicazione Symfony2 e il
suo compito è quello di usare una classe kernel, AppKernel, per inizializzare l’applicazione.

 

Cosa vuol dire avere un front controller?
Aver un front controller vuol dire avere URL diverse e più flessibili rispetto a una tipica applicazione in puro PHP.
Quando si usa un front controller, gli URL sono formattati nel modo seguente:

http://localhost/app.php/hello/Ryan

Il front controller, app.php, viene eseguito e l’URL “interno” /hello/Ryan è dirottato internamente, usando la configurazione delle rotte.

Usando mod_rewrite di Apache, si può forzare l’esecuzione del file app.php senza bisogno di specificarlo nell’URL:

http://localhost/hello/Ryan

La cartella dell’applicazione (APP)

La classe AppKernel è il punto di ingresso principale dell’applicazione ed è responsabile di tutta la configurazione.

Per questo è memorizzata nella cartella app/.

Questa classe deve implementare due metodi, che definiscono tutto ciò di cui Symfony ha bisogno di sapere sulla propria applicazione.

Non ci si deve preoccupare di questi metodi all’inizio, Symfony li riempe al posto nostro con delle impostazioni predefinite.
registerBundles(): Restituisce un array di tutti bundle necessari per eseguire l’applicazione (vedere Il sistema dei bundle);
registerContainerConfiguration(): Carica il file della configurazione principale dell’applicazione (vedere la sezione Configurazione dell’applicazione).

La cartella app/ per modificare i file di configurazione e delle rotte nella cartella      app/config/ (vedere Configurazione dell’applicazione).
Essa contiene anche
– la cartella della cache dell’applicazione (app/cache),
– la cartella dei log (app/logs)
– la cartella dei file risorsa a livello di applicazione, come i template (app/Resources).

      Ma che cos’è  Autoload?
Quando Symfony si carica, un file speciale chiamato app/autoload.php viene incluso.

Questo file è responsabile di configurare l’autoloader, che auto-caricherà i file dell’applicazione    dalla cartella src/ e le librerie di terze parti dalla cartella vendor/ menzionate nel file composer.json.
Grazie all’autoloader, non si avrà mai bisogno di usare le istruzioni include o require.
Al posto loro, Composer usa lo spazio dei nomi di una classe per determinare la sua posizione e includere automaticamente il file al posto nostro, nel momento in cui la classe è necessaria.

L’autoloader è già configurato per cercare nella cartella src/ tutte le proprie classi PHP. Per poterlo far funzionare, il nome della classe e quello del file devono seguire lo stesso schema:

Nome della classe:
     Acme\HelloBundle\Controller\HelloController
Percorso:
     src/Acme/HelloBundle/Controller/HelloController.php

La cartella dei sorgenti (SRC)
Detto semplicemente, la cartella src/ contiene tutto il codice (codice PHP, template, file di configurazione, fogli di stile, ecc.) che guida la propria applicazione.

Quando si sviluppa, gran parte del lavoro sarà svolto dentro uno o più bundle creati in questa cartella.

Ma cos’è esattamente un bundle?
Un bundle è simile a un plugin in altri software, ma anche meglio. La differenza fondamentale è che tutto è un bundle in Symfony2, incluse le funzionalità  fondamentali del framework o il codice scritto per la propria applicazione.
Questo fornisce la flessibilità di usare caratteristiche già pronte impacchettate in bundle di terze parti o di distribuire i propri bundle.
Rende facile scegliere quali caratteristiche abilitare nella propria applicazione per ottimizzarla nel modo preferito.

 Un bundle è semplicemente un insieme strutturato di file dentro una cartella, che implementa una singola caratteristica.
Si potrebbe creare un BlogBundle, un ForumBundle o un bundle per la gestione degli utenti (molti di questi già esistono come bundle open source).

Ogni cartella contiene tutto ciò che è relativo a quella caratteristica, inclusi file PHP, template, fogli di stile, JavaScript, test e tutto il resto.

Ogni aspetto di una caratteristica esiste in un bundle e ogni caratteristica risiede in un bundle.

Un’applicazione è composta di bundle, come definito nel metodo registerBundles() della classe AppKernel:

// app/AppKernel.php
public function registerBundles()
{
$bundles = array(
new Symfony\Bundle\FrameworkBundle\FrameworkBundle(),
new Symfony\Bundle\SecurityBundle\SecurityBundle(),
new Symfony\Bundle\TwigBundle\TwigBundle(),
new Symfony\Bundle\MonologBundle\MonologBundle(),
new Symfony\Bundle\SwiftmailerBundle\SwiftmailerBundle(),
new Symfony\Bundle\DoctrineBundle\DoctrineBundle(),
new Symfony\Bundle\AsseticBundle\AsseticBundle(),
new Sensio\Bundle\FrameworkExtraBundle\SensioFrameworkExtraBundle(),
);
if (in_array($this->getEnvironment(), array(‘dev’, ‘test’))) {
$bundles[] = new Acme\DemoBundle\AcmeDemoBundle();
$bundles[] = new Symfony\Bundle\WebProfilerBundle\WebProfilerBundle();
$bundles[] = new Sensio\Bundle\DistributionBundle\SensioDistributionBundle();
$bundles[] = new Sensio\Bundle\GeneratorBundle\SensioGeneratorBundle();
}
return $bundles;
}

Col metodo registerBundles(), si ha il controllo totale su quali bundle siano usati dalla propria applicazione (inclusi i bundle del nucleo di Symfony).
Un bundle può stare ovunque, purché possa essere auto-caricato (tramite l’autoloader configurato in app/autoload.php).

Se avete dei dubbi commentate , saremo pronti a rispondervi per spiegarvi meglio l’argomento.

Puoi leggere Anche

WordPress Come Aggiornare i Plugin

Nella guida di oggi vedremo come Aggiornare i Plugin. Così come la versione di WordPress ...