OOP database
Pagina: « vorige 1 2 3 4 volgende »
Dat hele idee van een user object is wat mij betreft niet van toepassing op een php applicatie, omdat php stateless is. Elke keer dat je een script start begin je van voren af aan en php heeft geen weet van wat er daarvoor al is gebeurd. Je zal de data waar je mee werkt dus ergens vandaan moeten halen: user input, omgevingsvariabelen, database, sessie, wat dan ook.
Het gebruik van een user object dat wordt geserialized en opgeslagen in een sessie vind ik persoonlijk een knullige manier van het nabootsen van een database. Die gegevens staan namelijk al in een database, dus haal het gewoon daarvandaan als je het nodig hebt.
Dan terug naar de vraag, hoe je het in OOP doet is net als hoe je elke andere tabel update in OOP. Hoe update jij gegevens van bijvoorbeeld een product tabel?
Wat dat betreft mag je dat best negeren, het is zeker niet zo dat alles wat ik zeg perfect is en 'de' waarheid. De waarheid bestaat namelijk niet, zeker niet in dit geval.
Als je verder wilt zoals je nu al bezig bent dan moet je je denk ik 2 dingen realiseren. Ten eerste, die rechten moet je er echt in verwerken, anders kan iedereen zometeen alles aanpassen wat ze leuk vinden. Ten tweede moet je je bewust zijn van het feit dat alleen de database altijd de correcte (lees laatste) gegevens heeft. Als je dus een user object gebruikt op die manier, dan moet je ervoor zorgen dat gegevens waarop je bepaalde beslissingen maakt (zoals de rechten) altijd eerst worden geverifieerd met de database, voor je iets doet. Misschien nog beter, pas die rechten toe via een join in je query. Omdat de laatste gegevens altijd in de database staan, weet je zeker dat je dan goed zit.
En kan ik bij een userMapper dan niet gewoon de user class achterwege laten en gelijk met $userMapper->getUsername($id) etc. de gegevens uit de database halen, of is dit niet echt waar OOP voor bedoeld is?
Gewijzigd op 08/01/2013 20:22:43 door Lord Gaga
Ongeacht wat voor actie er wordt gevraagd gebruik ik dezelfde constructie. In het geval van een update van user gegevens stop ik dus alle gegevens die vanuit de request (POST in dit geval waarschijnlijk) komen in het parameters object en het model vogelt vervolgens wel uit wat er mee moet (en mag gebeuren). Indien de ingelogde gebruiker geen rechten heeft dan zal het model een exception opgooien waarop de controller via de view dit weer kan laten zien aan de gebruiker.
https://github.com/Monsma/Project-Atlanta/blob/master/application/models/pdo.php
Nergens checken op het feit dat $this->statement wel bestaat.
'die()' in een class?
Hmm, nee, deze kant zou ik inderdaad ook niet opgaan.
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
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
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
<?php
// Database Class
class Database
{
// Variables
private $host;
private $user;
private $pass;
private $name;
private $link;
// Constructor
public function __construct($host, $user, $pass, $name)
{
$this->host = $host;
$this->user = $user;
$this->pass = $pass;
$this->name = $name;
}
// Connect
public function connect()
{
return $this->link = mysqli_connect($this->host, $this->user, $this->pass, $this->name);
}
// Close
public function close()
{
return mysqli_close($this->link);
}
// Set Charset
public function set_charset($charset)
{
return mysqli_set_charset($this->link, $charset);
}
// Escape
public function escape($string)
{
return mysqli_real_escape_string($this->link, $string);
}
// Query
public function query($query)
{
return mysqli_query($this->link, $query);
}
// Num Rows
public function num_rows($result)
{
return mysqli_num_rows($result);
}
// Fetch Array
public function fetch_array($result)
{
return mysqli_fetch_array($result);
}
// Fetch Assoc
public function fetch_assoc($result)
{
return mysqli_fetch_assoc($result);
}
// Fetch Object
public function fetch_object($result)
{
return mysqli_fetch_object($result);
}
}
?>
// Database Class
class Database
{
// Variables
private $host;
private $user;
private $pass;
private $name;
private $link;
// Constructor
public function __construct($host, $user, $pass, $name)
{
$this->host = $host;
$this->user = $user;
$this->pass = $pass;
$this->name = $name;
}
// Connect
public function connect()
{
return $this->link = mysqli_connect($this->host, $this->user, $this->pass, $this->name);
}
// Close
public function close()
{
return mysqli_close($this->link);
}
// Set Charset
public function set_charset($charset)
{
return mysqli_set_charset($this->link, $charset);
}
// Escape
public function escape($string)
{
return mysqli_real_escape_string($this->link, $string);
}
// Query
public function query($query)
{
return mysqli_query($this->link, $query);
}
// Num Rows
public function num_rows($result)
{
return mysqli_num_rows($result);
}
// Fetch Array
public function fetch_array($result)
{
return mysqli_fetch_array($result);
}
// Fetch Assoc
public function fetch_assoc($result)
{
return mysqli_fetch_assoc($result);
}
// Fetch Object
public function fetch_object($result)
{
return mysqli_fetch_object($result);
}
}
?>
Ook zou ik je aanraden om te gaan werken met PDO. Voor meer info zie: http://net.tutsplus.com/tutorials/php/pdo-vs-mysqli-which-should-you-use/
Of heb ik dit verkeerd begrepen?
Erwin H op 17/01/2013 14:47:13:
Public property?
Nergens checken op het feit dat $this->statement wel bestaat.
'die()' in een class?
Hmm, nee, deze kant zou ik inderdaad ook niet opgaan.
Nergens checken op het feit dat $this->statement wel bestaat.
'die()' in een class?
Hmm, nee, deze kant zou ik inderdaad ook niet opgaan.
of je begrijpt het gewoon niet ik zou is een voorbeeld geven hoe je met mijn class overweg kan
Code (php)
zo simple
Nicky Monsma op 17/01/2013 20:03:25:
of je begrijpt het gewoon niet
Nou, ik denk dat dat wel meevalt. Maar je class is gewoon slecht opgezet.
die() is uberhaupt al een slechte gewoonte, maar als je met classes aan de slag gaat helemaal. Een simpele database class moet niet gaan bepalen hoe een applicatie afgesloten wordt als er een fout is.
Public properties betekent dat alles en idereen in die class kan gaan zitten vroeten en er vanalles in zetten, zonder dat die class weet wat er gebeurt.
Niet controleren of je statement wel bestaat betekent dat als er iets verkeerd gaat die class hard onderuit gaat zonder dat je het afhandelt.
Dan kan het makkelijk aan te roepen zijn, het is nog steeds slecht geschreven, vol met fouten en levert je meer problemen op dan gewoon direct met PDO werken.
en ik kan er ook wel een trigger_error van maken maar je moet niet bijdehand gaan doen
heb jij certificaten in PHP? ik toevallig wel dus beetje opletten,
BTW de class check wel of er een statement is beter lezen of wil je een brilletje
Code (php)
Als statement niet bestaat, of nog niet is aangemaakt gaat je class vreselijk onderuit.
En ja, die is hetzelfde als exit, dat is beide net zo slecht. Een class behoort ofwel een foutcode terug te geven, ofwel een exception op te gooien. Wat als je deze class morgen in een script wil gebruiken waar je een file aanmaakt voor downloading. Dan wil je echt niet dat er een string naar het scherm wordt gestuurd met die foutmelding. Dan is namelijk niet echt een juist bestand, wel?
zonder statement kan je ook geen fetch_assoc / result of num_rows maken
ik geef je een voorbeeld hoe je echt moet parameteren
Code (php)
1
2
3
4
2
3
4
<?php
$DB = new Database();
$DB->prepare('SELECT email FROM users WHERE username = ? LIMIT 1')->bind_param(array('monsma'))->execute()->result();
?>
$DB = new Database();
$DB->prepare('SELECT email FROM users WHERE username = ? LIMIT 1')->bind_param(array('monsma'))->execute()->result();
?>
zoals je wel ziet heb ik nu een result gemaakt snap je het nu?
Pagina: « vorige 1 2 3 4 volgende »