W jaki sposób odczytujecie plik konfiguracyjny w swoich aplikacjach?

Załóżmy że w wielu klasach odczytywana jest tablica z pliku np.

[PHP] pobierz, plaintext 
$config = Config::read('plik.php');
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
class Config
{
    private static $opt;
    private static $file;
 
    private function __construct(){}
    private function __clone(){}
 
 
    /**
    *    Odczytuje parametry pliku konfiguracyjnego
    *
    */
    public static function read($var=null)
    {
        if(!isset($var) OR empty($var) OR !is_string($var))
        {
            return null;
        }
 
        static::getAll(self::$file);
 
        if(isset(self::$opt[$var]))
        {
			return self::$opt[$var];
		}
 
        if(false !== strpos($var, '.'))
        {
			$names = explode('.', $var, 3);
			//pr($names);
			$var = $names[0];
			//pr($var);
            switch (count($names))
            {
                case 2:
                if(isset(self::$opt[$var][$names[1]]))
                {
                    return (string)self::$opt[$var][$names[1]];
				}
			    break;
                case 3:
                if(isset(self::$opt[$var][$names[1]][$names[2]]))
                {
                    return self::$opt[$var][$names[1]][$names[2]];
                }
                break;
            }// end switch
 
		}// end strops
 
    return null;
    }// end function read
 
 
    /**
    *    Ładuje plik konfiguracyjny
    *
    */
    public static function load($var)
    {
        self::$file = basename($var);
    }// end function load
 
 
    /**
    *    Zwraca całą tablicę pliku konfiguracyjnego
    *
    */
    public static function getAll($file)
    {
        self::$file = basename($file);
 
        if(file_exists(self::$file))
        {
            include self::$file;
        }
        else
        {
            return null;
        }
 
        if(isset($config) AND is_array($config))
        {
            self::$opt = $config;
            unset($config);
            return self::$opt;
        }
        else
        {
            unset($config);
            return null;
        }   
    }// end function getAll
 
} // end class Config
[PHP] pobierz, plaintext 

Jednak za każym razem gdy wywołam

[PHP] pobierz, plaintext 
$config = Config::read('plik.php');
[PHP] pobierz, plaintext 

Plik jest wczytywany od nowa. Nie mogę użyć include_once ponieważ wtedy będzie odczytany tylko 1 plik konfiguracyjny i to zablokuje odczyt drugiego.

Zawsze możesz zrobić to na zasadzie takiej leniwej fabryki. Już mówię o co chodzi:

Załóżmy że w wielu miejscach używasz

[PHP] pobierz, plaintext 
    $config = Config::read('plik.php');
[PHP] pobierz, plaintext 

Odczytywanie pliku "plik.php" za każdym razem to strata wydajności itd itp...

Co zrobić? Jeżeli nie zapisujesz konfiguracji z poziomu PHP (choć to też w sumie nie stanowiło by problemu) najlepiej zrobić to tak:

1. dodaj do klasy config tablicę (private) o kluczach będących nazwami plików.
2. przy każdym wywołaniu sprawdzaj czy istnieje tablica z indeksem takim jak plik z argumentu metody ::read(...)
3. jeśli taki rekord istnieje w tablicy - zwracasz go
4. jeśli nie - metoda robi swoje, ładuje plik, zapisuje go do tablicy z indeksem równym nazwie pliku i zwraca
5. każde kolejne wywołanie idzie wtedy z tablicy (bez ponownego ładowania pliku)

W FW np CI mój kontroler musi dziedziczyć po kontrolerze CI. Czy jest sens takiego rozwiązania, że Główny kontroler wczytuje cfg jako

[PHP] pobierz, plaintext 
$this->config = Config::read('plik.php');
[PHP] pobierz, plaintext 

A później w innym kontrolerze dziedziczę po nim ten kod przez extends i mogę w swojej klasię odczytać $this->config ? Czy to na jedno wyjdzie?

Jeżeli dobrze Cię zrozumiałem to samo dziedziczenie kodu wykona tą funkcję znowu więc będzie miał tak naprawdę 2 razy dobieranie się do tego pliku "plik.php" najpierw FC potem zwykły C :/

Sephirus - A co rozumiesz przez "Jeżeli nie zapisujesz konfiguracji z poziomu PHP" ?

