Configuration¶

Configuration de la Base de Données¶

CakePHP s’attend à trouver les détails de configuration de la base de données dans le fichier app/Config/database.php. Un exemple de fichier de configuration de base de données peut être trouvé dans app/Config/database.php.default. Une configuration basique complète devrait ressembler à quelque chose comme cela:

class DATABASE_CONFIG {
    public $default = array(
        'datasource'  => 'Database/Mysql',
        'persistent'  => false,
        'host'        => 'localhost',
        'login'       => 'cakephpuser',
        'password'    => 'c4k3roxx!',
        'database'    => 'my_cakephp_project',
        'prefix'      => ''
    );
}

Le tableau de connexion $default est utilisé tant qu’aucune autre connexion n’est spécifiée dans un model, par la propriété $useDbConfig. Par exemple, si mon application a une base de données pré-existante, outre celle par défaut, je pourrais l’utiliser dans mes models, en créant un nouveau tableau de connexion à la base de données, intitulé $ancienne, identique au tableau $default, puis en initialisant la propriété public $useDbConfig = 'ancienne'; dans les models appropriés.

Complétez les couples clé/valeur du tableau de configuration pour répondre au mieux à vos besoins.

datasource

Le nom de la source de données pour lequel ce tableau de configuration est destiné. Exemples : Database/Mysql, Database/Sqlserver, Database/Postgres, Database/Sqlite. Vous pouvez utiliser la syntaxe de plugin pour indiquer la source de données du plugin à utiliser.

persistent

Indique si l’on doit ou non utiliser une connexion persistante à la base. Si vous utilisez SQLServer, vous ne devriez pas activer les connections persistantes car cela entraîne des problèmes pour diagnostiquer des crashes dans les versions antérieures de CakePHP. A partir de la version 2.10.2, une exception sera lancée pour SQLServer si vous essayez de l’activer.

host

Le nom du serveur de base de données (ou son adresse IP).

login

Le nom d’utilisateur pour ce compte.

password

Le mot de passe pour ce compte.

database

Le nom de la base de données à utiliser pour cette connexion.

prefix (optionel)

La chaîne qui préfixe le nom de chaque table dans la base de données. Si vos tables n’ont pas de préfixe, laissez une chaîne vide pour cette valeur.

port (optionel)

Le port TCP ou le socket Unix utilisé pour se connecter au serveur.

encoding

Indique quel jeu de caractères utiliser pour envoyer les instructions SQL au serveur. Ces valeurs pour l’encodage par défaut de la base de données sont valables pour toutes les bases autres que DB2. Si vous souhaitez utiliser l’encodage UTF-8 avec des connexions mysql/mysqli, vous devez écrire “utf8” sans le tiret.

schema

Utilisé dans les paramètres d’une base PostgreSQL pour indiquer quel schéma utiliser.

datasource

Source de données Non-DBO à utiliser, ex: “ldap”, “twitter”.

unix_socket

Utilisé par les pilotes qui le supportent pour connecter via les fichiers socket unix. Si vous utilisez PostgreSQL et voulez utiliser les sockets unix, laissez la clé host vide.

ssl_key

Le chemin vers le fichier de clé SSL. (Seulement supporté par MySQL, nécessite PHP 5.3.7+).

ssl_cert

Le chemin vers le fichier de certificat SSL. (Seulement supporté par MySQL, nécessite PHP 5.3.7+).

ssl_ca

Le chemin vers l’autorité de certification SSL. (Seulement supporté par MySQL, nécessite PHP 5.3.7+).

settings

Un tableau de clé/valeur qui doit être envoyé à la base de données du serveur en tant que commandes SET quand la connexion est créée. Cette option est seulement supportée par Mysql, Postgres, et Sqlserver en ce moment.

A présent, vous aurez peut-être envie de jeter un œil aux Conventions de CakePHP. Le nommage correct de vos tables (et de quelques colonnes en plus) peut vous rapporter quelques fonctionnalités supplémentaires et vous éviter trop de configuration. Par exemple, si vous nommer votre table big_boxes, votre model BigBox, votre controller BigBoxesController, tout marchera ensemble automatiquement. Par convention, utilisez les underscores, les minuscules et les formes plurielles pour les noms de vos tables - par exemple : bakers, pastry_stores, et savory_cakes.

Chemins de Classe Supplémentaires¶

Il est occasionnellement utile d’être capable de partager des classes MVC entre des applications sur le même système. Si vous souhaitez le même controller dans les deux applications, vous pouvez utiliser le bootstrap.php de CakePHP pour amener ces classes supplémentaires dans la vue.

En utilisant App::build() dans bootstrap.php nous pouvons définir des chemins supplémentaires où CakePHP va recherchez les classes:

