Publicado em 27 de jan.

Arquivos de configuração com PHP OO

Olá a todos.

Caros,

Qual seria a melhor opção para se trabalhar com mais de um ambiente de trabalho em um projeto, usando PHP OO?
Por exemplo, quando eu fazia meus projetos sem orientação à objetos, fazia algo como:

config.php

<?php
 $_CONFIG = array();

 $_CONFIG['production'] = array(
 'database' => array(
 'name' => 'test',
 'user' => 'root',
 'pass' => '123456',
 'port' => '3306'
 )
 );

 $_CONFIG['staging'] = array(
 'database' => array(
 'name' => 'test',
 'user' => 'root',
 'pass' => '123456',
 'port' => '3306'
 )
 );

index.php

<?php
 if ( $_SERVER['HTTP_HOST'] === 'meuhost.com.br' )
 define( 'CONFIG_APP', 'production' );
 else
 define( 'CONFIG_APP', 'staging' );

 function insert()
 {
 global $_CONFIG[ CONFIG_APP ];
 $config = $_CONFIG[ CONFIG_APP ];

 //do something
 }

Bom, como estou usando PHP OO agora, imagino que seja errado usar variáveis globais para armazenar as configurações dos meus projetos,
mesmo tendo visto isso no Code Igniter por exemplo, que é bem famoso e largamente utilizado.

Pensei então em criar uma classe para fazer um parser em um arquivo .ini com as configurações do projeto, usando a função parse_ini_file,
ou até mesmo em criar uma classe que só contém constantes, algo do tipo:

<?php
 class Config
 {
 const MYSQL_NAME = 'test';
 const MYSQL_USER = 'root';
 const MYSQL_PASS = '1234';
 }

Existe alguma boa prática para isto, ou seria desnecessário? Qual seria a melhor opção para "guardar" as configurações de um projeto?

Existe algum material de leitura que me mostre o caminho?

Obrigado.

Discussão (2)

Entre ou cadastre-se para participar da discussão

Entrar Criar conta

Marcielo· 27 de jan.

Existe algum material de leitura que me mostre o caminho?

Você está no caminho..

Bom, como estou usando PHP OO agora, imagino que seja errado usar variáveis globais para armazenar as configurações dos meus projetos

Não só para configurações, para qualquer uso globais não devem ser usadas.

Pensei então em criar uma classe para fazer um parser em um arquivo .ini com as configurações do projeto, usando a função parse_ini_file

Ótimo!

ou até mesmo em criar uma classe que só contém constantes

Nananinanão! São configurações, devem ser facilmente configuradas..sem contar que isso não seria configurável, você estaria preso as constantes.

Qual seria a melhor opção para "guardar" as configurações de um projeto?

Acredito eu que não haja "melhor opção", o projeto deve dar suporte à opções.

Bom, irei sugerir uma forma bacana..você poderia ter uma classe configurações que as carregasse de várias formas possíveis e ao mesmo tempo as representasse, por exemplo:

class Config {

 private $configs = array();

 public function __construct(array $configs) {
 foreach ($configs as $name => $config) {
 $this->set($name, $config);
 }
 }

 public static function load($configs) {
 if (is_string($configs) && is_file($configs)) {
 if (!file_exists($configs)) {
 throw new InvalidArgumentException(sprintf(
 'Ops! File of configurations not exists in "%s', $configs
 ));
 }

 $ext = pathinfo($configs, PATHINFO_EXTENSION);

 switch ($ext) {
 case 'ini':
 $configs = parse_ini_file($configs, true);
 break;
 case 'php':
 $configs = include $configs;
 break;
 default:
 throw new InvalidArgumentException(sprintf(
 'Extension "%s" not supported', $ext
 ));
 break;
 }
 } elseif (!is_array($configs)) {
 throw new InvalidArgumentException(sprintf(
 'Type "%s" not supported for configurations', gettype($configs)
 ));
 }

 return new self($configs);
 }

 public function set($name, $value) {
 if (is_array($value)) {
 $value = new self($value);
 }

 $this->configs[$name] = $value;
 }

 public function get($name) {
 if (!isset($this->configs[$name])) {
 throw new InvalidArgumentException(sprintf(
 'Configuration not found for "%s"', $name
 ));
 }

 return $this->configs[$name];
 }

 public function __set($name, $value) {
 $this->set($name, $value);
 }

 public function __get($name) {
 return $this->get($name);
 }
}
 

 Usando..

Carregando configurações a partir de um array:

$config = new Config(array(
 'database' => array(
 'host' => 'localhost',
 // ...
 )
));

A partir de um .ini:

$config = Config::load('/path/to/file.ini');
ou até mesmo um arquivo php com um array:

file.php

return array(
 'host' => 'localhost',
 // ...
);

$config = Config::load('/path/to/file.php');

Acessando parâmetros:

echo $config->database->host; // saída: localhost
Repare que todos os arrays se transformaram em objetos..e recursivamente, portanto:

var_dump($config->database instanceof Config); // bool(true)

Para resolução de nomes também é possível:

echo $config->database->get('db.host');
Alterando ou adicionando um parâmetro:

$config->database->host = '127.0.0.1';
Setando configurações:

class Connection {

 public function setConfig(Config $config) {
 // ...
 }
}

$connection = new Connection();
$connection->setConfig($config->database);

O exemplo é apenas uma forma de demonstrar..

Uma outra forma poderia ser:

interface DatabaseConfiguration {

 public function getDatabaseConfig();
}

class Configuration implements DatabaseConfiguration {

 public function getDatabaseConfig() {
 return array(
 'host' => 'localhost',
 // ...
 );
 }
}

Espero ter contribuído ;)

Jonaslhp· 27 de jan.

Opa, foi uma senhora resposta Marcielo! Sua colaboração foi enorme, muito obrigado mesmo.
Estarei estudando essa forma de implementação, como ainda não implementei nada em OO e estou apenas na fase de testes e estudos, isso vai ser de grande valia.