Programmation PHP Orientée Objet sous Eclipse

Depuis la démocratisation de php5, il est possible d’appréhender les projets web d’un point de vue « Objet ». Certes, ça n’est pas une révolution, et cette approche était déjà permise, dans une moindre mesure, avec php4. Le but ici n’est pas de promouvoir la POO à tout prix, simplement d’expliquer pourquoi ça peut être utile et comment ça peut être fun.

D’abord, la POO (Programmation Orientée Objet), ça n’a pas de particularité technique. En effet, il s’agit plus d’une manière de concevoir que d’une façon de coder. A ce titre, on pourrait envisager de « coder objet » avec presque n’importe quel langage, et inversement, utiliser un langage objet sans avoir besoin de l’exploiter comme tel.

La POO donc, ça consiste entre autres, à se représenter un programme, un script, une application, dans l’espace plutôt que dans le temps. Grosso-modo, il s’agit de penser en terme d’objets, capables d’interagir entre eux, et pas de lignes de codes qui s’enchaineraient les unes après les autres.

La POO, ça permet de donner un semblant de vie comportement à des entités de données, de variables, de valeurs… qu’on appellera du coup des objets. A l’instant où j’écris ce billet, j’ai à l’écran une zone de texte pour le titre, une autre pour le texte, et un bouton pour enregistrer. Je peux dès lors considérer qu’un billet est un objet, doté d’un titre, d’un texte, et capable de s’enregistrer lorsqu’on lui demandera de le faire.

Sans entrer dans les détails, cette vision des choses offre de nombreux avantages, au nombre desquels on peut citer:

• la POO encourage le travail collaboratif.
• la POO simplifie la maintenance.
• la POO accroît la stabilité.
• la POO assouplit le code.
• la POO rend le travail plus agréable.

En contrepartie:

• la POO est chronophage.
• la POO consomme des ressources.
• la POO n’aime pas l’approximation.

Cependant, chacun de ces points est discutable, et s’il faut retenir quelque chose à propos de la POO, c’est qu’elle n’apporte rien qu’on ne se donne pas la peine d’implémenter. A contrario, elle offre un cadre de travail efficace, et encourage la réflexion, en délestant le programmeur de fastidieuses tâches de codage.

La POO est, comme son nom l’indique, basée sur la notion d’objet. Un objet possède des attributs (repésentant l’état de l’objet) et des méthodes (représentant des opérations applicables à l’objet). Toute la façon d’imaginer, de penser le code est remis en question par rapport au php classique (dit « procédural »). Il faut un petit temps d’adaptation pour faire du code réellement en objet. La difficulté provient du fait que l’on a parfois du mal à imaginer certaines notions virtuelles sous forme d’objet.