App::build(array(
    'Model' => array(
        '/path/to/models',
        '/next/path/to/models'
    ),
    'Model/Behavior' => array(
        '/path/to/behaviors',
        '/next/path/to/behaviors'
    ),
    'Model/Datasource' => array(
        '/path/to/datasources',
        '/next/path/to/datasources'
    ),
    'Model/Datasource/Database' => array(
        '/path/to/databases',
        '/next/path/to/database'
    ),
    'Model/Datasource/Session' => array(
        '/path/to/sessions',
        '/next/path/to/sessions'
    ),
    'Controller' => array(
        '/path/to/controllers',
        '/next/path/to/controllers'
    ),
    'Controller/Component' => array(
        '/path/to/components',
        '/next/path/to/components'
    ),
    'Controller/Component/Auth' => array(
        '/path/to/auths',
        '/next/path/to/auths'
    ),
    'Controller/Component/Acl' => array(
        '/path/to/acls',
        '/next/path/to/acls'
    ),
    'View' => array(
        '/path/to/views',
        '/next/path/to/views'
    ),
    'View/Helper' => array(
        '/path/to/helpers',
        '/next/path/to/helpers'
    ),
    'Console' => array(
        '/path/to/consoles',
        '/next/path/to/consoles'
    ),
    'Console/Command' => array(
        '/path/to/commands',
        '/next/path/to/commands'
    ),
    'Console/Command/Task' => array(
        '/path/to/tasks',
        '/next/path/to/tasks'
    ),
    'Lib' => array(
        '/path/to/libs',
        '/next/path/to/libs'
    ),
    'Locale' => array(
        '/path/to/locales',
        '/next/path/to/locales'
    ),
    'Vendor' => array(
        '/path/to/vendors',
        '/next/path/to/vendors'
    ),
    'Plugin' => array(
        '/path/to/plugins',
        '/next/path/to/plugins'
    ),
));

Configuration du Coeur¶

Chaque application dans CakePHP contient un fichier de configuration pour déterminer le comportement interne de CakePHP. app/Config/core.php. Ce fichier est une collection de définitions de variables et de constantes de la classe Configure qui déterminent comment votre application se comporte. Avant que nous creusions ces variables particulières, vous aurez besoin d’être familier avec la classe de configuration registry Configure de CakePHP.

Classe Configure¶

class Configure¶

Malgré quelques petites choses à configurer dans CakePHP, il est parfois utile d’avoir vos propres règles de configuration pour votre application. Dans le passé, vous aviez peut-être défini des valeurs de configuration personnalisées en définissant des variables ou des constantes dans certains fichiers. Faire cela, vous force à inclure ce fichier de configuration chaque fois que vous souhaitez utiliser ces valeurs.

La nouvelle classe Configure de CakePHP peut être utilisée pour stocker et récupéré des valeurs spécifiques d’exécution ou d’application. Attention, cette classe vous permet de stocker tout dedans, puis de l’utiliser dans toute autre partie de votre code: une tentative évidente de casser le modèle MVC avec lequel CakePHP a été conçu. Le but principal de la classe Configure est de garder les variables centralisées qui peuvent être partagées entre beaucoup d’objets. Souvenez-vous d’essayer de suivre la règle « convention plutôt que configuration » et vous ne casserez pas la structure MVC que nous avons mis en place.

Cette classe peut être appelée de n’importe où dans l’application dans un contexte statique:

Configure::read('debug');

static Configure::write($key, $value)¶

Paramètres:

• $key (string) – La clé à écrire, peut utiliser une valeur de notation avec points.

• $value (mixed) – La valeur à stocker.

Utilisez write() pour stocker les données dans configuration de l’application:

Configure::write('Company.name','Pizza, Inc.');
Configure::write('Company.slogan','Pizza for your body and soul');

Note

La notation avec points utilisée dans le paramètre $key peut être utilisée pour organiser vos paramètres de configuration dans des groupes logiques.

L’exemple ci-dessus pourrait aussi être écrit en un appel unique:

Configure::write(
    'Company', array('name' => 'Pizza, Inc.', 'slogan' => 'Pizza for your body and soul')
);

Vous pouvez utiliser Configure::write('debug', $int) pour intervertir les modes de debug et de production à la volée. C’est particulièrement pratique pour les intéractions AMF et SOAP quand les informations de debug peuvent entraîner des problèmes de parsing.

static Configure::read($key = null)¶

Paramètres:

• $key (string) – La clé à lire, peut utiliser une valeur avec notation avec points

Utilisée pour lire les données de configuration à partir de l’application. Par défaut, la valeur de debug de CakePHP est au plus important. Si une clé est fournie, la donnée est retournée. En utilisant nos exemples du write() ci-dessus, nous pouvons lire cette donnée:

