Cześć, mam problem z własną klasą do obsługi bazy.

Tymczasowo mam tylko samo połączenie, ale docelowo chciałbym w tej klasie zamieścić uniwersalne metody do wykonywania select'ów / update'ów / etc.

Kod mojej klasy:

[PHP] pobierz, plaintext 
<?php
class DB
{
    private static $instance;
 
    private function __construct() 
    {
        $dsn_user = 'xxx';
        $dsn_pass = 'yyy';
        $dsn_host = 'zzz';
        $dsn_base = 'www';
 
        try
        {
            self::$instance = new PDO ("mysql:host=" . $dsn_host . ";dbname=" . $dsn_base . ";port=3306", $dsn_user, $dsn_pass);
            self::$instance->exec("SET NAMES UTF8");
        }
        catch (PDOException $e)
        {
            echo "DB error (" . $e->getMessage() . ")";
            exit;
        }
    }
 
    private function __clone() {}
 
    public static function getInstance()
    {
        if (self::$instance === null) 
        {
            self::$instance = new self();
        }
        return self::$instance;
    }
}
?>
[PHP] pobierz, plaintext 

I teraz jak próbuje jej użyć:

[PHP] pobierz, plaintext 
<?php
require_once( dirname(__FILE__) . '/../class/DB.class.php' );
 
    $db = DB::getInstance();
 
    $r = $db->query("select * from Table");
?>
[PHP] pobierz, plaintext 

to dostaje komunikat: Fatal error: Call to undefined method DB::query().

Może mi ktoś wskazać gdzie popełniam błąd? Z góry dzięki za pomoc!

Jak już to rozszerz sobie PDO


i wtedy dodaj tam singletona.

A co niejasnego jest w tym komunikacie?


@up: Ano

No tak, ale w takim przypadku (class DB extends PDO) nie mogę zablokować konstruktora (private function __construct() {}) bo krzyczy mi błędem (Access level to DB::__construct() must be public (as in class PDO)).
Jak w takim przypadku zabezpieczyć klasę przed możliwością tworzenia obiektu?

A po co blokować konstruktor? Dopóki tylko ty korzystasz z tego kodu to nie ma takiej potrzeby.
Albo drugie wyjście, zamiast new self daj new PDO(...). Ale to już będzie mniej zgodne z wzorcem.

Tak się dziś cały dzień zastanawiam nad powyższym rozwiązaniem i wymyśliłem taką mieszankę singeltona i klasy statycznej (o ile można tak to nazwać

[PHP] pobierz, plaintext 
<?php
class DB
{
    private static $instance;
 
    private function __construct() {} 
    private function __clone() {} 
 
    private static function getInstance()
    {
        if (self::$instance === null) 
        {
            try
              {
                  self::$instance = new PDO ("mysql:host=aaa;dbname=bbb;port=3306", "ccc", "ddd");
                  self::$instance->exec("SET NAMES UTF8");
              }
              catch (PDOException $e)
              {
                  echo "DB error (" . $e->getMessage() . ")";
                  exit;
              }
        }
        return self::$instance;
    }
 
 
    public function query($_sql)
    {
        self::getInstance();
        $_r = self::$instance->prepare($_sql);
        if ( !$_r->execute() ) 
        {
            echo "DB error (" . $_r->errorInfo() . ")";
            exit;
        }
        return $_r->fetchAll();
    }
}
?>
[PHP] pobierz, plaintext 

I potem wystarczy tylko tyle do użycia:

[PHP] pobierz, plaintext 
<?php
$r = DB::query("select * from Table");
?>
[PHP] pobierz, plaintext 

Co sądzicie o takim rozwiązaniu? Ma rację bytu czy raczej przekombinowane?

Ja bym powiedział tak:

Albo klasa statyczna albo nie.

Jeżeli masz metody "niestatyczne" to singleton'a robisz tak:

[PHP] pobierz, plaintext 
<?php
private __construct() { 
// konstruktor
}
 
public function sing() {
static $handle;
if (!isset($handle)) {
$handle = new nazwaklasy();
}
return $handle
}
?>
[PHP] pobierz, plaintext 

i tworzysz potem obiekt klasy
$test = nazwaklasy::sing();