Méthylbro Développeur Web PHP - Tag - config

PHP : Stocker sa configuration dans un fichier XML avec WDDX

Méthylbro — Mon, 13 Jul 2009 08:00:00 +0200

Il y a quelques semaines, j'ai parlé longuement de la gestion des variables de configuration au sein d'application PHP. J'ai même essayé de donner quelques pistes de réflexion en proposant un petit ensemble de classe pour stocker ces valeurs dans des fichiers .ini, dans des bases de données, ou encore dans les variables de session.

Pourtant je trouvais dommage de ne pas montrer au moins un exemple utilisant XML pour stocker ces valeurs. Je vais donc corriger ca en vous proposant cet exemple aujourd'hui. Nous allons compléter nos exemples avec une petite classe qui nous permettra de stocker des variables de configuration au sein d'un fichier XML.

Le choix du format XML

Pour me simplifier la vie, lorsque je doit représenter des données en XML via un script PHP, j’aime bien utiliser WDDX. En effet, il existe une extension qui permet de sérialiser et desérialiser des données au format WDDX sans soucis.

Nous allons donc utiliser les fonctions wddx_serialize_value() et wddx_deserialize() pour transformer notre tableau de valeurs en un paquet au format WDDX.

La classe WDDXFile_ConfigurationHandler

Nous allons donc créer une nouvelle classe WDDXFile_ConfigurationHandler héritant de notre classe abstraite ConfigurationHandler et implémentant l’interface iConfigurationHandler. Il nous suffira donc de rédiger uniquement les méthodes load() et save() de notre interface.

Voici à quoi ressemblera la structure de notre classe :

class WDDXFile_ConfigurationHandler 

extends ConfigurationHandler 

implements iConfigurationHandler {

private $file;

public function __construct($file, $auto=false) {}

public function load() {}

public function save() {}

}

La méthode load()

Pour lire le paquet WDDX contenu dans le fichier, nous allons utiliser conjointement les fonctions file_get_contents() et wddx_deserialize().

La première va récupérer le contenu du fichier et la seconde va transformer la chaîne de caractères contenant le paquet WDDX.

public function load() {

$this->setData(wddx_deserialize(file_get_contents($this->file)));

return $this;

}

la méthode save()

Pour écrire notre nouveau document XML au sein de notre fichier, nous allons à l’inverse de la fonction load() utiliser les fonctions file_put_contents() et wddx_serialize() pour créer le paquet WDDX et l’écrire dans le fichier.

public function save() {

file_put_contents($this->file, wddx_serialize_value($this->data));

return $this;

}

PHP : Stocker sa configuration dans une session

Méthylbro — Thu, 25 Jun 2009 08:30:00 +0200

De prime abord, cette idée peut paraitre saugrenue. Quelle peut être l'intérêt de stocker des variables de configuration au sein d'une session ?

J'avoue que je n'en ai absolument aucune idée. Ne me jetez pas la pierre, je cherchais juste un bon exemple pour montrer que l'on peut enregistrer des variables de configuration n'importe ou avec un minimum d'abstraction.

De prime abord, cette idée peut paraitre saugrenue. Quelle peut être l'intérêt de stocker des variables de configuration au sein d'une session ?

La classe Session_ConfigurationHandler


class Session_ConfigurationHandler extends ConfigurationHandler implements iConfigurationHandler {



private $array_access;



public function __construct($array_access, $auto=null) {

parent::__construct($auto);



if (strlen(session_id())<=0) throw new Exception('need a valid SID resource');

$r = (!session_is_registered($array_access))

? (session_register($array_access))

? true

: new Exception('failed to define \''.$array_access.'\'')

: new Exception('\''.$array_access.'\' is already defined');

if ($r instanceof Exception) throw $r;

}



public function load() {

$this->setData($_SESSION[$this->array_access]);

return $this;

}



public function save() {

$_SESSION[$this->array_access] = $this->getData();

return $this;

}



}

PHP : Stocker sa configuration dans une base de données

Méthylbro — Tue, 23 Jun 2009 08:30:00 +0200

