30. Classi per interrogare PHP

Posted Mer, 11/26/2008 - 14:16 by Francesco Casula

In questo capitolo costruiremo una classe PhpService per inviare e ricevere dati con PHP in codifica URL, derivando la classe da EventDispatcher.
Questo ci consentirà di gestire gli eventi che ci interessano nel nostro script, aggiungendo eventuali listener direttamente alle istanze di PhpService, come mostrato nel capitolo Gestire gli Eventi.

La nostra classe conterrà quattro attributi :

  • private var vars:Array; (Array che conterrà tutte le variabili che saranno inviate allo script PHP in codifica URL)
  • private var script:String; (Stringa che indica il nome della pagina PHP che conterrà lo script di nostro interesse)
  • public var response:URLVariables; (Conterrà i dati restituiti dallo script PHP in seguito alla richiesta HTTP)
  • public static var scriptPath:String; (Variabile statica utilizzata per impostare l'URL di base dove risiedono gli script PHP)

Il costruttore di classe prenderà in input un solo valore che indicherà il nome del file PHP che conterrà lo script di nostro interessa (attributo script).

Prima di dare un'occhiata al codice vediamo quali metodi costituiscono il corpo di classe :

  • public function reset():void
    Azzera l'array di variabili che contiene i dati da inviare allo script PHP.
  • public function addVar(name:String, content:String):void
    Ogni chiamata al metodo aggiunge una variabile all'array di dati che verrà inviato allo script PHP in codifica URL.
    Il metodo prende due parametri : il primo rappresenta il nome della variabile come verrà letta in PHP attraverso l'array globale $_POST[], mentre il secondo rappresenta il valore contenuto nella variabile.
  • public function request():void
    Effettua la richiesta HTTP contattando lo script, inviando e ricevendo i dati con quest'ultimo.
  • public function completeHandler(event:Event):void
    Memorizza la risposta dello script PHP nell'attributo pubblico response e solleva l'evento Event.COMPLETE.

Di seguito riporto il codice del costruttore e dei primi due metodi, molto semplici :

// Costruttore della classe
public function PhpService(PhpScript:String = "default.php"):void
{
	// Memorizza il nome del file PHP che contiene lo script di interesse
	this.script = PhpScript;
	// Inizialliza un array vuoto di variabili per l'invio dei dati allo script PHP
	this.vars = new Array();
}

public function reset():void
{ this.vars = new Array(); }

public function addVar(name:String, content:String):void
{
	/*
	La sintassi che segue permette di inserire nell'elemento di un array
	direttamente un oggetto dinamico con due proprietà "name" e "content"
	*/
	this.vars.push({name: name, content: content});
}

Il prossimo metodo, request, riutilizza il codice visto nel precedente capitolo, con la differenza di una gestione più completa delle variabili che andrà a leggere dall'array vars, per poi trasformarle in codifica URL pronte da inviare allo script PHP.

 
public function request():void
{
	var urlencoded:String = new String();

	/* Il ciclo "for" che segue, legge gli elementi dell'array vars e li
	trasforma in una stringa con la codifica URL per l'invio allo script PHP */

	for (var i:uint = 0; i < this.vars.length; i++)
	{
		urlencoded += this.vars[i].name + "=" + this.vars[i].content;
		if ((i + 1) < this.vars.length) urlencoded += "&";
	}

	try
	{
		var variables:URLVariables = new URLVariables(urlencoded);

		var loader:URLLoader = new URLLoader();
		loader.dataFormat = URLLoaderDataFormat.VARIABLES;
		loader.addEventListener(Event.COMPLETE, completeHandler);

		var request:URLRequest = new URLRequest(PhpService.scriptPath + this.script);
		request.method = URLRequestMethod.POST;
		request.data = variables;

		loader.load(request);
	}
	catch (error:Error)
	{ trace("Errore di connessione."); }
}

Per ultimo vediamo il metodo completeHandler, il quale memorizzerà la risposta dello script nell'attributo response e solleverà l'evento Event.COMPLETE in modo da poterlo ricatturare e gestire nella classe documento.

private function completeHandler(event:Event):void
{
	var loader:URLLoader = URLLoader(event.target);
	this.response = new URLVariables(loader.data);

	super.dispatchEvent(new Event(Event.COMPLETE));
}

Potete vedere il codice della classe al completo qui.

Di seguito un esempio di classe documento dove viene utilizzata un'istanza di PhpService.

HelloWorld.as

package
{
	import PhpService;
	import flash.events.Event;
	import flash.display.MovieClip;

	public class HelloWorld extends MovieClip
	{
		private var phpserv:PhpService;

		public function HelloWorld():void
		{
			PhpService.scriptPath = "http://localhost/realizzazionesito/";

			this.phpserv = new PhpService("servizio.php");
			this.phpserv.addVar("utente", "mario");
			// this.phpserv.addVar("utente2", "luca");
			// this.phpserv.addVar("utente3", "giovanni");
			this.phpserv.addEventListener(Event.COMPLETE, completeHandler);
			this.phpserv.request();
		}

		private function completeHandler(evt:Event):void
		{
			trace("Return : " + this.phpserv.response);
		}
	}
}

Per la costruzione di una classe più robusta che possa soddisfare i bisogni di un'applicazione reale, vi consiglio di completare il codice di PhpService, aggiungendo la gestione degli eventi che seguono :

addEventListener(Event.COMPLETE, completeHandler); // Questo è già implementato
addEventListener(Event.OPEN, openHandler);
addEventListener(ProgressEvent.PROGRESS, progressHandler);
addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
addEventListener(HTTPStatusEvent.HTTP_STATUS, httpStatusHandler);
addEventListener(IOErrorEvent.IO_ERROR, ioErrorHandler);

AllegatoDimensione
PhpService.as1.77 KB