Dovrebbero seguire altre puntate per completare il discorso, quindi se siete interessati aggiungetelo ai segnalibri.

symfony utilizza come ORM (Object Relational Mapper) Propel, il quale si appoggia a sua volta sull’abstraction layer Creole. Propel per funzionare correttamente ha bisogno di avere una completa descrizione delle tabelle del database. A questo è adibito il file schema.yml dentro alla directory config. Vediamone uno di esempio, contenente la descrizione delle tabelle di un database di un blog.

propel:
  weblog_post:
    _attributes: { phpName: Post }
    id:
    title:       varchar(255)
    excerpt:     longvarchar
    body:        longvarchar
    created_at:
  weblog_comment:
    _attributes: { phpName: Comment }
    id:
    post_id:
    author:      varchar(255)
    email:       varchar(255)
    body:        longvarchar
    created_at:

Ecco, è relativamente semplice. Innanzitutto questa configurazione è fatta utilizzando YAML, un linguaggio di markup che al contrario di XML è più coinciso e sbrigativo. Per ulteriori informazioni consultate il sito ufficiale.

Entriamo ora nei particolari del file; prima di tutto vediamo che come elemento padre c’è “propel:”. Questo è un elemento necessario, e non può essere omesso. Dopo di questo, ogni elemento figlio sarà una tabella del database, col suo vero nome all’interno del DBMS (in questo caso weblog_post e weblog_comment). In seguito il campo particolare “_attributes” definirà alcuni parametri, come il più importante phpName, ovvero il nome che avrà la nostra classe in PHP.

Essendo un argomento troppo vasto da trattare in un singolo post, vi linko ora delle fonti dove trovare dei suggerimenti per la scrittura del vostro file schema.yml

• CheatSheet
• Pagina del symfony book
• Meet Schema.yml

Il prossimo post parlerà degli ultimi dettagli di base per conoscere symfony, e poi partiremo con la realizzazione di un piccolo forum con questo ottimo framework. Alla prossima!

La struttura di un sito realizzato con symfony è la seguente:

• progetto: è il sito stesso.
• applicazione: nel classico esempio dell’applicazione frontend e quella backend.
• modulo: un modulo racchiude azioni che hanno qualcosa in comune. Ad esempio un modulo utente gestirà tutte gli aspetti riguardanti gli utenti
• azione: la parte più piccola. Nel caso del modulo utente, le azioni saranno per esempio visualizzaDati, modificaPassword, effettuaLogin ecc.

Per creare il filesystem necessario allo sviluppo, abbiamo già detto di aver bisogno della riga di comando. Vediamo come si creerebbe la struttura dell’esempio precedente utilizzando il comando symfony.

symfony init-project nomesito
symfony init-app frontend
symfony init-app backend
symfony init-module frontend utente

Con questi comandi creiamo il progetto “nomesito”, le applicazione frontend e backend, ed il modulo utente appartenente all’applicazione frontend.
Vorrei sottolineare il fatto che alla prima applicazione creata verrà associata anche la pagina index.php, ovvero sarà il punto d’ingresso del nostro sito. Sarà possibile ovviamente cambiare questa scelta in seguito, ma è preferibile già da ora fare la nostra decisione.

Queste sono proprio le basi per la creazione delle vostre applicazioni in symony. Per ulteriori informazioni potete consultare l’ottima documentazione ufficiale.

Ora invece passiamo al codice vero e proprio. Nella cartella apps inizialmente vuota ora vi saranno due directory chiamate frontend e backend. Entriamo in quella frontend, scegliamo modules, utente, ed infine actions. Da qui apriamo il file actions.class.php.

Come potete vedere è una classe che si presenta in questo modo:

<?php
/**
 * utente actions.
 *
 * @package    nomeprogetto
 * @subpackage utente
 * @author     Your name here
 * @version    SVN: $Id: actions.class.php 2692 2006-11-15 21:03:55Z fabien $
 */

class utenteActions extends sfActions
{
  /**
   * Executes index action
   *
   */
  public function executeIndex()
  {
    $this->forward('default', 'module');
  }
}

Questa è una tipica classe di azioni. executeIndex è l’azione predefinita (a meno che non si specifichi un’altra tramite la configurazione). Ogni azione raggiungibile dal browser dev’essere preceduta da “execute“, e deve avere la prima lettera maiuscola, ad esempio “executeLogin“, “executeVisualizzaDati“, “executeRegistrazione“. Ora, supponendo che il vostro web server (presumibilmente apache) punti alla directory base del nostro progetto, per accedere tramite browser si dovrà utilizzare questo url:

http://localhost/web/fronted_dev.php/utente

In questo modo punteremo alla directory web, file frontend_dev.php (il nostro front controller), ed al modulo utente. Non essendo specificata l’azione, verrà eseguita quella predefinita, ovvere index.

Ora analizziamo questo:

