In PHP, ogni volta che una pagina contenente del codice di scripting viene richiamata, questa viene analizzata e precompilata in codice intermedio, che successivamente viene leggermente ottimizzato ed eseguito. Come è possibile dedurre, il processo di compilazione ed ottimizzazione viene effettuato sempre, indipendentemente dal fatto che la pagina sia stata modificata o meno.

[ad code=4 align=center]

APC (Alternative PHP Cache) è un’estensione nativa per PHP che svolge principalmente il compito di precompilare, ottimizzare e mantenere in memoria il codice intermedio associato agli script PHP in modo che venga bypassato questo passaggio dopo la prima richiesta effettuata ad un file PHP.

Installare e configurare la libreria in Windows

Probabilmente quando uscirà PHP 6 questi includerà nativamente il supporto ad APC, alla quale verranno fatte alcune migliorie ed ottimizzazioni al fine di adattarsi alle modifiche che verranno apportate allo Zend Engine. Aspettando quel tempo, possiamo comunque installare ed utilizzare APC poiché essa èuna libreria nativa compatibile sia con PHP 4 sia con PHP 5.

Il processo di installazione è il solito che si usa seguire quando è necessario aggiungere nuove librerie native per PHP. Nel caso di utenti Windows è possibile scaricare la DLL precompilata della libreria (che potete trovare direttamente sul sito di PHP), posizionarla all’interno della directory contenente le altre estensioni ed infine abilitarla da file php.ini utilizzando la direttiva

extension=php_apc.dll

Nel caso di sistemi Debian:

Innanzitutto abbiamo bisogno che sul nostro server sia installato PECL, una applicazione che ci permetterà di installare APC, quidni dopo aver installato un server Apache basterà lanciare il seguente comando

pecl install apc

Ora ci verranno fatte un paio di domande durante la fase di installazione, digitiamo il tasto INVIO per andare avanti durante la fase di installazione.

-Adesso che APC è installato non ci resta che abilitarlo nella configurazione del PHP:

modifichiamo il file php.ini (normalmente lo trovate alla seguente posizione: /etc/php5/apache2/php.ini) ed inseriamo all’interno del file le seguenti regole:

extension=apc.so

apc.enabled=1

apc.shm_size=32M

Adesso salviamo il file e riavviamo Apache:

/etc/init.d/apache2 restart

Come utilizzare APC

Nonostante molte operazioni della libreria APC vengano svolte in modo trasparente durante l’esecuzione dello Zend Engine è possibile interrogare APC ed utilizzare alcune caratteristiche interessanti esposte dalla libreria.
Spesso può risultare utile, soprattutto in fase di debugging o quando avvengono errori ed eccezioni inaspettate, conoscere lo stato della cache di APC per poter comprendere se questa ha influito sul malfunzionamento. Per ottenere un array associativo contenente i metadati relativi allo stato attuale della cache utilizziamo la funzione apc_cache_info.
La cache viene ripulita automaticamente da APC in base alle direttive specificate in fase di compilazione utilizzando delle funzioni avanzate di garbage collection che permettono anche il riciclo della cache marcata per l’eliminazione. Nel caso fosse necessario è possibile comunque ripulire la cache manualmente utilizzando la funzione apc_clear_cache.
Non so se è una cosa nota a tutti, ma definire costanti attraverso la funzione define di PHP è un’operazione molto lenta. Sebbene sia buona norma non abusare di questa funzione, fortunatamente possiamo sfruttare APC per definire costanti in modo molto veloce: la funzione apc_define_constants accetta come primo parametro una stringa per identificare con un nome univoco un gruppo di costanti, come secondo parametro un array chiave/valore che rappresenta le costanti da definire ed opzionalmente un terzo parametro che indica se trattare le costanti come case sensitive o no; dopo aver definito questo gruppo di costanti, è possibile utilizzare apc_load_constants per inserirle all’interno dello scope globale specificando come unico parametro la stringa che rappresenta il gruppo di costanti da caricare. Anche in questo caso abbiamo a disposizione un parametro aggiuntivo che indica se trattare le costanti in modo case sensitive o no.
L’ultima, utilissima, funzionalità di APC è quella che permette di salvare in memoria condivisa delle variabili in modo che risultino persistenti tra richieste diverse. Possiamo salvare risultati di interrogazioni o elaborazioni molto complesse, assicurandoci che queste non vengano più eseguite per un determinato lasso di tempo. Tramite la funzione apc_store, che accetta come parametri l’identificativo della variabile da salvare, il valore della variabile ed un numero indicante i secondi di vita della stessa, possiamo salvare in memoria condivisa dei dati. Successivamente questi possono essere recuperati attraverso apc_fetch che accetta come parametro l’identificativo riferito ai dati salvati o rimossi manualmente utilizzando apc_delete.