Nous venons de voir dans un billet précédant comment manipuler facilement des variables de configuration à l'aide d'un fichier .ini. Mais comme je l'ai expliqué dans le billet d'introduction à ce sujet, dans certains cas nous pourrions très bien vouloir stocker autrement ces informations.

Aujourd'hui nous allons voir comment, avec la même méthodologie, avec les mêmes classes et interfaces de base nous pouvons étendre notre petite librairie à l'utilisation de base de données.

La classe DataBase_ConfigurationHandler

Pour ce faire, il faudra indiquer à la classe Configuration comment elle doit lire et enregistrer les informations qu'elle manipule.

Il suffit donc de reprendre la classe abstraite ConfigurationHandler au sein d'une nouvelle classe (que nous appellerons ici DataBase_ConfigurationHandler) et de lui implémenter également les méthodes de l'interface iConfigurationHandler.

On se retrouve donc avec un nouvel objet de type ConfigurationHandler capable de lire et d'écrire dans une base de données.


class DataBase_ConfigurationHandler extends ConfigurationHandler implements iConfigurationHandler {



private $column_name;

private $column_value;

private $table;

private $_PDO;



public function __construct($colname, $colvalue, $table, $PDO, $auto=false) {

parent::__construct($auto);

$this->column_name = $colname;

$this->column_value = $colvalue;

$this->table = $table;

$this->_PDO = $PDO;

}



public function load() {

$sql = "SELECT `".$this->column_name."`, `".$this->column_value."` "

. "FROM `".$this->table."`;";

$PDOStatement = $this->_PDO->query($sql);

while($row = $PDOStatement->fetch(PDO::FETCH_ASSOC)) {

$this->setData($row[$this->column_name], $this->column_value);

}

return $this;

}



public function save() {

$arr = array();

$sql = "TRUNCATE TABLE `".$this->table."`;";

$this->_PDO->exec($sql);

$sql = "INSERT INTO `".$this->table."` "

. "(`".$this->column_name."`, `".$this->column_value."`) VALUES ";

foreach($this->data as $name => $value) $arr[] = "('".$name."', '".$value."')";

$sql.= implode(', ', $arr);

$this->_PDO->exec($sql);

return $this;

}



}

La table CONFIGURATION

Dans un second temps nous allons créer une table simple au sein d'une base de données qui contiendra les valeurs de chaque variables de configuration que nous allons utiliser :


CREATE TABLE `CONFIGURATION` (

`name` varchar(255) NOT NULL,

`value` blob NULL,

PRIMARY KEY (`name`)

)TYPE=MyISAM;



INSERT INTO `CONFIGURATION` (`name`, `value`) VALUES ('bonjour', 'hello world !'), ('foo', 'bar');

Exemple d'utilisation

Pour finir il ne reste plus qu'a utiliser notre nouvelle classe. Rien de plus simple car grâce au l'interface iConfigurationHandler c'est toujours les mêmes méthodes que l'on utilise.


$PDO = new PDO();

$maMethode = new DataBase_ConfigurationHandler('name', 'value', 'CONFIGURATION', $PDO);

$maConfiguration = new Configuration($maMethode);



echo $maConfiguration->bonjour;

/*

* Affichera :

* hello world !

*/

echo $maConfiguration->foo;

/*

* Affichera :

* bar

*/



$maConfiguration->bonjour = 'coucou !';

$maMethode->save();

PHP : Stocker sa configuration dans un fichier ini

Méthylbro — Sun, 21 Jun 2009 08:30:00 +0200

Maintenant que vous savez comment gérer vos variables de configuration en PHP avec une classe et que vous êtes capable de stocker ces dernières de différentes manière. Nous allons voir comment les enregistrer au sein d'un fichier ini.

Comme je l'ai déjà dit, ce format sera plus efficace, car l'on pourra lire et écrire plus facilement les données concernées.

Nous allons voir aujourd'hui un exemple de classe héritant de la classe abstraite ConfigurationHandler ainsi que l'interface iConfigurationHandler que nous avons déjà vu dans un billet précédant.

Il suffit juste d'indiquer comment doivent se lire et s'enregistrer les différentes variables de configuration dans le fichier .ini.


