Witam.


Chciałbym się dowiedzieć czy idę dobrą drogą

Posiadam dwie klasy, które są odpowiedzialne za nawiązywanie łączności z bazą danych. Klasa _DSN - przygotowuję dane potrzebne konstruktorowi PDO, dane te są zapisane w pliku tekstowym. Druga klasa to _PDOConnect(Singleton), odbiera i nawiązuje połączenie z bazą. Klasy są surowe jeżeli chodzi o sprawdzanie błędów itp. jest to świadome.

[PHP] pobierz, plaintext 
<?php
 
  class _DSN // Pobiera plik z danymi do logowania PDO
 {
   private $file;
   static  $dsnInfo = array();
 
    function __construct ($file) //Pobiera ścieżkę pliku i wywołuje metody.
    {
      if(is_file($file) && file_exists($file))
	  {
	  $this ->file = $file;
 
	   $this ->openFileDSN();
	   $this ->saveDSNInfo();
	  }
	  else {return false;}
    }
 
    function openFileDSN() // kroi dane DSN z pliku na tablice numeryczną
    {
      $file_get_contents = file_get_contents($this ->file);
      self::$dsnInfo = explode('|' ,$file_get_contents);
    }
    function saveDSNInfo() // zamienia indeksy numeryczne na string
    {
	$key = array('driver','host','dbname','user','password');
	self::$dsnInfo = array_combine($key, self::$dsnInfo);
    }
   }
 
   class _PDOConnect
   {
    static private $instance;
 
	  private function __construct() 
	  {
	  $Dsn = new _DSN('dsn.txt'); // W celu wykonania metod klasy _Dsn. Parametr konstruktora pobierany zewnątrz klasy.
 
	  try 
	  {
	    $PDO = new PDO (
	    _Dsn::$dsnInfo['driver'].
	    _Dsn::$dsnInfo['host'].
	    _Dsn::$dsnInfo['dbname'].
	    _Dsn::$dsnInfo['user'].
	    _Dsn::$dsnInfo['password']
	   );
	   }
	   catch (Exception $e)
	   {
	    echo $e ->getMessage();
	   }
	   }
 
	  public static function getInstance() 
	  {
	  if (empty(self::$instance))
	  {
	    self::$instance = new _PDOConnect();
	  }
	  return self::$instance;
	  }
    }
 
 
?>
[PHP] pobierz, plaintext 

1. Jeśli ma to być singleton brakuje prywatnej/chronionej metody __clone
2. Przemyślałbym obsługę wielu baz, bo nawet jeśli tego nie przewidujemy to może taka potrzeba się pojawić. I pytanie, czy musi to być singleton bo przecież nie piszemy skryptu, gdzie w każdym pliku na samym początku DB::getInstance()
3. Współpracę klas oceniam fatalnie - poczytaj o wzorcach współpracy klas, na początek dependency injection, "wstrzykiwanie zależności" - tak to chyba po polsku się nazywa
4. Podobnie klasę _DSN - zobacz, jak tego używasz, najpierw tworzysz obiekt by wywołać konstruktor a potem dobierasz się do pól statycznych? Podstawą są gettery i settery a nie kombinowanie metodami statycznymi czy magicznymi. A jeśli już to powinieneś pobrać sobie ten cfg jedną metodą statyczną gdzie przekazujesz ten plik jako parametr, bez konieczności tworzenia obiektu.

Możesz coś więcej powiedzieć, gdzie tutaj byś zastosował DI?

W konstruktorze _PDOConnect masz nas stałe

[PHP] pobierz, plaintext 
$Dsn = new _DSN('dsn.txt');
[PHP] pobierz, plaintext 

powinienes _DSN przesłać w argumencie konstruktora

[PHP] pobierz, plaintext 
private function __construct( _DSN $dsn ) 
[PHP] pobierz, plaintext 

i już masz wstrzyknięta zależność

Singelton to zły pomysł, obsługa jednego połączenia też.
Pula połączeń jeśli takowe już istnieje biore z puli.

[PHP] pobierz, plaintext 
 static  $dsnInfo = array();
[PHP] pobierz, plaintext 

To też zły pomysł. Zmienne prywatne, gety ,sety tak jak pisze ten alkocholik nademna.

Ja dodam, że singletona powinno się unikać, tak samo jak konstrukcji goto lub funkcji eval()
Ten wzorzec nie jest mile widziany podczas tworzenia dobrego obiektowego kodu.

Oczywiście ma on swoje zastosowanie, ale w 99,9% przypadków jest on stosowany w nieprawidłowy sposób.