Configure::read('Company.name');    //yields: 'Pizza, Inc.'
Configure::read('Company.slogan');  //yields: 'Pizza for your body and soul'

Configure::read('Company');

//yields:
array('name' => 'Pizza, Inc.', 'slogan' => 'Pizza for your body and soul');

Si $key est laissé à null, toutes les valeurs dans Configure seront retournées. Si la valeur correspondant à la $key spécifiée n’existe pas alors null sera retourné.

static Configure::consume($key)¶

Paramètres:

• $key (string) – La clé à lire, peut utiliser une valeur en notation avec points

Lit et supprime une clé de Configure. C’est utile quand vous voulez combiner la lecture et la suppression de valeurs en une seule opération.

static Configure::check($key)¶

Paramètres:

• $key (string) – La clé à vérifier.

Utilisé pour vérifier si une clé/chemin existe et a une valeur non-null.

Nouveau dans la version 2.3: Configure::check() a été ajoutée dans 2.3.

static Configure::delete($key)¶

Paramètres:

• $key (string) – La clé à supprimer, peut être utilisée avec une valeur en notation avec points

Utilisé pour supprimer l’information à partir de la configuration de l’application:

Configure::delete('Company.name');

static Configure::version¶

Retourne la version de CakePHP pour l’application courante.

static Configure::config($name, $reader)¶

Paramètres:

• $name (string) – Le nom du reader étant attaché.

• $reader (ConfigReaderInterface) – L’instance du reader étant attachée.

Attachez un reader de configuration à Configure. Les readers attachés peuvent ensuite être utilisés pour charger les fichiers de configuration. Regardez Chargement des fichiers de configuration pour plus d’informations sur la façon de lire les fichiers de configuration.

static Configure::configured($name = null)¶

Paramètres:

• $name (string) – Le nom du reader à vérifier, si null une liste de tous les readers attachés va être retournée.

Soit vérifie qu’un reader avec un nom donnée est attaché, soit récupère la liste des readers attachés.

static Configure::drop($name)¶

Retire un objet reader connecté.

Lire et écrire les fichiers de configuration¶

CakePHP est fourni avec deux fichiers readers de configuration intégrés. PhpReader est capable de lire les fichiers de config de PHP, dans le même format dans lequel Configure a lu historiquement. IniReader est capable de lire les fichiers de config ini du coeur. Regardez la documentation PHP pour plus d’informations sur les fichiers ini spécifiés. Pour utiliser un reader de config du coeur, vous aurez besoin de l’attacher à Configure en utilisant Configure::config():

App::uses('PhpReader', 'Configure');
// Lire les fichiers de config à partir de app/Config
Configure::config('default', new PhpReader());

// Lire les fichiers de config à partir du chemin
Configure::config('default', new PhpReader('/path/to/your/config/files/'));

Vous pouvez avoir de multiples readers attachés à Configure, chacun lisant différents types de fichiers de configuration, ou lisant à partir de différents types de sources. Vous pouvez intéragir avec les readers attachés en utilisant quelques autres méthodes de Configure. Pour voir, vérifier quels alias de reader sont attachés, vous pouvez utiliser Configure::configured():

// Récupère le tableau d'alias pour les readers attachés.
Configure::configured()

// Vérifie si un reader spécifique est attaché
Configure::configured('default');

Vous pouvez aussi retirer les readers attachés. Configure::drop('default') retirerait l’alias du reader par défaut. Toute tentative future pour charger les fichiers de configuration avec ce reader serait en échec.

Chargement des fichiers de configuration¶

static Configure::load($key, $config = 'default', $merge = true)¶

Paramètres:

• $key (string) – L’identifieur du fichier de configuration à charger.

• $config (string) – L’alias du reader configuré.

• $merge (boolean) – Si oui ou non les contenus du fichier de lecture doivent être fusionnés, ou écraser les valeurs existantes.

Une fois que vous attachez un reader de config à Configure, vous pouvez charger les fichiers de configuration:

// Charge my_file.php en utilisant l'objet reader 'default'.
Configure::load('my_file', 'default');

Les fichiers de configuration chargés fusionnent leurs données avec la configuration exécutée existante dans Configure. Cela vous permet d’écraser et d’ajouter de nouvelles valeurs dans la configuration existante exécutée. En configurant $merge à true, les valeurs ne vont pas toujours écraser la configuration existante.

Configure::dump('my_config.php', 'default');

Configure::dump('error.php', 'default', array('Error', 'Exception'));

// Stocke la configuration courante dans la clé 'user_1234' dans le cache 'default'.
Configure::store('user_1234', 'default');

// restaure la configuration exécutée à partir du cache.
Configure::restore('user_1234', 'default');

Créer vos propres readers de Configuration¶

