Introduzione

Sito ufficiale di Symfony: https://symfony.com/

Symfony è un framework, questo vuol dire che ci aiuta (e di molto) a creare i nostri siti (e altro) in php.

Nel corso degli anni si è molto evoluto e oggi (Gennaio 2018) è arrivato alla versione 4.0 stabile (o master) e stanno lavorando alla 4.1.

La prima cosa che si legge andando nel sito ufficiale è che le versioni precedenti alla 4.0 (3.4, ecc…) non sono compatibili, quindi se state sviluppando un sito con la versione 4.0 e cercate in rete delle risorse, al prima cosa di cui dovete accertarvi è la versione per la quale è stata sviluppata.

Una delle caratteristiche di Symfony è che il progetto si gestisce da riga di comando, riga di comando che chiede in rete l’ultima versione che sto cercando.

Per questo motivo vi consiglio di non far creare lo skeleton del progetto da IDE (come Eclipse, NetBean, o altri) invece si possono usare per lavorare con file già creati.

Primo progetto (Symfony 4)

Dopo aver installato Composer e PHP 7.1

    • Installiamo il progetto (dalla console)
      • composer create-project symfony/skeleton my-project
    • Installiamo il web server  (non è adatto alla produzione)
      • cd my-project
        composer require server --dev
  • avviamo il server
    • php bin/console server:run
  • nel browser
    • http://localhost:8000/

       

Creo Controller e rotta

Il Controller è un file che si trova src/Controller/LuckyController.php

Nuovo Progetto in Eclipse

  1. Dopo aver scaricato e lanciato l’installer di eclipse, installare “Eclipse IDE for PHP Developers”
  2. Da Eclipse Marketplace (menu – help), instalalre “Symfony Plugin 1.3.1″ e ” Twig plugin …” se si vuole usare twig (nel dubbio installatelo)
  3. Dopo aver riavviato eclipse
  4. Menu – Preferences – PHP –
    1. Installed PHPs – Search – selezionare l’ultima versione
    2. Servers – editare la voce presente – Inserire in Document root – Indicare la root dei progetti
  5. Menu – File – New – other – Symfony Project
    1. Inserire il nome del progetto
    2. Create new Project in workspace
      1. Create project on a local server (selezionando la voce disponibile) se si vuole creare su un server
    3. Use default PHP settings
    4. Selezionare l’ultima versione di Symfony
    5. Next
    6. Finish
  6. Si apre il file Composer.json
  7. Si avvia lo script per creare il progetto base
  8. Alla richiesta di alcuni  parametri (database_host, ecc…) confermare i valori di default con invio

 

 

Per fa diventare un progetto PHP un progetto Symfony, tasto DX del mouse sul nome del progetto, Configure, Add Symfony support

 

Nuovo Progetto in NetBeans

  1. Installare i plugins per symfony
    1. menu -> tools -> plugins -> Available Plugins -> (scrivere symfony in search) installare:
      1. Symfony Framework
      2. Symfony 2/3 Framework
  2. Nuovo progetto -> PHP -> PHP Application -> next
    1. Project Name: NOMEPROGETTO
    2. Source Folder: D:\wamp64\www\NOMEPROGETTO
  3. Run As:
    1. Local Web Site
    2. PHP Buil-in Web Server
  4. Check su: Symfony 2/3 PHP Web Framework
  5. Finish

Se va in errore per la versione che si sta cercando di installare:

  1. Installare il progetto da console: php symfony NOMEPROGETTO 3.3.11
  2. Nuovo progetto -> PHP -> PHP Application with Existing Sources -> next
  3. Selezionare la cartella del nuovo progetto
  4. Inde File: indicare “web/app_dev.php”
  5. Click su “Run project” (triangolo verde)
  6. Si apre il browser che punta a http://localhost/sym03/web/app_dev.php

P.S. Per far partire il progetto dal browser interno di php: tasto DX sul nome del progetto -> Set configuration -> customize…

 

Primo progetto (Symfony 3)

  1. Creare un bundle chiamato MWATestBundle (confermando le opzioni predefinite)
php bin/console generate:bundle - -namespace=MWA/TestBundle - -format=yml

