26. Messa in produzione di un progetto

Con la programmazione ad oggetti abbiamo introdotto il paradigma MVC, che consiste nel tener separate la definizione degli oggetti, logiche di controllo e le viste. Un modo ottimale per gestire le viste consiste nell'utilizzo file HTML contenenti il markup dell’elemento, ma con dei valori segnaposto che vengono sostituiti di volta in volta. Questi file HTML vengono chiamati template. Ogni volta che dovrà essere stampato un elemento di quel tipo (si pensi ad esempio a degli articoli) il codice PHP prenderà il template, sostituirà i valori segnaposto con quelli reali ed eseguirà la stampa.

Il vantaggio di questo approccio è ancora una volta nella manutenzione del codice, perché il codice HTML sarà separato dal codice PHP e sarà possibile riutilizzarlo tutte le volte che serve.

Facciamo un esempio su come avviene la gestione: supponiamo di dover inserire in una pagina una serie di articoli. Il codice degli articoli sarà sempre uguale, cambieranno solo i contenuti. Quindi possiamo creare un file che chiameremo articolo.html fatto in questo modo:

<div class=”articolo” >
	<h1> _titolo_ </h1>
	<h2> _sottottitolo_ </h2>
	<p> _testo_ </p>
</div>

possiamo poi creare una funzione PHP che recupera queste informazioni e sostituisce gli articoli ogni volta:

	function renderizzaArticoli($titolo, $sottoTitolo,$testo) {
		$codice = file_get_contents(“articolo.html”);
		$codice = str_replace(“_titolo_”,$titolo);
		$codice = str_replace(“_sottottitolo_”,$sottottitolo);
		$codice = str_replace(“_testo_”,$testo);
		echo $codice;
	}

In questo modo il codice per recuperare gli articoli potrebbe essere:

	$query = “SELECT * FROM articoli”;
	if(!$risQuery = $db->query($query)) {
                    echo "Errore durante l'esecuzione della query: ".$db->error;
                    echo "<br>$query";
                exit();
          }

	while($articolo = $risQuery→fetch_assoc()) {
		renderizzaArticoli($articolo[“titolo”], $articolo[“sottoTitolo”],$articolo [“testo”]);
	}

Creiamo una funzione più generalista

La funzione renderizzaArticoli vista sopra svolge il suo dovere per stampare gli articoli ma è troppo specializzata, possiamo usarla solo per questo compito. Questo approccio non è l’ideale, perché ci costringe a creare una funzione per ogni oggetto che dobbiamo renderizzare. 

La soluzione migliore è costruire una funzione generalista, che non prenda parametri precisi ma un template e un array di parametri, che sostituisce di volta in volta:

	function renderizza($template, $parametri) {
		$codice = file_get_contents($template);
		foreach($parametri as $etichetta => $valore) {
                		$ codice = str_replace("_$etichetta_",$valore,$codice);
            	}
		echo $codice;
	}

Possiamo quindi riscrivere il codice visto sopra in questo modo:

	$query = “SELECT * FROM articoli”;
	if(!$risQuery = $db->query($query)) {
                    echo "Errore durante l'esecuzione della query: ".$db->error;
                    echo "<br>$query";
                exit();
          }

	while($articolo = $risQuery→fetch_assoc()) {
		renderizza(“articolo.html”,array(“titolo”=>$articolo[“titolo”], ”sottoTitolo”=> $articolo[“sottoTitolo”], ”testo”=>$articolo [“testo”]));
	}

In questo modo quando vorremmo utilizzare la stessa funzione per stampare altri tipi di elementi ci basterà cambiare il template HTML e i parametri dell’array. Un’altra ottimizzazione è quella di chiamare i campi della tabella e del template HTML allo stesso modo, in modo da passare direttamente l’array associativo ricavato dalla variabile $risQuery. Vediamo un esempio:

	$query = “SELECT titolo, sottoTitolo, testo FROM articoli”;
	if(!$risQuery = $db->query($query)) {
                    echo "Errore durante l'esecuzione della query: ".$db->error;
                    echo "<br>$query";
                exit();
          }

	while($articolo = $risQuery→fetch_assoc()) {
		renderizza(“articolo.html”,$articolo);
	}

Le sessioni sono un modo che ha il PHP per ricordare dei valori da una pagina ad un’altra. Vediamo un esempio:

	session_start();

	$_SESSION[“nome”] = “Mario”;

