PHP - Fichier de configuration d'application stocké en tant que - ini, php, sql, mis en cache, classe php, JSON, tableau php?

StackOverflow https://stackoverflow.com/questions/1809241

Question

J'essaie de choisir le meilleur moyen de stocker les paramètres de configuration de mes applications. Il y a tellement d'options.

La majorité des applications que j'ai vues utilisaient un besoin simple et un fichier PHP contenant des variables. Il semble y avoir des techniques beaucoup plus avancées là-bas.

Qu'avez-vous utilisé? Quel est le plus efficace? Qu'est-ce qui est le plus sécurisé?

Était-ce utile?

La solution

La meilleure chose à faire est de la chose la plus simple qui pourrait fonctionner (variables php). ) et envelopper dans une classe. De cette façon, vous pourrez modifier l’implémentation ultérieurement sans modifier aucun code client. Créez une interface que la classe de configuration implémente et faites en sorte que le code client utilise les méthodes d'interface. Si vous décidez ultérieurement de stocker la configuration dans une base de données, JSON ou autre, vous pouvez simplement échanger la mise en œuvre existante avec une nouvelle. Assurez-vous que votre classe de configuration est testable et écrivez des tests unitaires.

Autres conseils

Nous utilisons un fichier appelé Local.php , qui est exclu du système SCM. Il contient plusieurs constantes ou variables globales. Par exemple: 

// Local.php
class Setting
{
   const URL = 'http://www.foo.com';
   const DB_User = 'websmith';
}

Et il peut être référencé à n'importe où simplement par: 

Setting::URL

Si vous souhaitez que les paramètres soient accessibles en écriture au moment de l'exécution, je vous suggère plutôt d'utiliser des variables statiques publiques.

Essayez d'utiliser les fichiers de configuration php-arrays en utilisant la technique décrite ci-dessous: http://www.dasprids.de/blog/2009/05/08/writing-powerful-and-easy-config-files-with-php-arrays

Cette méthode vous permet d'écrire la configuration de l'application de la manière suivante: app.config.php 

<?php

return array(
  'appname' => 'My Application Name',
  'database' => array(
    'type' => 'mysql',
    'host' => 'localhost',
    'user' => 'root',
    'pass' => 'none',
    'db' => 'mydb',
  ),
);

Cette méthode est sécurisée et peut être mise en cache par les cachers d'opcode (APC, XCACHE).

Je trouve Zend_Config pour être une bonne solution. Vous pouvez charger la configuration à partir d'un tableau simple , à partir de un fichier de style INI , ou de un document XML . Quel que soit votre choix, l'objet de configuration est identique, vous pouvez donc changer de format de stockage librement. Les objets Zend_Config peuvent également être fusionnés. Cela peut être utile en fonction de votre application (une configuration de serveur, puis une configuration par site / installation).

Comme avec la plupart (ou la totalité) des choses dans Zend Framework, vous pouvez facilement utiliser Zend_Config par lui-même.

Compte tenu de l'efficacité , je dirais que la méthode la plus rapide consiste à utiliser un tableau, car cela nécessite moins (dans ce cas, une analyse de chaîne). Cependant, un format INI / XML peut être plus facile à maintenir pour certains. Bien sûr, une mise en cache vous donnerait le meilleur des deux mondes.

De plus, l’utilisation de fichiers INI avec Zend_Config vous permet de définir des sections de configurations qui héritent les unes des autres. L’utilisation la plus courante est une section «développement» qui hérite de la section «production», puis redéfinit les paramètres de la base de données et du débogage.

En ce qui concerne la sécurité , conserver le fichier de configuration hors de la racine Web est la première étape. Le rendre en lecture seule et limiter l'accès pourrait le rendre plus sécurisé; Cependant, en fonction de la configuration de votre hébergement / serveur, vous pouvez être limité dans ce qui peut être fait ici.

Que diriez-vous de: 

; <?php die('Direct access not allowed ;') ?>
; The above is for security, do not remove

[database]
name = testing
host = localhost
user = root
pass = 

[soap]
enableCache = 1
cacheTtl = 30

Enregistrer sous config.php (ou quelque chose comme ça, vous devez avoir une extension php), puis chargez-le simplement avec: 

parse_ini_file('config.php', true);

Et vous pourriez utiliser 

array_merge_recursive(parse_ini_file('config-default.php', true), parse_ini_file('config.php', true))

pour fusionner un fichier de configuration par défaut avec un fichier de configuration plus spécifique.

Le point ici est que vous pouvez utiliser le format ini très lisible, tout en conservant votre fichier de configuration dans un répertoire public. Lorsque vous ouvrez le fichier avec votre navigateur, php l’analysera d’abord et vous donnera le résultat, qui sera simplement "" ;; Accès direct non autorisé; ". Lorsque vous analysez directement le fichier en tant que fichier ini, l'instruction php die sera commentée selon la syntaxe ini (;), de sorte qu'elle n'aura aucun effet à ce moment-là.

