[OOP] PDO verwerken in class.
Ik heb wat kleine dingen veranderd aan dit script en ik heb ipv standaard queries gebruik gemaakt van de PDO 'plugin' van php.
Met standaard programmeren (dus niet OOP) werkt PDO perfect. Maar zo gauw ik dit in mijn class verwacht krijg ik de Error:
"Fatal error: Call to a member function quote() on a non-object in C:\wamp\www\classes\Auth\clsAuthentication.php on line 29"
Mijn script kun je hier vinden: http://rafb.net/p/KC3sGL62.html
Ik heb wel een oplossing, de PDO connection in de constructor zetten, maar dit is ver van praktisch. Volgens mij is extenden ook niet een goede oplossing.
Weet iemand hoe ik dit werkend krijg ?
Gewijzigd op 01/01/1970 01:00:00 door Kwastie
Er zijn eigenlijk een paar mogelijkheden:
een class om pdo schrijven die singleton is waardoor je ter plekke een instance kunt "maken" en gebruiken
De $db variabele meegeven aan de class (en dus binnen de class opslaan)
Een registry class schrijven waar je de variabele $db aan meegeeft, die classe kun je dan overal om die variabele vragen
oplossing 2 is misschien het makkelijkst, maar het ligt meestal aan de omgeving wat hier het handigste is.
Gewijzigd op 01/01/1970 01:00:00 door TJVB tvb
Code (php)
Gewijzigd op 01/01/1970 01:00:00 door Jurgen assaasas
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
<?php
class Myclass
{
protected $connection;
public function __construct(PDO $connection)
{
$this->connection = $connection;
}
public function myfunction()
{
$this->connection->query("SELECT * FROM table");
// continue..
}
}
?>
<?php
$connection = new PDO('mysql:host=localhost;dbname=db', 'user', 'pass');
$myclass = new Myclass($connection);
?>
class Myclass
{
protected $connection;
public function __construct(PDO $connection)
{
$this->connection = $connection;
}
public function myfunction()
{
$this->connection->query("SELECT * FROM table");
// continue..
}
}
?>
<?php
$connection = new PDO('mysql:host=localhost;dbname=db', 'user', 'pass');
$myclass = new Myclass($connection);
?>
Edit:
Jurgen was me voor ;)
Gewijzigd op 01/01/1970 01:00:00 door Cedric
Opties:
- elke class een PDO database connectie meegeven
- $_GLOABAL gebruiken
- elke class extenden op de PDO class
Ik vind eigelijk alle 3 de oplossingen niets.
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?php
class Register {
static public function DB() {
static $db;
if(!$db) {
$db = new PDO('mysql:host='.SERVER.';dbname='.DB, USER, PASS);
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
return $db;
}
}
// Dan kan je het op de volgende manier pdo aanroepen
public function findById($id) {
$pdo = Register::DB();
$stmt = $pdo->prepare
// enz
}
?>
class Register {
static public function DB() {
static $db;
if(!$db) {
$db = new PDO('mysql:host='.SERVER.';dbname='.DB, USER, PASS);
$db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
}
return $db;
}
}
// Dan kan je het op de volgende manier pdo aanroepen
public function findById($id) {
$pdo = Register::DB();
$stmt = $pdo->prepare
// enz
}
?>
Normaal gesproken geef je de klasses die je nodig hebt mee via de constructor maar omdat een database class zo centraal staat vind ik dit ook wel een mooie oplossing. Het Register kan je dan ook voor andere dingen zoals een template engine gebruiken.
Gewijzigd op 01/01/1970 01:00:00 door Jan geen
optie 1 is de meest correcte.
Oplossing 2 is een beetje twijfelachtig, omdat je de klasse moet kennen wil je weten dat je een global variabele nodig hebt, je de variabele gemakkelijk kan vervangen met iets verkeerts, ook per ongeluk waardoor plotseling de zooi niet meer werkt. En al je klassen maken gebruik van dezelfde PDO instantie.
Oplossing 3 is niet te doen. Dat zou inhouden dat iedere instantie een eigen verbinding opzet, en dat je de constructor als het ware kwijt bent aan PDO, je zal iedere instantie al de verbindingsgegevens mee moeten geven. Dat is nog erger dan oplossing 1. Erger, je extend PDO om functionaliteit terwijl je eigenlijk alleen moet extenden wanneer een klasse een specifiekere variant is van een andere klasse. Extenden doe je bij een "is een", niet bij "gebruikt een". Extend je PDO, kan je niets anders meer extenden.
In mijn ogen is oplossing nummero uno de prettigste. $pdo aan de constructor meegeven is relatief weinig moeite en geeft je toch de meest makkelijk te begrijpen code en de meeste flexibiliteit.
Met optie 2 en 3 gaat de 'flexibiliteit' erg omlaag.
Code (php)
Of belachelijk kort
Code (php)
Op deze manier kan je database instantie niet worden overschreven, wordt hij pas aangemaakt wanneer hij echt nodig is, en krijg je een duidelijke foutmelding dat er iets mis is. Je houdt het probleem dat je maar 1 verbinding binnen alle instanties kan gebruiken. Maar in voornamelijk kleine applicaties zou dat niet een probleem hoeven zijn. En dan is het wel makkelijk.
$result = $m_mysql->doSql($sql); zorgt er voor dat er een connectie wordt gemaakt, dat de query wordt uitgevoerd, connectie verbroken, result weergegeven. De connectie gegevens zitten in dat object. Overal waar ik mySQL nodig heb binnen een class geef ik dat object $m_mysql mee aan de andere class.
Maar inderdaad, het is ook simpel om je config file gewoon een beetje anders te gebruiken.
ipv.
Code (php)
1
2
3
4
5
2
3
4
5
<?
$db_user = 'root';
$db_pasword = 'huppeldepup';
...
?>
$db_user = 'root';
$db_pasword = 'huppeldepup';
...
?>
maak je iets als
Code (php)
Dan kan je getDbConfig() overal in je site gebruiken.