1. Widziałem sporo wzorców Singleton i w żadnym nie spotkałem zastosowania metody __clone.

2. Nie rozumiem, czemu aktualny kod nie może nawiązywać połączenia z różnymi bazami?. Domyślam się, że chodzi o gotowy kod dla konstruktora klasy PDO i metodę, która będzie go wstrzykiwać w zależności od chęci użycia danej bazy.
Akurat w moim przypadku wystarczy zmodyfikować ręcznie kod w pliku.

3. Poczytam.

4. Racja to było desperackie podejście - bez obycia w programowaniu obiektowym, człowiek ma mętlik w głowie jak przychodzi powiązać klasy .

Ad1. Słabe przykłady miałeś
https://github.com/zendframework/zf1/blob/m...y/Zend/Auth.php

Poprawiłem co nieco semantykę i wiązanie klasy _DSN z _PDOConnect.

Pokażę tylko _PDOConnect

[PHP] pobierz, plaintext 
   class _PDOConnect
   {
    private static $instance;
    protected $dsnInfo;// przechowuję tablicę danych dsn z klasy _DSN
 
	 private function __construct() 
	 {}
 
	  public function getClass_DSN(_DSN $dsn) // delegacja klasy _DSN 
	  {
	    $this ->dsnInfo = $dsn ->getDsnInfo();
	  }
 
	  public function getPDOClass()
	  {
	   try 
	   {
	    $PDO = new PDO (
	     $this ->dsnInfo['driver'].
	     $this ->dsnInfo['host'].
	     $this ->dsnInfo['dbname'].
	     $this ->dsnInfo['user'].
	     $this ->dsnInfo['password']
	     );
	   }
	   catch (Exception $e)
	   {
	    echo $e ->getMessage();
 
	   }
	  }
 
	  public static function getInstance() 
	  {
	    if (empty(self::$instance))
	   {
	     self::$instance = new _PDOConnect();
	   }
	    return self::$instance;
	   }
      }
 
?>
[PHP] pobierz, plaintext 

Tylko teraz, powyższa implementacja klasy Singleton wymaga wywołania trzech metod:
_PDOConnect::getInstance();
getClass_DSN(_DSN $DSN);
getPDOClass();

Tak pomyślałem, że szkoda żeby konstruktor się marnował , więc stworzyłem implementację opartą na nawiązywaniu połączenia w konstruktorze - tak jak to było pierwotnie za implementowane.

[PHP] pobierz, plaintext 
  class _PDOConnect
   {
    private static $instance;
    protected static $dsnInfo; // przechowuję statyczną tablicę danych dsn z klasy _DSN
 
	 private function __construct() 
	 {
	     try 
	   {
	    $PDO = new PDO (
	     self::$dsnInfo['driver'].
	     self::$dsnInfo['host'].
	     self::$dsnInfo['dbname'].
	     self::$dsnInfo['user'].
	     self::$dsnInfo['password']
	     );
	   }
	   catch (Exception $e)
	   {
	    echo $e ->getMessage();
	   }
	 }
 
	  public static function getClass_DSN(_DSN $dsn) // delegacja klasy _DSN 
	  {
	    self::$dsnInfo = $dsn ->getDsnInfo();
	  }
 
	  public static function getInstance() 
	  {
	    if (empty(self::$instance))
	   {
	     self::$instance = new _PDOConnect();
	   }
	    return self::$instance;
	   }
      }
 
[PHP] pobierz, plaintext 

_PDOConnect::getClass_DSN(_DSN $DSN);
_PDOConnect::getInstance();

Teraz wystarczą tylko dwie metody i klasa gotowa do użycia. Co o tym sądzicie ma to ręce i nogi?

Stworzyłem takiego dziwaka:

[PHP] pobierz, plaintext 
/**
 * Jakieś takie udziwnienie...
 * Odziedzicz po tym a będziesz miał singletona... jak widać
 */
abstract class singleton {
 
    final private function __construct() {}
    final private function __clone() {}
 
    final public static function getInstance() {
        return (static::$instance)?self::onlyReturn(): self::loadAndReturn();
    }
 
    final static private function onlyReturn() {
        static::$instance->afterInstance();
        return static::$instance;
    }
 
    final static private function loadAndReturn() {
        $called_class = get_called_class();
        static::$instance = new $called_class();
        static::$instance->afterInstance();
        return static::$instance;
    }
 
    # nadpisz mnie, jestem konstruktorem
    protected function afterInstance() {}
 
}
[PHP] pobierz, plaintext 

I jest nawet wygodny w użyciu.