class IniFile_ConfigurationHandler extends ConfigurationHandler implements iConfigurationHandler {



private $file;



public function __construct($file, $auto=false) {

parent::__construct($auto);

$r = (file_exists($file) && is_file($file))

? (is_readable($file) && is_writable($file))

? $this->file = $file

: new Exception('failed to open stream: Permission denied')

: new Exception('failed opening \''.$file.'\': No such file');

if ($r instanceof Exception) throw $r;

}



public function load() {

$this->setData(parse_ini_file($this->file, false));

return $this;

}



public function save() {

$str = null;

foreach($this->data as $name => $value) {

$str.= $name.' = '. ((is_int($value))

? $value

: (is_bool($value))

? ($value) ? 'On' : 'Off'

: '"'.$value.'"').PHP_EOL;

}

file_put_contents($this->file, $str);

return $this;

}



}

Ainsi, pour dire à notre classe Configuration qu'elle doit lire et enregistrer ses valeurs dans le fichier config.ini, nous l'utiliserons désormais de la façon suivante :


$maMethode = new IniFile_ConfigurationHandler('config.ini');

$maConfiguration = new Configuration($maMethode);



$maConfiguration->maVariable = 'Hello World !'; 

$maConfiguration->foo = 'bar';



$maMethode->save();

PHP : Enregistrer et stocker des variables de configuration

Méthylbro — Fri, 19 Jun 2009 08:30:00 +0200

Après avoir commencé à vous parler des variables de configuration avec PHP lundi, billet que j'ai illustré mercredi avec un exemple de classe de configuration en php, nous allons continuer aujourd'hui sur le même sujet.

Comment résoudre de façon générique l'enregistrement et le stockage de ces variables de configuration ?

Maintenant que nous avons vu comment gérer et manipuler des variables de configuration avec PHP, nous allons pouvoir nous pencher sur les différentes façon possible d'enregistrer et de stocker ces valeurs.

Comme je l'ai expliqué lors de l'introduction, le nombre de méthodes et d'outils possible pour enregistrer ses valeurs est potentiellement illimité. Ainsi donc, au lieu de créer une classe qui nous limiterais uniquement à l'une de ces méthodes, nous allons utilisée une interface commune pour chacune de ces méthodes. Libre ensuite au développeur de choisir la méthode de son choix parmi celles que nous allons voir, ou tout simplement d'écrire la sienne.

Chaque méthode de stockage sera représenté par sa propre classe dans le script. Cependant afin d'unifier et normaliser ces classes, nous utiliserons une interface ainsi qu'une classe abstraite.

L'interface iConfigurationHandler

Commençons par l'interface ; que nous appellerons iConfigurationHandler. Les méthodes qui seront communes à tous nos moyens de stockages seront load() et save().

La première, load(), nous permet de lire et placer en mémoire l'ensemble des données de configuration. Tandis que comme son nom l'indique la seconde, save(), enregistrera la liste des variables en mémoire en utilisant le système de stockage concerné.


interface iConfigurationHandler {

public function save();

public function load();

}

La classe abstraite ConfigurationHandler

Nous allons décider que, en plus d'implémenter l'interface iConfigurationHandler (et donc de proposer obligatoirement les méthodes load() et save()) nos différents moyens de stockage seront également manipulables avec certaines méthodes et propriétés communes.

Pour cela nous devrons donc définir une classe mère, qui sera abstraite (et donc non directement instanciable) que nous appellerons ConfigurationHandler.


abstract class ConfigurationHandler {

protected $data=Array();

protected $auto;

public function __construct($auto) {}

public function __destruct() {}

public function setData() {}

public function delData() {}

public function getData() {}

}

Au final donc, nos objets permettant le stockage de nos variables de configuration devront à la fois hériter de la classe ConfigurationHandler mais également implémenter les méthodes de l'interface iConfigurationHandler.

Modifications sur la classe Configuration

Il faut maintenant signaler à la classe Configuration qu'elle soit déléguer son stockage des données à une classe de type ConfigurationHandler.

Voici donc les modifications à apporter sur cette dernière :