$this->forward('default','module');

Con questo codice attiviamo una sorta di redirect, che senza far cambiare l’indirizzo al browser, esegue un modulo ed azione differenti. L’accoppiata default/module è quella predefinita, e mostra la pagina di benvenuto di symfony.
Ora cancelliamo quella riga, e trasformiamola in

$this->messaggio = 'Hello, world!';

Ora apriamo il file “apps/frontend/modules/utente/templates/indexSuccess.php” e vi scriviamo dentro

<?php echo $messaggio ?>

Aggiorniamo la pagina del browser, ed ecco che come per magia abbiamo realizzato il nostro hello world in symfony! Fin qui tutto semplice, dalla prossima inizieremo con qualcosa di più complesso. A presto!

Per utilizzare symfony ci sono due modi: uno prevede l’installazione del pacchetto apposito tramite pear, l’altro invece consente di scaricare un file pronto all’uso chiamato sf_sandbox.tgz, che ha già preconfigurati alcuni parametri (come l’utilizzo di sqlite invece di mysql). Personalmente preferisco la prima soluzione, ed è quella che andiamo a spiegare.

Come spiegato nella pagina di download di symfony, per installare il framework tramite pear, basta scrivere da riga di comando:

pear channel-discover http://pear.symfony-project.com

Seguito da

pear install symfony/symfony

Aspettate che pear scarichi il pacchetto, lo decomprima ed installi (tutto automatico), e tutta la potenza dell’ultima versione di symfony sarà nelle vostre mani!

Per poter utilizzare appieno questo strumento è consigliabile avere una certa dimestichezza con la riga di comando, che sia terminale o prompt o l’equivalente del vostro sistema operativo. Infatti per le operazioni di base viene utilizzato il comando “symfony”, ovvero un collegamento allo script che gestisce il framework. Sul mio PC, in Windows Vista è situato in

C:\Program Files\PHP\symfony

mentre in Ubuntu 7.10 è in

/usr/bin/symfony

Non essendo purtroppo utente Mac non posso dire dove si trova questo file. Per gli interessati posso solo consigliare di cercare in rete.

Il comando di base per generare la struttura di file e directory per un nuovo progetto è questo:

symfony init-project nomeprogetto

Questo creerà tutto il necessario per lavorare. Da sottolineare come questo comando non crea una directory “nomeprogetto” formata dalle sottodirectory, ma crea file e cartelle a partire dalla posizione attuale. Perciò è consigliabile, se non obbligatorio utilizzare questo comando in una directory vuota.

Andiamo ora a vedere cosa ha generato questa nostra azione:

/
apps/
batch/
cache/
config/
  config.php
  databases.yml
  propel.ini
  properties.ini
  rsync_exclude.txt
  schema.yml
data/
  model/
  sql/
doc/
lib/
  model/
log/
plugins/
test/
  bootstrap/
    functional.php
    unit.php
  functional/
  unit/
web/
  css/
    main.css
  images/
  js/
  uploads/
    assets/
  .htaccess
  robots.txt
symfony

Questo è symfony. La prossima volta andremo ad analizzare cosa significano le directory più importanti, ed inizieremo finalmente a vedere un pò di codice. Alla prossima!

L’argomento del post di oggi è un framework a cui sono particolarmente “affezionato“: symfony.

Symfony è un framework MVC sviluppato interamente ad oggetti in PHP5. Si basa su propel per la componente Model, su un sistema di classi personalizzato per la componente Controller, e su dei semplici template con PHP embedded per la parte View.
La forza di questo framework sta nell’essere uno strumento “all-in-one”. Ovvero, a fronte di una leggera pesantezza del sistema, si hanno a disposizione strumenti molto potenti e completi. Inoltre è facilmente estendibile, facilitando la realizzazione di plugin.

Tra i suoi difetti, oltre alla già citata pesantezza, vi è una non troppo veloce esecuzione del codice, frutto della mole di dati e classi caricati in memoria ad ogni reload della pagina. Inoltre c’è una forse eccessiva prolissità della sintassi di Propel, ma in questo caso non è colpa di symfony in se. I suoi difetti (a mio parere) finiscono qui, e dall’altra parte troviamo molte ed interessanti caratteristiche:

• File di configurazione basati su YAML, un linguaggio di definizione dati meno prolisso di XML ma altrettanto potente.
• Comoda comandi da shell, per iniziare progetti, moduli, controller e quant’altro.
• Pannello di amministrazione dati realizzato automaticamente a partire da un semplice file YAML.
• Un sistema automatico di caching dell’applicazione.
• Sfruttamento appieno della programmazione ad oggetti (ogni componente è un oggetto, le azioni sono metodi di oggetti..).
• Strumenti per facilitare l’internazionalizzazione dei propri progetti.
• Molto, molto altro.

