Hilfe zu Prepared Statements mit PDO

[Puccini]

HI,

ich bin jetzt, dank Tip hier aus dem Forum, dabei,meine Anwendung etwas schneller und vor allem Sicherer zu machen.
Mit hilfe der Prepared Statements erhoffe ich mir eine sichere Webanwendung.

Dafür wollte ich aber noch folgednes wissen.

Bisher hab ich das immer so gemacht, das ich eine Funktion (db_connect()) hatte, welche ich for jeder Abfrage aufgerufen hab. Der rückgabewert war dabei die erzeugte Verbindung.
Das hat wunderbar funktioniert.
Jetzt meine Frage, kann ich das genauso bei den Statements machen?
Hier der link zur erzeugung der DB-Verbindung mit PDO:
PHP 5.1: Abstraktion und Prepared Statements mit PDO

Erzeug ich da nicht jedesmal ein neues OBjekt??

$strDbLocation = 'mysql:dbname=ipro;host=127.0.0.1';
$strDbUser = 'root';
$strDbPassword = '';

try
{
  $objDb = new PDO($strDbLocation, $strDbUser, $strDbPassword);
}
catch (PDOException $e)
{
  echo 'Fehler beim Öffnen der Datenbank: ' . $e->getMessage();
}

wäre quasi in meiner db_connect() zu finden. Der rückgabeparameter wäre $objDb.

Sollte ich diese Variable da lieber global benutzen oder vor jeder abfrage die funktion db_connect aufrufen?


Thx shconmal

 

[freak131]

schau dir mal "singleton" an, hier ein Beispiel:

/* Singleton - Pattern
 * (c) Tim Glabisch
 * 
 * Verwendungszweck
 * Das Singleton ist wohl eins der einfachsten Entwurfsmuster,
 * oft macht es keinen Sinn das erzeugen mehrerer Instanzen zu erlauben.
 * Das Singleton verhindert dies, bietet jedoch die Möglichkeit über eine 
 * statische Funktion an die Instanz zu gelangen.
 * 
 * Hinweis:
 * Der Konstruktor wird als protected deklariert, die Funktion __clone
 * als private, dies bezieht sich auf das Vererbungsverhalten. Die Klasse
 * kann natürlich auch als "final" gekennzeichnet werden.
 */

class cCar
{
    private static $instance = null;
    
    protected function __construct()  {}
    private function __clone() { }
    
    public static function fGetInstance()
    {
        if(self::$instance == null)
            self::$instance = new cCar;
            
        return self::$instance;
    }
    
    // optional als Beispiel
        public function bSetTestString($string)
        {
            return $this->sTestString = $string;
        }
        
        public function sGetTestString()
        {
            return $this->sTestString;
        }
}

//und ausprobieren:

$cCar = cCar::fGetInstance();
$cCar->bSetTestString('<hr/>just a test :)');

$cSecondInstance = cCar::fGetInstance();
echo $cSecondInstance->sGetTestString();

// $cNewInstance = new cCar(); // Fatal Error
// $cCloneInstance = clone $cCar; // Fatal Error

 

[Gelöschtes Mitglied 3007]

auch zum gebrauch einer begrenzten anzahl von instanzen

class Test {
    private static $instances = array();

    private function __construct() {
        // do something
    }

    public static function getInstance($name) {
        if(array_key_exists($name, self::$instances)) {
            self::$instances[$name] = new self($name);
        }
        return self::$instances[$name];
    }
}

 

[gollum1990]

Ich würde dir eher zu Factory Method bzw. Registry raten.

 

[Patrick Leuppert]

    public static function fGetInstance()
    {
        if(self::$instance == null)
            self::$instance = new cCar;
            
        return self::$instance;
    }

Ich hab gelernt, dass eine Klasse, die von sich selbst ein Objekt erzeugt, dies mit self machen soll. Ist aber eigentlich auch Wurscht ;-)

    public static function fGetInstance()
    {
        if(self::$instance == null)
            self::$instance = new self;
            
        return self::$instance;
    }

 

[freak131]

oder so:

/* Singleton - Pattern
 * (c) Tim Glabisch
 * 
 * Hinweis:
 * Benötigt PHP 5.3
 */

abstract class ac_singleton
{
 private static $instance = null;
    
    protected function __construct()  {}
    final private function __clone() { }
    
    final public static function fGetInstance()
    {
        if(self::$instance == null)
        {
            $className = get_called_class();
            self::$instance = new $className;
        }
            
        return self::$instance;
    }
}

eine factory wäre hier doch unangebracht, bzw. müste diese auch ein singleton implementieren.