Con questo codice ho creato una variabile di sessione dove memorizzo che nome = Mario. Quindi, quando nelle altre pagine PHP faremo riferimento a quella variabile, riceveremo il valore Mario. Ad esempio supponiamo di voler stampare la variabile di sessione nome creata sopra. Scriveremo:

	session_start();

	echo $_SESSION[“nome”];

session_start() e session_destroy()

Quando vogliamo usare le sessioni in una pagina PHP dobbiamo utilizzare la funzione session_start(). Se nei due esempi precedenti togliessimo la session_start il codice genererà un errore, perché la variabile globale $_SESSION non è visibile.

Un esempio molto comune: lo script per il login

Supponiamo che l’utente abbia effettuato il login ad un portale web: ha inserito le credenziali, il nostro codice PHP ha fatto una query e ha appurato che l’utente esiste. Per fare in modo che PHP si ricordi che l’utente ha già effettuato il login bisogna usare questo codice:

	session_start();

	$_SESSION[“nomeSessione”]  = “valore a piacere”;

nelle pagine in cui vogliamo controllare che una determinata sessione sia presente, scriveremo un codice che, se la sessione non esiste l’utente viene rediretto in un’altra pagina:

	session_start();

	if(!isset($_SESSION["idUtente"])) {

		header("Location: accessonegato.php");

	}

Eliminare una sessione

Quando una sessione non è più necessaria può essere eliminata con la funzione unset() vista anche per gli array.

	unset($_SESSION[“nomeSessione”]);

Se dobbiamo eliminare tutte le sessioni, ad esempio quando un utente ha effettuato il logout, possiamo usare session_destroy(). Prima di invocare session_destroy() bisogna invocare session_start(), vediamo un esempio qui sotto:

    session_start();	

    session_destroy();

    header("Location: index.php");  

l’ultima riga di codice serve per effettuare un redirect ad un’altra pagina, cosa da fare nella stragrande maggioranza dei casi dopo che un utente ha effettuato un logout.

Vediamo ora altri due concetti fondamentali nella programmazione ad oggetti: le interfacce e l’ereditarietà. Le prime servono per standardizzare il codice, l’ereditarietà invece serve per ottimizzare il codice scritto ed evitare ripetizioni.

Interfacce

Le interfacce vengono utilizzate per definire un tipo di dato e una classe, che però non viene implementato. Vengono definite solo le firme dei metodi che poi saranno implementate in altre classi. Vediamo un esempio di interfaccia:

public interface Libro {

	public void stampaLibro();

	public void setTitolo(String titolo);

	public String getTitolo();

	public void setNumeroPagine(int numeroPagine);

	public int getNumeroPagine();

}

Per usare una determinata interfaccia dopo il nome della classe dobbiamo usare la parola chiave implements seguita dal nome dell'interfaccia. Appena facciamo questo il nostro IDE ci segnalerà che i metodi dell'interfaccia non sono ancora implementati, clicchiamo su add unimplementated methods (potrebbe cambiare a seconda dell’ide usato) e il nostro IDE li aggiungerà per noi, dobbiamo solo completarli con il codice all'interno.

In sostanza le interfacce consentono di standardizzare il codice: due programmatori si accordano sui metodi e su come vengono chiamati, e poi ai fini dell'interoperabilità delle classi non è importante come viene implementato. Nel tempo le implementazioni possono cambiare, ma rispettandole interfacce non ci saranno problemi di incompatibilità

Ereditarietà

Ci sono casi in cui dobbiamo creare classi molto simili tra loro. Per questo molti linguaggi di programmazione consentono di usare il meccanismo dell’ereditarietà. Supponiamo di avere bisogno di queste due classi:

• Utente
  id, nome, cognome, indirizzo, telefono
• Fornitore
  id, nome, cognome, indirizzo, telefono, partita IVA

notiamo che Fornitore è quasi uguale alla classe Utente, quindi non ha senso riscriverla. Quando creiamo la classe Fornitore che estenderà la classe Utente.

Anatomia di una classe

Ogni classe è composta da tre tipi di elementi:

Variabili

le variabili di una classe si dichiarano come le variabili che abbiamo sempre visto, ovvero specificando il tipo di dato (int, double, String e così via) ma in più dobbiamo specificare il tipo di accesso, ovvero public, private, protected. Questo è necessario per utilizzare una caratteristica della programmazione ad oggetti, l’incapsulamento, che vedremo più avanti.