Non voglio che questa sembri una crociata in favore di questo framework piuttosto che di un altro. Dopo averlo provato, sono ora convinto delle sue grandi potenzialità, soprattutto in progetti di medie/grandi dimensioni.

Dietro questo progetto, vi è una web agency francese, la Sensio. Questo consente di avere un’ottima qualità del codice del framework, e garantisce un costante impegno su di esso. Inoltre, essendo un progetto open-source, ha dalla sua una folta comunità di sviluppatori volontari.

Nei prossimi giorni torneremo a parlarvi di questo framework, facendo degli esempi del suo utilizzo.

Voi utilizzate / vi piacerebbe utilizzare qualche framework? Cosa pensate al riguardo?

Con oggi iniziamo un nuovo argomento, destinato a accompagnarci per un bel pò sulle pagine virtuali di questo blog: la realizzazione di un ORM (Object Relational Mapping) per PHP5.

Scopo dell’articolo odierno è di fornire un’introduzione teorica all’argomento che affronteremo in questa serie di post.

Prima di tutto, cosa si intende con ORM: Un ORM è un componente che detto in maniera semplicistica fa da filtro tra il programma vero e proprio ed i dati del database. Si occupa della manipolazione delle tuple del DB, astraendo i comandi e evitando al programmatore di dover andare ad accedere direttamente ai dati. Se utilizzate un ORM in pratica vedrete spesso scritte come queste

$comment->getID();

$post->getAuthor()->getName();

e molto meno come queste

$result = mysql_query("select id from comments");

$result = mysql_query("select name from posts inner join authors on posts.author_id = author.id");

A me sembra più comodo e pratico, credo anche a voi.

L’immagine in cima al post (cliccateci per l’originale più grande e leggibile) spiega com’è implementato tutto ciò nel framework symfony: Propel (un ottimo ORM, forse un pò prolisso nella sintassi) si appoggia su Creole (lo strato che fisicamente si collega al DB, fa le query ecc.) e rende trasparente l’accesso al database da parte del programmatore.

Per semplicità io includerò tutto in un unico componente, realizzato in classi e sfruttando le capacità di PHP5. Chiedo ai lettori di correggermi nel caso troviate degli errori (sono umano anch’io, e l’ORM lo realizzo man mano che scrivo gli articoli) e di darmi consigli, saranno tutti bene accetti.

Ho deciso che l’ORM utilizzerà solo MySQL, in quanto sinceramente ho poca esperienza con altri tipi di RDBMS, e essendo un prodotto “artigianale” non ha molto senso andare a sbattere la testa con problemi di scelta del gestore dati. Realizzerò il componente in modo tale sia più semplice possibile andare a sopperire a questa mancanza, magari aggiungendo un singolo file con le istruzioni necessarie.

Rimando alla voce di wikipedia (o alla più completa versione in inglese) per ulteriori delucidazioni sulla parte teorica.

Nel prossimo articolo (online presumibilmente tra pochi giorni) inizieremo a vedere la struttura vera e propria del componente, la gerarchia dei file e concluderemo la parte teorica.

Il design pattern MVC identifica 3 livelli all’interno dell’architettura di un’applicazione:

• il model rappresenta l’informazione che vogliamo rappresentare e su cui l’applicazione lavora, è quella che possiamo definire business logic
• il view è come rappresentiamo il model e quindi l’informazione permettendo l’interazione da parte dell’utente
• il controller è il motore vero e proprio dell’applicazione risponde alle azioni dell’utente tramite la vista e chiede i dati al model facendo da tramite tra i due layer

L’architettura MVC separa quindi la business logic (model) e la sua presentazione (view), rendendo il codice molto più facile da mantere ed aggiornare. Tale metodologia di design delle applicazioni è rivolta principalmente a progetti di media e grande dimensione visto che richiede una minuziosa progettazione e pianificazione per essere realizzato.

CONSIGLIATI:
Understanding MVC in PHP
The MVC Pattern

Leggo un’interessante lista di indizi dal blog di Reinhold Weber che secondo lui bastano a definire davvero scarso (schifoso sarebbe la traduzione esatta) un programmatore PHP. Si tratta di 40 “regole” di buona programmazione e progettazione che ci invitano a riflettere sul proprio modo di agire e sperano di scatenare qualche buon proposito per migliorarsi.

Su alcuni concordo più che su altri:

• non commenti il codice con qualcosa tipo phpDoc, io aggiungo non commenti il codice e basta
• non esegui l’escaping e la validazione di input e delle query sql (di cui abbiamo parlato)
• non pianifichi, progetti la tua applicazione in modo dettagliato prima di cominciare a scrivere codice
• non tieni separati i diversi layer utilizzando qualcosa basato su MVC (model-view-control)
• non ha mai sentito parlare di sql injection or cross-site scripting (Xss)
• non usi un abstraction layer per interagire con i database
• …

E voi cosa ne pensate? Lasciate pure la vostra opinione nei commenti qui sotto.