PDO, OOP, config
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.
Met vriendelijke groet.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
<?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(){}
}
[/code]
/**
* 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(){}
}
[/code]
Gewijzigd op 01/01/1970 01:00:00 door Andreas Warnaar
Kijkens naar de volgende sites:
http://php.net/manual/en/function.parse-ini-file.php(Ik neem aan dat je configfile een ini bestand is)
http://www.phpro.org/tutorials/Introduction-to-PHP-PDO.html#7
http://www.phpro.org/tutorials/Model-View-Controller-MVC.html
http://www.phpro.org/articles/Application-Configuration.html#6.1
Deze heeft mij opweg geholpen bij het begin.
Gewijzigd op 01/01/1970 01:00:00 door Andreas Warnaar
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:
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.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<?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");
}
}
?>
// 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");
}
}
?>
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)
Gewijzigd op 01/01/1970 01:00:00 door Jelmer -