Metodi

I metodi rappresentano le operazioni che possono essere eseguite dagli oggetti di quella classe. Come le funzioni, i metodi possono avere parametri in input e possono essere usati per eseguire le operazioni più varie. Possono anche avere parametri preimpostati come visto nel capitolo delle funzioni.

Anche nei metodi usiamo un indicatore di accesso tra public, private, protected.

Costruttore

una casse di per se è solo un elenco di metodi e variabili, definisce il comportamento di un oggetto ma non viene eseguita direttamente, per utilizzarla dobbiamo creare un oggetto di quel tipo. Per questo ogni classe ha un metodo speciale chiamato costruttore, che serve a creare l’oggetto su cui noi possiamo poi usare i metodi definiti nella classe. Può prendere in input dei parametri con i quali inizializzerà le variabili di classe. Il costruttore si invoca con la parola chiave new seguita dal nome della classe e i parametri che abbiamo stabilito nel costruttore.

Cosa succede quando invochiamo un costruttore?

Quando invochiamo un costruttore di una classe viene creato un oggetto che ha al suo interno le variabili definite da quella classe, che ci mette a disposizione i metodi definiti nella classe. Per ogni classe possiamo creare tutti gli oggetti che vogliamo.

Metodi statici

PHP consente di creare metodi statici, che sono cui metodi il cui output sempre uniforme, che non dipende da variabili di classe. Quando creiamo un oggetto che è un’istanza di una classe normale PHP creerà un oggetto di quella classe su cui noi possiamo eseguire i metodi.  Se invece vogliamo invocare un metodo statico la sintassi è diversa: dobbiamo scrivere il nome della classe seguito dai 2 punti seguiti dal nome del metodo, ad esempio:

	NomeClasse::nomeMetodo();

I metodi statici devono essere preceduti dalla parola chiave static e possono essere utilizzati senza creare un costruttore. Dal momento che i metodi statici possono essere invocati in qualsiasi contesto non possiamo inserire al loro interno eventuali variabili di classe.

Esempio di metodo statico

Vediamo un esempio di metodo statico: immaginiamo di avere una classe esempio con un metodo statico che prende in input un link e un titolo e li stampa in un codice HTML.

class Esempio {

         static function visualizzazioneArticolo($linkContenuto,$titolo) {

            echo"<div class=\"articolo\">

                <h2 class=\"title\"><a href=\"$linkContenuto\">{$titolo}</a></h2>

            </div>\n";

        }

}

Per utilizzare questo metodo scriveremmo:

	Esempio::visualizzazioneArticolo($link,$titolo);

Nota: i metodi statici non possono usare variabili istanza, se proviamo ad accedere ad una proprietà non statica (ad esempio una variabile di classe) otterremo un errore, ad esempio il seguente codice:

class Esempio {
         static function visualizzazioneArticolo() {
            echo"<div class=\"articolo\">
                <h2 class=\"title\"><a href=\"$this->linkContenuto\">{$this->titolo}</a></h2>
            </div>\n";
        }
}

Genera un errore di questo tipo:

Fatal error: Using $this when not in object context in …

Questo perché noi abbiamo provato ad invocare una variabile istanza in un metodo statico, ma dato che quando si usa un metodo statico non è stato proprio creato un oggetto quella variabile non esiste.

Il paradigma MVC

La programmazione ad oggetti è utilizzata nel paradigma MVC (Model, View, Controller), che consente una separazione delle logiche. Vediamo i tre elementi nel dettaglio:

• model
  sono le classi cosi come le abbiamo viste. Quando creiamo una classe infatti definiamo degli oggetti ma non li usiamo in quell’istante
• view
  le viste rappresentano la parte del progetto che mostra i dati visivamente
• controller
  sono i file che consentono di rendere permanenti le operazioni sugli oggetti: creazione di nuovi elementi, modifica di elementi esistenti, eliminazione di elementi e anche recupero dei dati di un elemento. I controller nascondono le logiche sottostanti alle altre classi: potremmo voler salvare i dati in un file oppure nel database, per le classi esterne viene chiamato lo stesso metodo. Facendo passare tutte le operazioni di salvataggio, modifica, caricamento per il controller avremo solo una classe che gestisce queste operazioni, che si traduce in un vantaggio per la manutenibilità del codice, in quanto per apportare modifiche alla gestione degli oggetti dovremmo modificare solo la classe relativa.