Dalle ultime versioni della libreria è possibile passare un array alla funzione apc_fetch in modo da recuperare in un colpo solo tutti i valori necessari, evitando chiamate ripetitive alla funzione. È utile ricordare anche che apc_store pare non funzionare correttamente nel caso venga passato come secondo parametro un array; per ovviare al problema è possibile utilizzare l’oggetto ArrayObjects disponibile con PHP5.

che ne pensate dell’utilizzo della cache per le vostre applicazioni?

Il Singleton è un design pattern creazionale

Quello che andrò a realizzare è un Singleton in PHP per ottenere cosi l’istanza della mia classe.

[ad code=4 align=center]

class MyClass{
 //
 // utilizzo un Singleton per creare una sola istanza di questa classe.
 //
 private static $instance;

 /**
 * =---------------------------------------------------------------------=
 * getInstance
 * =---------------------------------------------------------------------=
 * Un metodo statico che restituisce un'istanza dell'oggetto MyClass.
 * Creo sola una di questa, in modo da restituire la stessa istanza
 * su ripetuti appelli di questo metodo.
 *
 * @return $instance MyClass.
 */
 public static function getInstance() {
    if (MyClass::$instance === NULL) {
       MyClass::$instance = new MyClass();
    }
    return MyClass::$instance;
 }

/**
* =---------------------------------------------------------------------=
* __construct()
* =---------------------------------------------------------------------=
* Il costruttore di MyClass, settato come metodo privato
*/
 private function __construct() { }

}

Quindi ora per richiamare un istanza della nostra classe basterà richiamare il metodo statico getInstance()

require_once 'myclass.php';
$myInstance = MyClass::getInstance(); //Creo un istanza dell'oggetto MyClass

Riccardo Tartaglia

PhpProxy è un web proxy http molto semplice da installare e adattabile a tutte le necessità.

Per poterlo utilizzare basta scaricarlo: Download PhpProxy

[ad code=4 align=center]

e caricare il contenuto in una cartella del vostro provider e settare correttamente i permessi (777).

Piccola precisazione: Per poter supportare il protocollo https bisogna aver installato sul proprio server il modulo php openssl

Allora che ve ne pare? Avete usato altri metodi?

Riccardo Tartaglia

Per ovviare a questo problema ho realizzato una piccola pagina php che in pratica registra un identificatore per ogni sessione inizializzata dall’accesso di un utente, se questo identificatore non è presente nella tabella viene aggiunto, se esso è invece già presente viene aggiornato il dato relativo al momento del suo accesso; nel caso in cui il momento di accesso di un utente sia inferiore al timestamp ottenuto sottraendo 5 minuti (300 secondi) dal risultato della funzione time(), il record corrispondente verrà eliminato considerando l’utente non più online.

Vi lascio il codice

[ad code=4 align=center]

<?php
// inizializzazione della sessione
session_start();
// creazione dell'identificatore di sessione
$sessione = session_id();
// memorizzo il tempo in cui l'utente si è connesso
$time = time();
// definizione dell'intervallo di tempo valido per l'utente connesso
$intervallo = $time-300; //dopo 300 secondi(5 minuti) di inattività l'utente sarà considerato off