Juste un exemple de la façon de mettre en œuvre une configuration centrale XML / Xpath. 

class Config {
    private static 
 Juste un exemple de la façon de mettre en œuvre une configuration centrale XML / Xpath. 



Config::getInstance()
    ->open('settings.xml')
    ->getConfig('/settings/module/section/item');




 Exemple d'appel 


<*>singleton;
    private $xml;
    static function getInstance() {
        if(is_null (self::
 Juste un exemple de la façon de mettre en œuvre une configuration centrale XML / Xpath. 


<*>


 Exemple d'appel 


<*>singleton) ) {
                self::
 Juste un exemple de la façon de mettre en œuvre une configuration centrale XML / Xpath. 


<*>


 Exemple d'appel 


<*>singleton = new self;
        }
        return self::
 Juste un exemple de la façon de mettre en œuvre une configuration centrale XML / Xpath. 


<*>


 Exemple d'appel 


<*>singleton;
    } 
    function open($xml_file) {
        $this->xml = simplexml_load_file($xml_file);
        return $this;
    }
    public function getConfig($path=null) {
        if (!is_object($this->xml)) {
            return false;
        }
        if (!$path) {
            return $this->xml;
        }
        $xml = $this->xml->xpath($path);
        if (is_array($xml)) {
            if (count($xml) == 1) {
                return (string)$xml[0];
            }
            if (count($xml) == 0) {
                return false;
            }
        }
        return $xml;
    }
}

Exemple d'appel

<*>

À mon avis, une bonne solution serait les fichiers INI.

Je ne préfère pas le fichier de configuration utilisant des tableaux / variables pour stocker les paramètres; voici pourquoi:

Que se passe-t-il si un utilisateur renomme par inadvertance votre variable de paramètre?
Que se passe-t-il si une variable portant un nom similaire est également définie ailleurs par l'utilisateur?
Les variables du fichier de configuration peuvent être écrasées si elles se trouvent en profondeur dans le script ou même dans des fichiers inclus.
et peut-être plus de problèmes ....

J'aime utiliser le fichier ini pour configurer mes applications php. Voici pourquoi:

C'est basé sur les sections
C'est plus facile
Vous pouvez définir des valeurs par noms conviviaux
Vous n'avez pas à vous soucier des variables écrasées, car il n'y en a pas.
Pas de conflit de variables bien sûr. Cela permet plus de flexibilité dans la spécification des types de valeurs.

Remarque: vous devez utiliser la fonction parse_ini_file pour lire les fichiers ini.

Il est préférable de faire toute configuration de base dans PHP même, mais si vous utilisez une base de données et que cela ne vous gêne pas - vous pouvez trouver une certaine souplesse dans le stockage de certains paramètres dans la base de données avec une seule requête supplémentaire (en supposant vous organisez correctement).

Quoi qu’il en soit, stocker ces données dans JSON, INI, XL, etc. n’est qu’une autre abstraction inutile qui est beaucoup trop utilisée de nos jours sur le Web. Votre meilleur choix est purement PHP, à moins que vous n'aimiez la flexibilité de certains paramètres dans la base de données.

La seule raison pour laquelle je peux penser à ne pas utiliser les vars php, comme le suggèrent d’autres, c’est si vous devez passer d’une configuration à l’autre de manière contrôlée, afin que les données et le comportement restent cohérents pendant le changement. Par exemple, si vous changez de base de données, le système peut verrouiller l’écriture jusqu’à ce que le basculement ait lieu (pour éviter les écritures fantômes, mais des lectures non conformes sont toujours possibles).

Si cela vous pose problème, vous pouvez écrire une page d'administration spéciale dans votre application (accès local préféré uniquement pour la sécurité) qui verrouille temporairement le système, puis lit et déploie toutes vos modifications avant le déverrouillage.

Si vous exploitez un site à fort trafic où la cohérence est importante, vous devez en tenir compte. Si vous pouvez déployer en dehors des heures où il y a peu ou pas de trafic, alors les vars php ou autres formats de texte standard suffiront.

J'aime l'idée d'avoir des "espaces de noms". ou une sorte d'arbre

afin que vous puissiez avoir: 

db.default.user

ou 

db.readonly.user

et ainsi de suite.

en ce qui concerne le code, j’ai créé une interface pour les lecteurs de configuration: vous pouvez donc disposer d’un lecteur de mémoire, d’un lecteur de tableaux, d’un lecteur de base de données, etc.

et une classe de configuration qui utilise ces lecteurs et vous permet d'avoir une configuration de n'importe quel type de source

Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top