PDO in static class
Ik zit even met een klein probleempje, en google helpt mij niet echt.
Ik heb een class met alleen maar static functies.
Maar hoe kan k nou een PDO connectie tot stand brengen, en die gewoon blijven gebruiken, in iedere functie.
dus ik wil dit:
Code (php)
Ik hoop dat het zo duidelijk is.
Gewijzigd op 01/01/1970 01:00:00 door Nicoow Unknown
(Denk er maar eens over na. Wanneer zou een statische class geïnitialiseerd moeten worden?)
Je kan natuurlijk wel zelf een public static initialize() method toevoegen, en die aanroepen direct na je class definitie, maar je hebt in theorie geen 100% zekerheid dat __initialize maar 1 keer wordt aangeroepen (in praktijk eigenlijk altijd wel)
Code (php)
Deze problemen heb je niet (en de zekerheid wel) wanneer je geen static classes gebruikt.
*disclaimer: ik heb het niet zo op static en singleton.
Ik heb het opzich ook niet zo op static, vind het toch wel beetje zweverig,,
Ik gebruik het eigenlijk alleen voor dingen als MathHelper class o.i.d.
Ik was het eigenlijk een beetje zat om constant in iedere controller opnieuw de database connectie te moeten maken.
Maar heb dat nu opgelost door een algemene controller class, die een (jawel) static functie aanroept die een PDO instance terug geeft.
Dus ik heb eigenlijk nu dit:
//Config.php
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<?php
class Config
{
private static $db_host = "localhost";
private static $db_database = "videos";
private static $db_username = "root";
private static $db_password = "";
public static function PDO()
{
$pdo = new PDO('mysql:host=' . self::$db_host . ';
dbname=' . self::$db_database,
self::$db_username,
self::$db_password,
array(PDO::ATTR_PERSISTENT => true));
$pdo->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
return $pdo;
}
}
?>
class Config
{
private static $db_host = "localhost";
private static $db_database = "videos";
private static $db_username = "root";
private static $db_password = "";
public static function PDO()
{
$pdo = new PDO('mysql:host=' . self::$db_host . ';
dbname=' . self::$db_database,
self::$db_username,
self::$db_password,
array(PDO::ATTR_PERSISTENT => true));
$pdo->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
return $pdo;
}
}
?>
Mijn Controller Class
Code (php)
En dan een echt controller class
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
class Video extends Controller
{
public $_id;
private $_title;
private $_image;
private $_min;
private $_sec;
private $_tags = array();
protected $sql;
private $tagController;
public function Video($id = null, $name = null, $image = null, $min = 0, $sec = 0)
{
$this->_id = $id;
$this->_title = $name;
$this->_image = $image;
$this->_min = $min;
$this->_sec = $sec;
$this->sql = parent::getPDOInstance();
}
}
?>
class Video extends Controller
{
public $_id;
private $_title;
private $_image;
private $_min;
private $_sec;
private $_tags = array();
protected $sql;
private $tagController;
public function Video($id = null, $name = null, $image = null, $min = 0, $sec = 0)
{
$this->_id = $id;
$this->_title = $name;
$this->_image = $image;
$this->_min = $min;
$this->_sec = $sec;
$this->sql = parent::getPDOInstance();
}
}
?>
Is dit een goede / acceptabele oplossing,
Of krijg ik nu een tik op mijn vingers?
Gewijzigd op 01/01/1970 01:00:00 door Nicoow Unknown
Ik heb het ooit eens gehoord, maar snapte het niet echt..
Dit kan dus bijvoorbeeld heel handig zijn als je een class aanmaakt die wiskundige vraag stukken oplost.
Even een klein voorbeeld
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
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
<?php
class wisNormal
{
public function telOp($a, $b)
{
return $a + $b;
}
//Yeej, Puberale humor
public function trekAf($a, $b)
{
return $a - $b;
}
}
class wisStatic
{
public static function telOp($a, $b)
{
return $a + $b;
}
//Yeej, Puberale humor
public static function trekAf($a, $b)
{
return $a - $b;
}
}
?>
class wisNormal
{
public function telOp($a, $b)
{
return $a + $b;
}
//Yeej, Puberale humor
public function trekAf($a, $b)
{
return $a - $b;
}
}
class wisStatic
{
public static function telOp($a, $b)
{
return $a + $b;
}
//Yeej, Puberale humor
public static function trekAf($a, $b)
{
return $a - $b;
}
}
?>
Dit lijkt opzich niet heel verschillend, maar de aanroep is wel heel verschillend.
Als je het "normaal" doet, dan is je script ongeveer zo:
Code (php)
1
2
3
4
5
6
7
2
3
4
5
6
7
<?php
$a = 5;
$b = 3;
$calculator = new wisNormal();
$c = $calculator->telOp($a, $b);
$d = $calculator->trekAf($a, $b);
?>
$a = 5;
$b = 3;
$calculator = new wisNormal();
$c = $calculator->telOp($a, $b);
$d = $calculator->trekAf($a, $b);
?>
Hier moet je dus eerst een instantie aanmaken van een class, en daarna kan je pas de functies aanroepen.
bij een static functie gaat het zo:
Code (php)
1
2
3
4
5
6
2
3
4
5
6
<?php
$a = 5;
$b = 3;
$c = wisStatic::telOp($a, $b);
$d = wisStatic::trekAf($a, $b);
?>
$a = 5;
$b = 3;
$c = wisStatic::telOp($a, $b);
$d = wisStatic::trekAf($a, $b);
?>
Hier zie je dus dat je niet eerst een instantie hoeft aan te maken.
Dit heeft als grote nadeel, dat je niks in een klasse variable kan opslaan, omdat die namelijk daarna weer verdwijnt.
Dus statische functies zijn er eigenlijk alleen voor simpele functies, voor luie programmeurs (en dat zijn we toch allemaal??), en andere kleine dingen, die je snel wilt kunnen aanroepen, zonder dat er een groot geheim achter zit.
Ik hoop dat het een beetje duidelijk is zo.
Bedankt voor je uitleg. Helemaal duidelijk.
Eén ding begrijp ik niet.
Je kan toch ook gewoon wisNormal::telOp($a,$b) doen?
Als je in wat striktere talen gaat programmeren, dan zal dit je niet meer lukken.
Dankjewel voor je uitleg (:
ps: ff mbt je script.
Ik zelf vind "sql" een beetje een vreemde naam in dit geval:
$this->sql = parent::getPDOInstance();
noem het dan pdo ofzo (:
Gewijzigd op 01/01/1970 01:00:00 door Boris Mattijssen
ik ben geen voorstander van hoe je dit aanpakt, gebruik dan depedency injection ofzo, maar als je het zo wil doen, zou ik er dit van maken:
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
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
<?php
class Config
{
private static $db_host = "localhost";
private static $db_database = "videos";
private static $db_username = "root";
private static $db_password = "";
protected static $_pdo = null;
public static function PDO()
{
if ( self::$_pdo === null ) {
$pdo = new PDO('mysql:host=' . self::$db_host . ';
dbname=' . self::$db_database,
self::$db_username,
self::$db_password,
array(PDO::ATTR_PERSISTENT => true));
$pdo->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
self::$_pdo = $pdo;
}
return self::$_pdo;
}
}
?>
class Config
{
private static $db_host = "localhost";
private static $db_database = "videos";
private static $db_username = "root";
private static $db_password = "";
protected static $_pdo = null;
public static function PDO()
{
if ( self::$_pdo === null ) {
$pdo = new PDO('mysql:host=' . self::$db_host . ';
dbname=' . self::$db_database,
self::$db_username,
self::$db_password,
array(PDO::ATTR_PERSISTENT => true));
$pdo->setAttribute( PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION );
self::$_pdo = $pdo;
}
return self::$_pdo;
}
}
?>
Dependency Injection
Alleen zie ik dan niet helemaal in waarom mijn Config anders moet,
Ik kan begrijpen dat jij het zo zou doen, maar dat maakt voor de rest niks uit,
Je krijgt dan gewoon zoiets.
$database = Config::PDO();
$video = new Video();
$video->setDatabase = $database;
Ik zie nu trouwens na een test dat hij hem maar 1 keer aanmaakt, bedankt voor jou methode, ik ga hem van je stelen en misbruiken =D