//Effettuo la connessione
$connessione = mysql_connect('localhost','root','');
mysql_select_db('mydb');

// confronto tra identificatore di sessione e dati in tabella
$sql_confronto = "SELECT * FROM utenti_on_line WHERE sessione='$sessione'";
$res_confronto = mysql_query($sql_confronto) or die(mysql_error());

// se l'identificatore non è presente viene creato un nuovo record
if(@mysql_num_rows($res_confronto) == 0){
   $sql_inserimento = "INSERT INTO utenti_on_line(sessione, timestamp)VALUES('$sessione', '$time')";
   $res_inserimento = mysql_query($sql_inserimento) or die(mysql_error());
} else {
   // se l'identificatore è già presente viene aggiornato il
   // valore relativo al momento di connessione
   $sql_aggiornamento = "UPDATE utenti_on_line SET timestamp='$time' WHERE sessione = '$sessione'";
   $res_aggiornamento = mysql_query($sql_aggiornamento) or die(mysql_error());
}

// cancellazione dei record obsoleti
$sql_cancellazione = "DELETE FROM utenti_on_line WHERE timestamp<$intervallo";
$res_cancellazione = mysql_query($sql_cancellazione) or die(mysql_error());

// estrazione dei record presenti in tabella per il conteggio
$sql_conteggio = "SELECT id FROM utenti_on_line";
$res_conteggio = mysql_query($sql_conteggio) or die(mysql_error());
$conteggio = mysql_num_rows($res_conteggio);

// stampa a video del conteggio
echo "Utenti online: " . $conteggio; 

// chiusura della connessione
@mysql_close();
?>

Alla prossima
Riccardo Tartaglia

Beh la risposta è semplice, sono file XML specifici per i blog grazie ai quali è possibile rimanere sempre aggiornati ogni volta che c’è un nuovo post utilizzando un semplice lettore di feed. Per maggiore chiarezza vi lascio questo video che sicuramente saprà schiarivi le idee su cosa sono realmente i feed e quale è il loro potenziale

Bene ora che abbiamo un idea su cosa siano i feed, andiamo a vedere come crearne uno con PHP e XML

Il linguaggio XML è stato creato da W3C e a differenza dell’ HTML deve rispettare alcune regole ferree, regole che peraltro sono definite dallo stesso programmatore e regolamentate da pagine di controllo (dtd – Document Type Definition) anch’esse compilate dal programmatore.

I Feed come detto precedentemente sono notoriamente associati alle news, ma niente ci impedisce di utilizzare un feed per qualsiasi altro tipo di informazione purché legato ad un database.

Ma vediamo ora un esempio di feed generato con php:

<?php
 header("Content-type: text/xml; charset=utf-8");//dichiaro che sto per scrivere una pagina in XML con php 

 echo ("<rss version=\"2.0\">");//versione rss
 echo ("<channel>")//inizio channel
 echo ("<title> titolo feed </title>");//titolo rss
 echo("<link> http://www.vostrosito.it/index.php </link>");//link rss
 echo ("<description> descrizione feed </description>");//descrizione rss
 echo "<copyright> Copyright 2010 proprietario </copyright>\n";//copiright
 echo "<docs>http://blogs.law.harvard.edu/tech/rss</docs>\n";//documento di informazione sulle specifiche dell'rss in oggetto
 echo "<managingEditor> email@vostrosito.it </managingEditor>\n";//email del compilatore
 echo "<webMaster> email@vostrosito.it </webMaster>\n";//email del webmaster
 echo ("<language>IT-it</language>");//linguaggio