class Configuration implements IteratorAggregate, Countable, ArrayAccess {

private $_ConfigurationHandler;

public function __construct(ConfigurationHandler $ConfigurationHandler) {}

public function __set($name, $value) {}

public function __get($name) {}

public function __isset($name) {}

public function __unset($name) {}

public function count() {}

public function getIterator() {}

public function offsetExists($offset) {}

public function offsetGet($offset) {}

public function offsetSet($offset, $value) {}

public function offsetUnset($offset) {}

}

Dans un prochain billet, nous verrons comment utiliser ces classes abstraites et ces interfaces pour créer nos propres méthodes de stockages. D'abord dans un fichier au format .ini, ensuite dans une base de données et enfin au sein des données de session du visiteur.

PHP : Gérer vos variables de configuration avec une classe

Méthylbro — Wed, 17 Jun 2009 08:30:00 +0200

Voici la suite du billet de lundi sur la gestion des variables de configuration au sein d’une application avec PHP.

Aujourd’hui nous allons rentrer dans le vif du sujet avec un premier exemple simple mais utilisant tout de même la surcharge ainsi que la SPL.

Cependant je garde pour plus tard toute la partie concernant l'enregistrement et le stockage de ces variables.

Dans un premier temps, nous allons voir comment manipuler un ensemble de variables de configuration au sein de votre application. Sans ce soucier pour le moment des méthodes qui seront utilisées pour enregistrés ou lire les données enregistrés (dans un fichier ou une base de données par exemple).

Parton donc du principe que nous souhaiterons pouvoir manipuler les données de configuration de la manière suivante :


$maConfiguration = new Configuration();

$maConfiguration->maVariable1 = 'ma valeur';

$maConfiguration->maVariable2 = 'mon autre valeur';



foreach ($maConfiguration as $variable => $valeur) {

echo $variable.' = '.$valeur.PHP_EOL;

}

/*

* Affichera :

* maVariable1 = ma valeur

* maVariable2 = mon autre valeur

*/



echo $maConfiguration['maVariable1'];

/*

* Affichera :

* ma valeur

*/

Pour se faire, nous allons devoir commencer par créer la classe Configuration.

Afin de pouvoir offrir à notre classe les comportements que nous venons de voir, nous allons utiliser des concepts courant en Programmation Orienté Objet : la surcharge et l'itérateur (enfin ici il ne s'agit pas d'un itérateur à proprement parler).

La surcharge, et ici la surcharge de propriétés, va nous permettre de redéfinir le comportement par défaut de php lorsqu'on fait appel en lecture et/ou écriture sur une propriété de notre objet. Je vous laisse lire le chapitre consacré à ce concept dans la documentation PHP : Les classes et les objets (PHP 5) : Surcharge

Ensuite, nous utiliserons les facilités apportées par la SPL comme par exemple l'interface IteratorAggregate qui nous permettra de manipuler notre objet comme un tableau dans les boucles foreach. Ou encore l'interface ArrayAccess qui nous permettra d'accéder au contenu de notre objet comme un tableau. Si vous n'avez encore jamais entendu parler de la Standard PHP Library, je vous laisse la découvrir : SPL Stantard PHP Library

La classe Configuration

Voici donc, dans sa forme la plus basique à quoi ressemble notre classe Configuration dans sa forme primaire.


class Configuration implements IteratorAggregate, Countable, ArrayAccess {

private $data=Array();

public function __get($name) {}

public function __set($name, $value) {}

public function __isset($name) {}

public function __unset($name) {}

public function count() {}

public function getIterator() {}

public function offsetExists($offset) {}

public function offsetGet($offset) {}

public function offsetSet($offset) {}

public function offsetUnset($offset) {}

}

Vous trouverez l'intégralité de la classe en exemple dans le fichier en annexe à ce billet.

Comme je l'ai expliqué, pour le moment nous ne nous sommes pas préoccupés de la façon dont les données seront enregistrées et stockées. Nous verrons ca dans les prochains billets.

Les variables de configuration avec PHP

Méthylbro — Mon, 15 Jun 2009 08:30:00 +0200

