Wat is de beste manier om gebruik te maken van PDO, in combinatie met een config file waar de login gegevens van de DB in staan, in classes. Sommige classes hebben al een extend of een implements. En bij sommige heb ik wel database connectie nodig, en bij sommige niet.
<?php
/**
* Database class
* Extends PDO make it available as a Singleton
* @author Andreas Warnaar
*/
class Db{
/**
*@var object self::Db
*/
private static $instance = NULL;
/**
* the constructor is set to private so
* so nobody can create a new instance using new
*/
private function __construct() {}
/**
* Return DB instance or create intitial connection
* @return object (PDO)
* @access public
*/
public static function getInstance() {
if (!self::$instance)
{
$config = Config::getInstance();
$registry = Registry::getInstance();
$section =$config->getValue($registry->configsection);
$dbhost = $section['database.host'];
$dbname = $section['database.name'];
$dbpass = $section['database.pass'];
$dbuser = $section['database.user'];
self::$instance = new PDO("mysql:host=$dbhost;dbname=$dbname", $dbuser, $dbpass);
self::$instance-> setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
return self::$instance;
}
/**
* Like the constructor, we make __clone private
* so nobody can clone the instance
*/
private function __clone(){}
}
En hoe haal je die gegevens op met de section? Ik snap niet hoe jij de config gegevens ophaalt, en wat nu te doen bij een nieuwe classe? elke keer deze classe aanroepen voor connectie?
Ben bekend met de ini file, de MCV. Maar ik snap de Singleton niet echt. elke keer als ik een class maak, hoe roep ik de Singleton gedeelte aan zodat ik altijd database verbinding heb.
Ik wil dus niet bij elke class in de construct de database connectie maken.
Wat ik nu heb, en wat mij gewoon fout lijkt is:
<?php
class Voorbeeld
{
public function __construct ()
{
//maak hier database connectie
}
public function innit ()
{
//doe hier iets met de database.
}
}
?>
Singleton lijkt me niet helemaal ideaal voor een database-verbinding. Een Singleton class is een class waar maar één instantie van kan bestaan, en deze instantie wordt overal gebruikt. Soms wil je een tweede, of een derde database-verbinding erbij hebben (andere user, andere database, andere verbinding zodat je die ene in de transactie kan houden terwijl je die andere gebruikt voor andere dingen)
Maar wat je zoals jezelf al aangeeft ook niet wil is ieder object een eigen verbinding laten opzetten. Wat je bijvoorbeeld kan doen is je configuratie in een class zetten (want in PHP is een class-definitie ook maar een tekstbestandje, net als een ini-bestandje. Maar je krijgt er wel veel meer flexibiliteit en simpelere code voor terug) Zoiets bijvoorbeeld. De class Environment bevat allemaal static methods die jouw configuratie bevat.
<?php
// static class die de PDO verbinding maar één keer aanmaakt.
class Environment
{
static public function database()
{
static $pdo;
if(!$pdo)
$pdo = new PDO('...');
return $pdo;
}
}
class Gastenboek
{
public function berichten()
{
$stmt = Environment::database()->query("SELECT * FORM berichten");
}
}
?>
Ok, dat ziet er beter uit. Was al volop aan het lezen over singleton, maar ik snap niet hoe dit mijn verbinding kan behouden overal met die classe. Dus jij zegt alle configuratie gewoon in een classe zetten met static's? En functies maken die gegevens die je nodig hebt returnt of gewoon connecties etc aanmaakt?
Ik gebruik de logingegevens voor de database nergens anders dan bij het verbinden met de database zelf. Dus dan lijkt het me slimmer om een instantie van PDO uit m'n configuratie te laten komen. Kan ik ook nog beslissen of ik PDO, of een andere class die je op dezelfde manier als PDO gebruikt instantieer.
Singleton is meer geschikt voor classes die wel een bepaalde staat hebben, maar ook maar één instantie van kan zijn. Bijvoorbeeld een object voor de uitvoer van je script (een response-object) Je pagina kan maar één uitvoer hebben (je kan niet met 2 html-pagina's antwoorden) maar je kan die uitvoer wel geleidelijk opbouwen. (headers toevoegen, stukjes html toevoegen)
edit: singleton heb je strikt gezien nooit nodig in PHP. Alles wat met een singleton class kan kan in weze ook met een class met alleen maar static methods. Het enige voordeel van een singleton class is dat je je object op dezelfde manier aanspreekt als een normaal object ($variabele->method()) Daardoor zet je niet overal in je code wat er daadwerkelijk voor object in $variabele hebt zitten, en kan je er ook nog een ander object instoppen dat dezelfde methods heeft. (ik geloof dat het loose coupling heet)