Ce qui est appelée « classe », est tout ce qui définit un objet. Un objet est unique (on parle ici d’instance ou d’occurence de classe) mais deux objets peuvent être instanciés à partir de la même classe. Donc la première chose à faire en POO, c’est de créer une classe (après avoir analyser le problème et savoir ce que l’on veut faire exactement. Voici sommairement la syntaxe à respecter pour créer une première classe (contenu du fichier MaClasse.class.php) :

class MaClasse {
	private $id;
	private $attribut;
	public function __construct($id= null, $attribut= null)
	{
		if(!empty($id)) {
			$this->id = $id;
		}
		if(!empty($attribut)) {
			$this->attribut = $attribut;
		}
	}

	public function affiche()
	{
		echo "L'attribut vaut $this->attribut";
	}
}

Quelques explications sur la classe créée ci-dessus :

• Une des premières règles de la POO est que le nom de la classe doit commencer par une majuscule. Après avoir indiqué le nom de la classe, on définit les attributs de cette classe (ici les attributs sont id et attribut. La première fonction (__construct) est appelé le constructeur de la classe. C’est grâce à cette fonction que l’on peut créer un objet de cette classe en faisant simplement « new() » (voir ci-après).

• La variable $this est une variable spécifique à la POO, elle permet d’indiquer que c’est cet objet qui est modifié. $this->id correspond à l’attribut id de l’objet sur lequel on travaille.

• La deuxième fonction (affiche) est une méthode de l’objet, ici c’est une méthode toute simple qui permet d’afficher, avec une phrase, la valeur de l’attribut nommé attribut.

Une fois la classe créée, il faut pouvoir s’en servir et créer des objets de cette classe :

include("MaClasse.class.php");$objet = new MaClasse(1, 10);$objet->affiche();

La première ligne permet d’inclure le fichier contenant la classe. La deuxième instruction permet de créer un nouvel objet grâce à l’appel au constructeur avec le mot « new ». Après cette ligne, on a donc un objet MaClasse (nommé « $objet ») dont les attributs id et attribut ont respectivement 1 et 10 comme valeur. Enfin la dernière ligne affiche : « L’attribut vaut 10« .

Voici donc le nécessaire pour débuter avec la POO en PHP. Malgré le temps d’adapation à la philosophie de la POO, cette technique de programmation fait gagner du temps. En effet, on se trouve, à la fin, avec un code plus compréhensible (surtout sur des gros projets), plus facilement réutilisable et surtout plus facilement maintenable.

Enfin, je mets quelques liens qui m’ont permis de débuter avec la Programmation Orientée Objet en PHP. Je préfère apprendre avec des exemples concrets, donc la plupart de ces liens vous en présenteront :

• Exemple : calculatrice (apprendre-php.com, forum)
• Classe sur des comptes utilisateurs (clubic.com, forum)
• Créer un blog en POO (nettuts.com, tutoriel)
• POO et MySQL (nettuts.com, tutoriel)
• Gestion des exceptions en PHP5 (scriptsphp.org, blog)

Php propose deux fonctions aussi puissantes qu’utiles (mais aussi méconnues) : serialize et unserialize.

• Serialialize compresse (linéarise) un tableau Php
• Unserialize le décompresse (ou délinéarise), tout simplement.

A partir de là, l’idée paraît s’imposer d’elle même : pour certaines requêtes qui sont énormément exécutées et/ou qui sont très lourdes (par exemple les données d’un membre utilisées sur toutes les pages d’un site), pourquoi ne pas mettre en cache le tableau issu d’un mysql_fetch_array() ? Ainsi, une fois que la requête a été exécuté on n’accède plus à la base de donnée, on récupère le tableau de données dans un fichier texte puis on le décompresse.

La première fonction permet, tout simplement, d’écrire dans un fichier (en le créant, le cas échéant) :

<?
function maj_fichier($file,$valeur)
{
$fp = fopen("$file","w+"); // ouverture du fichier en écriture (on le créé s'il n'existe pas)
fputs($fp, $valeur); // on écrit dans le fichier
fclose($fp);
}
?>

La seconde – et c’est la fonction qui nous intéresse – est la fonction de mise en cache :

(pour l’utiliser vous aurez besoin de la fonction maj_fichier() ci-dessus et de la fonction requete_sql disponible sur ce billet)

<?
function MiseEnCache($nomFichier,$table,$where,$champs)
{

if(file_exists($nomFichier)) // si les variables sont en cache
{
$requete = unserialize(lire_fichier($nomFichier)); // on utilise le fichier cache (unserialize = decompresser le tableau)
}
else // sinon on fait la requete sql
{
$requete = requete_sql($table, $champs, $where);
maj_fichier($nomFichier, serialize($requete)); // on place le resultat du tableau dans un fichier (serialize = compresser le tableau)
}

return $requete;
}
?>

Exemple d’utilisation :

<?
$req_membre=MiseEnCache("/cache/membres/membre-".$id_membre.".txt","membres", "id='$id_membre'", "prenom,nom,date_inscription,login");

echo »Bienvenue « .$req_membre[prenom]. » « .$req_membre[nom]. » ! »;
?>

Cet exemple permet de pouvoir afficher sur toutes les pages le prénom et le nom du membre en effectuant la requête qu’une seule fois ! Malin n’est-ce pas ?

Mais bien sur vous-vous dites : et si le membre modifie son nom, l’information sera erronée ?

La réponse est simple : il suffit de supprimer le fichier texte lors de la modification des informations pour le régénérer avec les bonnes !!

Il y a néanmoins une limitation à l’utilisation de ce procédé : ne l’utilisez pas pour des données sensibles (mot de passe, email, etc.) car un fichier texte est beaucoup plus facilement accessible pour un pirate qu’une base de données…

J’ai longuement cherché sur le web, et je n’ai trouvé que peu d’infos à ce sujet. Je vous livre ici le résultat de mes recherches et de mes multiples tests, de l’intégration des coordonnées de latitude/longitude à l’aide des API de géolocalisation google map et yahoo map jusqu’à la requête sql finale qui inclue la formule de calcul de distance à partir des coordonnées géolocalisées.

Une base de donnée fiable des villes associées à leurs coordonnées de latitude/longitude

En premier lieu, il s’agit d’avoir une base de données de villes. Il en existe de nombreuses sur le net, celle-ci intègre même les coordonnées de latitude et de longitude.

Dans mon cas, je possédais déjà une base de données de villes françaises mais sans ces coordonnées. La meilleure méthode pour y intégrer la latitude et la longitude de chaque ville est d’utiliser l’API de Yahoo ou de google.

Ces deux API permettent de récupérer un flux XML correspondant à la recherche (ex : Amiens, France) contenant la latitude et la longitude.

Par exemple, voici le résultat de la recherche de la ville d’Amiens avec l’API de Yahoo :

<ResultSet xsi:schemaLocation="urn:yahoo:maps http://api.local.yahoo.com/MapsService/V1/GeocodeResponse.xsd">
<Result precision="zip">
<Latitude>49.896309</Latitude>
<Longitude>2.279720</Longitude>
<City>80000 Amiens</City>
<State>France</State>
<Country>FR</Country>
</Result>
</ResultSet>

Il n’y a donc plus qu’à faire une boucle sql sur la table des villes en parsant le flux de yahoo ou google correspondant (en indiquant la ville, le code postal et le pays) et intégrer à l’enregistrement de la ville la latitude et la longitude. Un vrai jeu d’enfant avec simplexml en php5 ! Cependant, même si ces API sont puissantes, il se peut que parfois la ville ne soit pas trouvée, que la ville retournée ne soit pas la bonne ou que plusieurs résultats soient retournés. Pour plus d’informations, et pour choisir entre les API de Yahoo et de Google, je vous invite à lire cet article sur la géolocalisation via yahoo et google map très bien fait et qui m’a bien aidé.

Vous avez à présent une table contenant les villes associées à leurs coordonnées géographique de latitude et de longitude.

Il ne reste plus qu’à exploiter cela dans une requête SQL et afficher le tout en PHP.

J’ai d’abord tenté une conversion des données latitude/longitude en points de coordonnées lambert 2 étendue (norme française) grâce à la fonction geos2lambert() disponible sur google code mais son exploitation s’est révélé compliquée et imprécise (ou alors c’est moi qui suis vraiment nul en maths !).

Je suis donc reparti sur les données de latitude/longitude. Grâce à une formule mathématique complexe trouvée sur le net je suis arrivé au résultat suivant.

Je reçois en variable GET les coordonnées de ma ville de référence :

$latitude=$_GET[lat];
$longitude=$_GET[lon];

La fameuse formule utilisant les colonnes lat et lon de ma table sql et les données de latitude et longitude de ma ville de référence :

$formule="(6366*acos(cos(radians($latitude))*cos(radians(`lat`))*cos(radians(`lon`) -radians($longitude))+sin(radians($latitude))*sin(radians(`lat`))))";

Et la requête SQL prête à être exécutée :

$sql="SELECT ville,$formule AS dist FROM ville WHERE $formule<='$_GET[distance]' ORDER by dist ASC";

• le SELECT $formule AS dist permet de classer les villes de la plus proche à la plus éloignée avec ORDER by dist ASC
• le WHERE $formule<=’$_GET[distance]‘ permet de définir un rayon en km ($_GET[distance]) à partir de la ville de référence

Je vous laisse coder l’éxécution de la requête sql et l’affichage des données en php, ce n’est pas vraiment le plus dur !

Vous pouvez voir le résultat sur cette page. La ville de référence est ici Amiens avec un périmètre de 15 km.

En guise de conclusion…

Il faut savoir que ce calcul et le résultat ne sont pas précis pour plusieurs raisons :

• Le calcul ne tient pas compte de l’altitude, qui, dans certains endroits peut influer sur les distances
• La formule a été simplifiée au maximum par souci de simplicité et d’efficacité.
• La distance est « à vol d’oiseau » et non pas une distance routière
• La localisation latitude/longitude d’une ville repose sur un point (généralement la mairie de la ville en question), donc la distance ne commence pas à la sortie de la ville mais du centre de la ville. Ainsi, par exemple, pour Paris cela ne sert à rien de vouloir localiser les villes à 5km…

Cependant, malgré l’imprécision cela fonctionne, car l’intérêt premier est d’afficher les villes proches et non de concurrencer google map ! Il convient juste de ne pas forcément afficher les distances en km qui sont souvent fausses (à quelques kilomètres près).

L’utilisation de cette technique qui est finalement assez simple à mettre en place peut être très utile sur du web local afin d’élargir les recherches sur une ville aux villes à proximité (dans le cas où aucune réponse n’est disponible pour la ville concernée par exemple) ou proposer d’autres villes ou contenus (ou publicités géolocalisées !) à l’internautes en rapport avec sa requête.

Si vous avez des questions sur la mise en place d’une recherche de proximité ou si cet article vous a aidé, n’hésitez pas, les commentaires sont fait pour ça !

Pour inaugurer cette partie, je vous fournis 4 fonctions (+ 2 variantes) bien utiles pour faire des traitements SQL de base à savoir : SELECT, INSERT, UPDATE et DELETE.

Ces fonctions sont finalement assez simples, mais ça fait gagner du temps. De plus, ce genre de fonction permet d’opérer des changements sur toutes les requêtes identiques très simplement (ex : en cas de changement de système de base de données).

Insérer un enregistrement :

function inserer_sql($table,$champs,$donnees)
{
$sql = "INSERT INTO $table ($champs) ";
$sql .= "VALUES ($donnees)";

if(mysql_query($sql))
{
return true;
}
else
{
return false;
}
}

Et pour l’utiliser, c’est tout aussi simple. Par exemple :

if(inserer_sql("utilisateurs","email,nom,prenom",
"'$_POST[email]','$_POST[nom]','$_POST[prenom]'"))
echo"L'ajout a été effectué avec succès";
else echo"L'ajout a échoué";

Ensuite, pour gagner du temps j’utilise une autre fonction qui n’a comme arguments que le nom de la table et la liste des champs à ajouter (sous forme de tableau). Cela suppose bien sur une correspondance des champs du formulaire (données POST) et des champs de la table :

function inserer_sql_array($table,$array)
{
$req="";
$i=1;
foreach($array as $k)
{

if($i!=’1′) { $req.= », « ; $req2.= », « ; }

$req.= »$k »;
$req2.= »‘$_POST[$k]‘ »;
$i++;
}

return inserer_sql($table,$req,$req2);
}

Il suffit de l’utiliser comme ceci :

if(inserer_sql_array("utilisateurs",array("email,nom,prenom"))
echo"L'ajout a été effectué avec succès";
else echo"L'ajout a échoué";

Modification de données :

Sur le même principe que pour l’ajout j’ai cette fonction :

function maj_sql($table,$action,$where)
{
if($where=='') { $where=1; }

$sql = « UPDATE $table SET $action « ;
$sql .= « WHERE $where »;

if(mysql_query($sql))
{
return true;
}
else
{
return false;
}
}

Dans cette fonction, il est permis de modifier tous les enregistrements d’une table (en laissant l’argument $where à vide). Mais, par mesure de sécurité, on peut désactiver cela en testant la variable $where au début et en renvoyant false si elle est vide.

Pour utiliser cette fonction, il suffit de tester que la fonction renvoie bien true.

La variante de cette fonction qui génère la requête à partir d’un tableau array() :

function maj_sql_array($table,$array,$where)
{
$req="";
$i=1;
foreach($array as $k)
{
if($i!='1') $req.=", ";

$req.= »$k=’$_POST[$k]‘ »;
$i++;
}

maj_sql($table,$req,$where);
}

Suppression de données :

Cette fonction permet de supprimer un ou plusieurs enregistrements dans une table en précisant uniquement la table et la condition à remplir. Cependant, par mesure de sécurité, il est impossible de ne pas préciser de condition (cela supprimerait tous les enregistrements de la table) :

function sup_sql($table,$where)
{

if($where== ») {
return false;
}
else
{
$sql = « DELETE FROM $table « ;
$sql .= « WHERE $where »;

if(mysql_query($sql))
{
return true;
}
else
{
return false;
}
}
}

Lire une ligne d’une table :

Enfin, la dernière fonction permet d’extraire les données d’un enregistrement d’une table. C’est bien sûr en fait un simple SELECT mais comme pour les autres fonctions, cela permet de gagner du temps.

function requete_sql($table,$champs,$where)
{
// si $where est vide on lui attribue une valeur par défaut
if($where=='') { $where=1; }

// en cas de jointure on utilise le nom de la première table pour le tri par ID.
$tab=explode(« , »,$table);

$sql = « select $champs from $table where $where ORDER by $tab[0].id DESC LIMIT 1″;
$p = mysql_query($sql)OR DIE(« Erreur sur la requete SELECT $champs FROM $table WHERE $where »);
return mysql_fetch_array($p);
}

Le résultat de cette fonction est un tableau contenant les données précisées dans l’argument $champs. Exemple :

$requete=requete_sql("utilisateurs","nom,prenom,email","id='$_GET[user]'");
echo"Bonjour ".$requete[prenom]." !";

En bonus, voici la fonction qui permet de compter le nombre d’enregistrements dans une table pour une condition précise. Cette fonction effectue un mysql_numrows sur une requête SELECT. Les puristes préféreraient sans doûte un SELECT count(id), cependant, il me semble que ma méthode est moins lourde :

function compter_sql($table,$where)
{
if($where=='') { $where=1; }
$sql = "select id from $table where $where";
$p = mysql_query($sql)OR DIE("Erreur sur la requete SELECT id FROM $table WHERE $where");
return mysql_numrows($p);
}

Cette fonction suppose que vous avez une colonne id dans votre table puisque le SELECT est effectué dessus. Pour l’utiliser, rien de plus simple :

$nb_utilisateurs_hommes = compter_sql("utilisateurs","sexe='H'");

Conclusion :

Ces petites fonctions ne sont pas révolutionnaires en soit puisqu’elles reprennent les principes de base de SQL. Cependant, et ce n’est pas négligeable, elles permettent réellement de gagner du temps car elles sont plus rapides à écrire et plus faciles à retenir (je retiens mieux des noms de fonction en français qu’en anglais).

Bien sûr, elles ne sont pas parfaites, il faudrait protéger les données à insérer ou à modifier par des htmlspecialchars() et addslashes(). Mais pour ça, c’est à vous de jouer, je ne vais pas vous prémacher tout le travail non plus !

• Bien penser la structure de sa base de données avant le développement afin de réduire au maximum le nombre de requêtes SQL dans le développement (par exemple, ne pas hésiter à créer une colonne contenant le nombre de messages postés par un utilisateur – qui sera remis à jour à chaque message qu’il postera – plutôt que de faire un mysql_num_rows à chaque affichage de ce nombre).

• Mettre en cache tout ou une partie du contenu (stocker la page dans un fichier html et l’afficher s’il existe ou sinon affichage de la page php et génération du cache).

• Mettre en cache des variables avec les fonctions serialize et unserialize. Cela permet par exemple de mettre en cache le résultat d’un mysql_fetch_array assez lourd appelé sur chaque page (comme des variables sur l’utilisateur ou le contenu de menus…). J’y reviendrais plus en détail dans un prochain billet.

• Optimiser les requêtes SQL : utiliser les jointures (SELECT sur plusieurs table ayant des champs en communs) et ne pas faire de SELECT * (select sur tous les champs) mais lister les champs utilisés (SELECT id,login,nom FROM …).

• Mettre des index intelligents sur les tables SQL. Les index permettent un gain de temps d’accès énorme. Il faut les placer sur les colonnes utilisées dans la clause WHERE.

• Compresser vos pages web, fichiers CSS et javascripts à l’aide de la fonction gzip de php. Vous trouverez sur ce site une classe complète pour compresser vos pages. Cela peut paraître idiot à l’heure du haut débit : il faut optimiser le poids des images car des images lourdes ralentissent malgré tout le chargement de la page.

• Vérifier qu’un script, notamment de régie publicitaire, ne ralentit pas l’affichage de la page. Cela arrive fréquemment et certaines régies sont championnes dans ce domaine !

N’hésitez pas à compléter si j’ai oublié des choses