Depuis que les readers de configuration sont une partie extensible de CakePHP, vous pouvez créer des readers de configuration dans votre application et plugins. Les readers de configuration ont besoin d’implémenter l” ConfigReaderInterface. Cette interface définit une méthode de lecture, comme seule méthode requise. Si vous aimez vraiment les fichiers XML, vous pouvez créer un reader de config simple Xml pour votre application:

// dans app/Lib/Configure/MyXmlReader.php
App::uses('Xml', 'Utility');
class MyXmlReader implements ConfigReaderInterface {
    public function __construct($path = null) {
        if (!$path) {
            $path = APP . 'Config' . DS;
        }
        $this->_path = $path;
    }

    public function read($key) {
        $xml = Xml::build($this->_path . $key . '.xml');
        return Xml::toArray($xml);
    }

    // Depuis 2.3 une méthode dump() est ausi requise
    public function dump($key, $data) {
        // code pour supprimer les données d'un fichier
    }
}

Dans votre app/Config/bootstrap.php, vous pouvez attacher ce reader et l’utiliser:

App::uses('MyXmlReader', 'Configure');
Configure::config('xml', new MyXmlReader());
...

Configure::load('my_xml');

La méthode read() du reader de config, doit retourner un tableau d’informations de configuration que la ressource nommé $key contient.

interface ConfigReaderInterface¶

Définit l’interface utilisée par les classes qui lisent les données de configuration et les stocke dans Configure.

ConfigReaderInterface::read($key)¶

Paramètres:

• $key (string) – Le nom de la clé ou l’identifieur à charger.

Cette méthode devrait charger/parser les données de configuration identifiées par $key et retourner un tableau de données dans le fichier.

ConfigReaderInterface::dump($key, $data)¶

Paramètres:

• $key (string) – L’identifieur dans lequel écrire.

• $data (array) – La donnée à supprimer.

Cette méthode doit supprimer/stocker la donnée de configuration fournie à une clé identifié par $key.

exception ConfigureException¶

Lancé quand les erreurs apparaissent quand le chargement/stockage/restauration des données de configuration. Les implémentations de ConfigReaderInterface devraient lancer cette exception quand elles rencontrent une erreur.

Configuration de Inflection¶

Les conventions de nommage de CakePHP peuvent être vraiment sympas - vous pouvez nommer votre table de base de données big_boxes, votre model BigBox, votre controller BigBoxesController, et tout fonctionne ensemble automatiquement. La façon dont CakePHP sait comment lier les choses ensemble est en infléctant les mots entre leurs formes singulière et plurielle.

Il y a des occasions (spécialement pour nos amis ne parlant pas Anglais) où vous pouvez être dans des situations où l”Inflector de CakePHP (la classe qui met au pluriel, au singulier, en CamelCase, et en underscore) ne fonctionne pas comme vous voulez. Si CakePHP ne reconnait pas vos Foci ou Fish, vous pouvez dire à CakePHP vos cas spéciaux.

Chargement d’inflections personnalisées —————————–———–

Vous pouvez utiliser Inflector::rules() dans le fichier app/Config/bootstrap.php pour charger des inflections personnalisées:

Inflector::rules('singular', array(
    'rules' => array('/^(bil)er$/i' => '\1', '/^(inflec|contribu)tors$/i' => '\1ta'),
    'uninflected' => array('singulars'),
    'irregular' => array('spins' => 'spinor')
));

ou:

Inflector::rules('plural', array('irregular' => array('phylum' => 'phyla')));

Va fusionner les règles fournies dans les ensembles d’inflection définies dans lib/Cake/Utility/Inflector.php, avec les règles ajoutées prenant le pas sur les règles du coeur.

Bootstrapping CakePHP¶

Si vous avez des besoins de configuration en plus, utilisez le fichier bootstrap de CakePHP dans app/Config/bootstrap.php. Ce fichier est exécuté juste après le bootstrapping du coeur de CakePHP.

Ce fichier est idéal pour un certain nombre de tâches de bootstrapping courantes:

• Définir des fonctions commodes.

• Enregistrer les constantes globales.

• Définir un model supplémentaire, une vue, et des chemins de controller.

• Créer des configurations de cache.

• Configurer les inflections.

• Charger les fichiers de configuration.

Faîtes attention de maintenir le model MVC du logiciel quand vous ajoutez des choses au fichier de bootstrap: il pourrait être tentant de placer des fonctions de formatage ici afin de les utiliser dans vos controllers.

Résister à la tentation. Vous serez content plus tard d’avoir suivi cette ligne de conduite.

Vous pouvez aussi envisager de placer des choses dans la classe AppController. Cette class est une classe parente pour tous les controllers dans votre application. AppController est un endroit pratique pour utiliser les callbacks de controller et définir des méthodes à utiliser pour tous les controllers.