(togli lo spazio tra i due -)

  1. questo aggiunge una riga in app\AppKernel.php e crea, nella cartella src, la cartella MWA/TestBundle che contiene:
  2. Controller: contiene i controllori del bundle (p.e. HelloController.php);
  3. Resources\config: contiene la configurazione, compresa la configurazione delle rotte (p.e. routing.yml);
  4. Resources\views: contiene i template, organizzati per nome di controllore (p.e. Hello/index.html.twig);
  1. modificare il file composer.json
    1. sostituire
      "autoload": {
          "psr-4": { "": "src/" },
          ...
      "autoload-dev": {
          "psr-4": { "": "src/" },
    2. eseguire
composer dump-autoload
  1. L’applicazione si crea dentro il bundle
    1. Il file di default delle rotte si trova in \app\config\routing.yml
    2. Il formato yml è stato deciso in fase di creazione, ma può essere anche PHP o XML
    3. Alla creazione del bundle è stato inserito il relativo routing
  1. Creare una rotta
    1. si edita il file \src\MWA\TestBundle\Resources\config\routing.yml e si aggiunge la nuova rotta aggiungendo le seguenti righe:
random: 
    path: /random/{limit} 
    defaults: { _controller: MWATestBundle:Random:index }
  1. dove path è il percorso (URL); {limit} è un parametro che viene passato
  2. defaults indica il controller da eseguire
  3. Creiamo il controllore di nome Random
    1. dentro \src\MWA\TestBundle\Controller creiamo il file RandomController.php
    2. il controllore ha nome logico MWATestBundle:Random:index, mappato sul metofo indexAction della classe PHP: MWA\TestBundle\Controller\RandomController
    3. < ?php  //unire minore con ?php
      namespace MWA\TestBundle\Controller;
      
      use Symfony\Component\HttpFoundation\Response;
      
      class RandomController
      {
        public function indexAction($limit)
        {
          return new Response(
            '< html><body>Numero: '.rand(1, $limit).'</body></html>'  //unire minore con html
          );
        }
      }
      
    4. il controllore ha un’action che restituisce una response che contiene la pagina html da visualizzare
    5. Quindi, dopo aver digitato
      php bin/console server:run

      andando su:

    6. in sviluppo: http://localhost:8000/app_dev.php/random/10
    7. in produzione: http://localhost:8000/app.php/random/10
    8. PS se c’è un errore bisogna cancellare la cache con:
      1. php bin/console cache:clear –env=prod –no-debug

Template

Al posto di Response  si deve usare render, quindi il controller diventa:

 

< ?php //unire minore con ?php

namespace MWA\TestBundle\Controller;

//use Symfony\Component\HttpFoundation\Response;
use Symfony\Bundle\FrameworkBundle\Controller\Controller;

class RandomController extends Controller
{
public function indexAction($limit)
{
//return new Response('< html>< body>Numero: '.rand(1, $limit).'</body></html>');

$number = rand(1, $limit);
return $this->render(
'MWATestBundle:Random:index.html.twig',
array('number' => $number)
);

// rende invece un template PHP
// return $this->render(
// 'AcmeDemoBundle:Random:index.html.php',
// array('number' => $number)
// );
}
}

 

il template può essere scritto in php o twig, si possono usare entrambi nello stesso progetto.

Il controllore rende il template MSWTestBundle:Random:index.html.twig secondo la regola logica NomeBundle:NomeControllore:NomeTemplate che corrisponde alla posizione fisica /percorso_di_NomeBundle/Resources/views/NomeControllore/NomeTemplate

quindi creiamo il seguente il file

\src\MWA\TestBundle\Resources\views\Random\index.html.twig

{% extends '::base.html.twig' %}

{% block body %}
Numero: {{ number }}!
{% endblock %}

come si vede estende ::base.html.twig template che si trova in app/Resources/views/base.html.twig

 

Composer

Composer server per gestire le dipendenze del progetto

Per installare Composer prima si deve installare php va bene anche un pacchetto LAMP come WampServer poi

  • o tramite file di setup : https://getcomposer.org/download/
  • oppure
php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
php -r "if (hash_file('SHA384', 'composer-setup.php') === '544e09ee996cdf60ece3804abc52599c22b1f40f4323403c44d44fdfdd586475ca9813a858088ffbc1f233e9b180f061') { echo 'Installer verified'; } else { echo 'Installer corrupt'; unlink('composer-setup.php'); } echo PHP_EOL;"
php composer-setup.php
php -r "unlink('composer-setup.php');"
  • Per aggiornare all’ultima versione le librerie del progetto
    • composer update
  • Per installare le dipendenze (spesso dopo un checkout da git/svn)
    • composer install
  • Per verificare se le dipendenze di un progetto contengano vulnerabilità note:
    • php app/console security:check

Symfony 3 – Installazione – con Composer (deprecato)

  1. Installare WampServer
  2. Abilita rewrite_module di Apache: Click sull’icona W vicino l’orologio -> Apache -> moduli Apache -> rewrite_module
  3. Abilita php_xsl.dll di PHP: Click sull’icona W vicino l’orologio -> PHP -> php.ini -> cercare php_xsl.dll e togliere l’eventuale commento iniziale
  4. Aggiungi il percorso di PGP e MySQL al path di sistema: Sistema -> impostazioni di sistema avanzate -> Variabili d’ambiente -> Variabili di sistema -> Path (probabilmente già presenti)
  5. Installare Composer (che è il gestore dei pacchetti per PHP)
  6. Creare una nuova applicazione Symfony, da finestra MSDOS
    1. cd cartella di symfony/www
    2. composer create-project symfony/framework-standard-edition sym01
    3. che crea la cartella sym01, contenente il progetto base
  7. Per verificare il progetto si possono usare dur webserver
    1. Quello integrato in PHP
      1. Dal prompt dei comandi
      2. Posizionarsi nella cartella del progetto
      3. eseguire: php bin/console server:run
      4. dal browser andare su: http://localhost:8000/
      5. Risponde la pagina di Welcome
    2. Quello di WampServer
      1. Con tutti i servizi attivi (icona verde vinol’orologio)
      2. dal browser andare su: http://localhost/NOMEPROGETTO/web/
      3. Risponde la pagina di Welcome

Symfony 3 – Installazione

  1. Installare WampServer che contiene PHP
    1. Abilita rewrite_module di Apache: Click sull’icona W vicino l’orologio -> Apache -> moduli Apache -> rewrite_module
    2. Abilita php_xsl.dll di PHP: Click sull’icona W vicino l’orologio -> PHP -> php.ini -> cercare php_xsl.dll e togliere l’eventuale commento iniziale
    3. Aggiungi il percorso di PGP e MySQL al path di sistema: Sistema -> impostazioni di sistema avanzate -> Variabili d’ambiente -> Variabili di sistema -> Path (probabilmente già presenti)
  2. Creare una cartella temporanea
  3. Scaricare il file symfony con:
    1. Installare Wamp che installera PHP
    2. Andare nella cartella www di Wamp
    3. Scaricare symfony col seguente comando
    4. php -r  "read file ('https://symfony.com/installer');" > symfony

       

      1. PS read file è una sola parola (wordpress va in errore se la scrivo unita)
    5. php symfony
      

      per creare il progetto

      php symfony new progetto

       

    6. che creerà una nuova cartella dal nome progetto
    7. eventualmente possiamo scaricare vecchie versioni
    8. php symfony new progetto2.8 2.8
    9. Per verificare entrare nella cartella progetto (cd progetto)
    10. eseguire
      1. php bin/console server:run
    11. quindi dal browser andare su
      1. http://localhost:8000
      2. Per fare un check di symfony -> http://localhost:8000/config.php
    12. oppure visto che abbiamo creato tutto dentro WebServer
      1. http://localhost/progetto/web

 

In caso di errore del tipo:

GuzzleHttp\Exception\RequestException

Scaricare il file cacert.pem da https://curl.haxx.se/docs/caextract.html

Copiarlo nella cartella del PHP (vedi il path)

Aggiungere seguente riga al file php.ini

curl.cainfo=”D:\wamp64\bin\php\php7.1.9\cacert.pem”

 

[RuntimeException]
The selected version (3.3.12) cannot be installed because it does not exist

Prova a scaricare la 3.3.12 ma no è pronta è un baco che si risolve con:

php symfony new progetto 3.3.11