//Connessione e query al mio DB
$conn = @mysql_connect($host,$user,$password);//le vostre variabili di connessione database
$db = mysql_select_db('database');
$result = mysql_query("SELECT * FROM tabella ORDER BY id DESC LIMIT 5");//estraggo  gli ultimi 50 valori inseriti nel database e li ordino per id ( o qualunque altro nome colonna che indichi una data di inserimento)
while($row = mysql_fetch_assoc($result)){
   echo "<item>
           <title>".$row['titolo']."</title>";//titolo
   echo"<link>$row['link']</link>";//Link titolo. Potete anche inserire URL dinamici, ma SEMPRE ASSOLUTI (HTTP://www....)
 echo"<description>";//Inizio descrizione informazione
 echo"<![CDATA[";//Tutto quello racchiuso fra <![CDATA[ e ]]> sarà scritto a video
 echo"<font color=\"#C0C0C0\">Articolo:
 ".$row['testo']."
 </font>
 <br>
 <a href=".$row['link'].">
 Continua...
 </a>
 ]]>";//fine <![CDATA]
 echo"</description>";//fine descrizione
 echo"<guid>link all'articolo</guid>"; //Inserisci un URL univoco dell'informazione
 echo"<category domain\"link alla categoria\">link alla categoria</category>";//Inserisci la categoria dell'informazione
 echo"</item>";//fine item
 }
 echo "</channel></rss>";//fine channel e rss
 ?>

Ed ecco qui il vostro feed creato in poche righe di codice.

Che ne pensate?

Riccardo Tartaglia

In questo breve articolo vi illustrerò tutte le funzioni che PHP ci mette a disposizione per poter risolvere facilmente questo problema, basta cliccare sul nome della funzione per essere indirizzati sul sito di PHP.net per una descrizione approfondita:

[ad code=4 align=center]

• fopen: Permette di aprire un file in diverse modalità (lettura/scrittura/append) o di crearlo se iniesistente
• fgets o fread: Permettono la lettura di un file gia creato
• file : Legge il file e lo inserisce in un vettore
• fwrite: Scrive in un file
• fclose: Chiude un file aperto con fopen

Logicamente la gestione dei file con php può essere effettuata solo per file che sono fisicamente presenti sul server, e non lato client.

E voi? Avete qualche pezzo di codice da condividere per approfondire l’argomento?

Riccardo Tartaglia

Il gestore di pacchetti Apt (Advanced Package Tool) nasce all’interno del progetto Debian come erede di dpkg, il precedente gestore di pacchetti di Debian, uno dei primi in ambiente Linux. Una caratteristica importante, peraltro oggi presente in molti gestori di pacchetti, è la gestione automatica delle dipendenze: installando un programma, Apt si preoccuperà di installare tutti i pacchetti da cui tale programma dipende, evitando quindi laboriose ricerche ed installazioni manuali. Altra caratteristica è la possibilità di specificare diverse sorgenti da cui reperire i pacchetti: un archivio accessibile via HTTP o FTP, il cd-rom di installazione oppure il file system locale.

[ad code=4 align=center]

Ma procediamo passo passo con l’installazione

• Aggiornamento della lista dei pacchetti disponibili (è buona norma effettuarlo sempre prima di nuove installazioni):

  sudo apt-get update

• Installazione di Apache2:

  sudo apt-get install apache2-mpm-prefork

• Installazione di MySQL:

  sudo apt-get install mysql-server

• Installazione del modulo PHP5 per Apache2:

  sudo apt-get install libapache2-mod-php5

• Installazione della libreria per l’utilizzo di MySQL da PHP5:

  sudo apt-get install php5-mysql

• Installazione della libreria PHP per la manipolazione delle immagini:

  sudo apt-get install php5-gd

• Installazione della libreria PHP per l’esecuzione di PHP anche da linea di comando:

  sudo apt-get install php5-cli

• Attivazione dell’estensione MySQL sul file di configurazione di PHP5:

  vi /etc/php5/apache2/php.ini

  modifica della riga

  ;extension=mysql.so

  in

  extension=mysql.so

• Riavvio di Apache2:

  sudo /etc/init.d/apache2 restart

Se tutto è stato fatto per bene ora avrete il vostro web-server installato correttamente

Riccardo Tartaglia