W tych przykładach odczytujesz konfigurację z pliku php - ale czy planujesz na przykład ją z poziomu PHP zapisywać czyli na przykład:

[PHP] pobierz, plaintext 
$config = Config::read('plik.php');
$config->databaseUser = 'stefan';
Config::save('plik.php',$config);
[PHP] pobierz, plaintext 

W zasadzie to mam z tym problem nadal...

[PHP] pobierz, plaintext 
class Config
{
    private static $opt;
    private static $file;
 
    private static $configs = array();
 
    private function __construct(){}
    private function __clone(){}
 
 
    /**
    *    Zwraca całą tablicę pliku konfiguracyjnego
    *
    */
    public static function get($file)
    {
        self::$file = basename($file);
 
        if(isset(self::$configs[self::$file]))
        {
             echo '<div style=color:green>tablica</div>';
             return self::$configs[self::$file];
        }
        else
        {
            echo '<div style=color:red>include</div>';
            if(file_exists(self::$file))
            {
                include self::$file;
            }
            else
            {
                return null;
            }
 
            if(isset($config) AND is_array($config))
            {
                self::$opt = $config;
                unset($config);
 
                self::$configs = array(self::$file => self::$opt);
 
                return self::get(self::$file);
            }
            else
            {
                unset($config);
                return null;
            }   
        }
    }// end function getAll
 
} // end class Config
[PHP] pobierz, plaintext 

Nie wiem w którym miejscu robię błąd, ale nadal są includowane pliki...




Powinno wczytać plik test2.ini.php i test.ini.php.

Nie wiem jaki to ma związek z mvc, no ale dobra niech będzie że ma.

Na swoje potrzeby, zresztą nie tylko ja tak robię, mam klasę która przechowuje konfigurację i nic więcej nie robi (nie pobiera żadnych plików, ani ich nie nadpisuje). Gdzieś na początku wrzucam tablicę konfiguracji do klasy:

[PHP] pobierz, plaintext 
Config::add($this->loadConfig('config/settings.yml'));
[PHP] pobierz, plaintext 

i dostęp w obrębie całej aplikacji mam taki sam. Nie muszę wczytywać żadnych plików itp. A cała klasa konfiguracji to zwykłe setery i getery plus jedna prywatna właściwość, która przechowuje konfigurację i na której operują setery/getery. Czyli u ciebie metody: read, load moim zdaniem są zbędne. No chyba że masz różne pliki konfiguracyjne, ale to i tak powinieneś robić to inaczej.

EDIT: chyba zajarzyłem o co ci chodzi. Zrób sobie tymczasowo wszystkie właściwości publiczne i zaraz po wywołaniu:

[PHP] pobierz, plaintext 
Config::get('test2.ini.php');
[PHP] pobierz, plaintext 

sprawdź sobie co trzymasz w tych właściwościach:

[PHP] pobierz, plaintext 
var_dump(Config::$opt, Config::$file, Config::$configs);
[PHP] pobierz, plaintext 

I powoli całość rozkładaj na czynniki pierwsze. Tak samo powinieneś zresztą zrobić z ładowaniem konfiguracji:

[PHP] pobierz, plaintext 
var_dump(Config::get('test2.ini.php'));
[PHP] pobierz, plaintext 

by_ikar - ale właśnie co to jest $this->loadConfig('config/settings.yml') ? Przecież wczytujesz i tak ten plik. Więc jak się do niego odwołujesz? I tak mam wiele plików konfiguracyjnych.

edycja:

Tak, rozbiłem je i zawierają to co mają zawierać. Prócz tego że tablica jest tylko jedna. W powyższym kodzie nie zapisuje się 2 kluczy i nie wiem dlaczego.

[PHP] pobierz, plaintext 
self::$configs[self::$file] = self::$opt;
[PHP] pobierz, plaintext 

EDIT:

Popatrz jak to tutaj jest zrobione
https://github.com/kohana/core/blob/3.2/mas...kohana/i18n.php

Ok wszystko jest ok i jasne - linijka 42:

[PHP] pobierz, plaintext 
// masz:
self::$configs = array(self::$file => self::$opt);
 
// powinno być
self::$configs[self::$file] = self::$opt;
[PHP] pobierz, plaintext 

EDIT: ooo Sorry @up - dłuugo pisałem odpowiedź bo mi przeszkodzili - dubel nie celowy