Lors du développement d'application web ou de site internet un minimum complexes, certaines problématiques sont récurrentes. La gestion des utilisateurs, la gestion d'un cache et plein d'autre encore.

Ici, je vais vous parler d'un point sur lequel je me suis penché récemment : la gestion de variable de configuration au sein de votre application.

Il s'agit en fait d'un billet d'introduction à une série d'article un peu similaire à celle de l'année dernière sur la POO avec PHP. Nous verrons ainsi tout au long de la semaine comment, grâce à la Programmation Orienté Objet, on peut résoudre cette impératif technique qui est le stockage et le traitement de variables de configuration au sein d'une application PHP.

Qu'est-ce que j'entends par "variable de configuration" ?

Et bien de façon générale, si l'on en croit la wikipédia, il s'agit des paramètres qui permettent d'adapter leur comportement à la configuration dans lequel votre application est implantée.

Vous retrouverez donc par exemple parmi ces paramètres des valeurs comme les identifiants de connexion à votre base de données (adresse du serveur, login, mot de passe, etc), la liste des adresses emails destinataire d'un formulaire de contact ou encore la liste des fonctionnalités activées et/ou désactivées.

Les exemples peuvent être nombreux, mais le fait est que toute application possède un minimum de variables de "configuration".

Comment stocker et gérer ses variables ?

Il n'existe bien évidement pas de méthodes, de procédures prédéfini pour stocker et manipuler ces variables de configuration. Le nombre de possibilités techniques pour résoudre cette contrainte est égal au nombre de développeurs. C'est a dire ; à chaque développeur sa méthode.

Cependant quelques modèles génériques émergent :

Les fichiers de configuration

Le plus généralement, les variables de configuration sont centralisés au sein d'un fichier. Se pose alors le choix du type de fichier utilisé par le développeur.

Cette méthode présente plusieurs avantages. Les accès disques sont maitrisés par le développeur. Il est facile de gérer différentes versions du fichier de configuration.

le fichier de configuration .php

C'est la méthode la plus simple et la plus courante. Stocker ses valeurs directement dans un fichier de configuration en php. C'est le grand classique du config.php. On trouvera donc un fichier .php un peut comme ceci :


<?php

$db_host = 'localhost';

$db_user = 'root';

$db_pass = '';

$db_name = 'test';

?>

L'inconvénient de cette méthode, c'est qu'il devient très difficile de modifier dynamiquement ces valeurs. Il sera par exemple très coûteux en ressources et en code de créer une interface web pour venir modifier le contenu de ce fichier avec de joli formulaire et tout.

le fichier de configuration .ini, .xml et autres formats

Toujours dans le même principe que le fichier de configuration en php, on retrouve d'autres formats. Comme par exemple le format .ini qui permet grâce à la fonction php parse_ini_file() de lire très facilement sont contenu.


[DATABASE]

db_host = "localhost"

db_user = "root"

db_pass = ""

db_name = "test"

Bien évidement, si vous souhaitez utiliser un fichier pour stocker vos données de configuration un grand nombre de format de fichiers s'offre à vous. Vous pourrez alors sérialiser vos données avec serialize dans un fichier quelconque.

Ou encore utiliser le format xml. Soit avec un doctype personnalisé, soit en utilisant par exemple WDDX.

Les autres méthodes

Bien évidement il n'y a pas que les fichiers qui sont a même de stocker vos valeurs de configuration. Si vous avez à modifier régulièrement ces informations l'utilisation d'une base de données peut s'avérer par exemple plus utile.

Mais on peut encore imaginer bien d'autres forme de stockage. Pourquoi pas dans une base de registre, dans un annuaire, ou encore sur une boite mail (oui, on peut vraiment tout imaginer).

Conclusion

Vos applications doivent adapter leur comportement à la configuration dans laquelle elles sont implantées. Cela passe donc par une véritable gestion des valeurs qui permettent d'ajuster votre application en fonction de son environnement.

Nous verrons dans une série de tutoriels à venir que grâce à la programmation orienté objet en php on peut résoudre très facile les différentes contraintes technique relative au stockage et au traitement de ces variables de configuration.