OOP User classe
Pagina: « vorige 1 2 3 4 volgende »
Het volgende voorbeeld werkt dus gewoon als jij dit herkennen noemt:
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 TestController extends BaseController
{
public function preDispatch( )
{
// Shizzle
parent::preDispatch( );
}
public function testAction( )
{
// Model aanroepen
$tbl_test = new Table_Test( );
// Het kan via methoden
$this->view->test = $tbl_test->getTest( );
// OF
$this->view->test = $tbl_test->select( )->where( 'test = ?', 'test' )->order('RAND');
}
}
class TestController extends BaseController
{
public function preDispatch( )
{
// Shizzle
parent::preDispatch( );
}
public function testAction( )
{
// Model aanroepen
$tbl_test = new Table_Test( );
// Het kan via methoden
$this->view->test = $tbl_test->getTest( );
// OF
$this->view->test = $tbl_test->select( )->where( 'test = ?', 'test' )->order('RAND');
}
}
Quote:
(models op dit moment ook niet wegens tijdgebrek :))
Ahum, gauw aanpassen, het scheelt je juist tijd ;) Jij maakt dus gebruik van het VC pattern? ;)
Gewijzigd op 28/12/2010 15:26:39 door Niels K
Allereerst bedankt voor het advies om niet meer met de oude MySQL extensies te werken.
Daarnaast bedankt voor jouw geduld en begrip. Het is voor iemand die altijd Top-Down heeft gewerkt en onlangs pas op OOP is overgestapt hele lastige materie, juist omdat het zo abstract is. De eerste stap is gemaakt: het OOP-denken. Nu nog het MVC gebeuren. Ik lees er wel een hoop over maar ik denk dat ik het pas echt goed begrijp als ik zelf een kleine MVC toepassing in elkaar heb gestoken.
Wat betreft jouw uitleg: duidelijk, voor elke var een get en set aanmaken.
@Niels:
Bedankt voor het duidelijke MVC overzicht. Dit was ik natuurlijk al wel een aantal keren tegengekomen en het verhaal Model View Controller en het voordeel daarvan is mij meer dan duidelijk. Het probleem (voor velen denk ik) is dat het zo 'abstract' is aangezien de pagina pas in het laatste stadium (view) vorm krijgt.
Is het een idee om het Zend Framework te downloaden en daarmee aan de slag te gaan of denk je dan dat ik door de bomen het bos niet meer zie? Het is volgens mij haast onmogelijk om een klein, werkend MVC scriptje te maken....klopt dat?
Gewijzigd op 28/12/2010 15:59:57 door The Ultimate
Quote:
Allereerst bedankt voor het advies om niet meer met de oude MySQL extensies te werken.
Tja, op zich kan je dit nog makkelijk een jaar of 2 volhouden zonder dat je er problemen mee krijgt. Maar niet te min raad ik je ook gewoon PDO aan.
Quote:
Is het een idee om het Zend Framework te downloaden en daarmee aan de slag te gaan of denk je dan dat ik door de bomen het bos niet meer zie? Het is volgens mij haast onmogelijk om een klein, werkend MVC scriptje te maken....klopt dat?
Wat noem jij klein? Een blog? Nee, dat is gewoon prima in MVC te doen. Geef anders wat voorbeelden van OO wat je om wilt zetten in MVC, dan hoop ik je daarbij te helpen.
Object georiënteerd programmeren heeft trouwens niets te maken met MVC, andersom wel. Je hoeft dus niet perse iets in het MVC model te bouwen wil je object georiënteerd programmeren. Object georiënteerd programmeren is een denkwijze / programmeer stijl. Je moet object georiënteerd "denken" om het te begrijpen. Zelfde als met Engels, je kunt pas goed Engels spreken en verstaan als je er ook in "denkt" (tijdens mijn stage in Kenia begon ik na een half jaar zelfs in het Engels te dromen haha).
Maar goed je moet ook wat geduld hebben met het leren ervan. Op een gegeven moment ga je het grote voordeel ervan in zien. Advies van mijn kant is gewoon er blijven spelen ermee, en niet in te grote stappen.
Succes!
Gewijzigd op 28/12/2010 16:42:59 door Niels K
Maar eerst OO en daarna MVC dat is waar je helemaal gelijk in hebt.
Maar goed, zoals ik daarnet al zei ik zal straks wat commentaar over de klasse plaatsen, ben nu op het werk, daar kan ik geen hele verhalen gaan typen.
Gewijzigd op 28/12/2010 16:55:58 door Niels K
Het grote voordeel van het gebruik van ZF is dat als je het eenmaal onder de knie hebt, je natuurlijk niet verder meer hoeft te zoeken. Aangezien ik nog nooit enige scripting heb gevolgd op school (studeer namelijk rechten en ben dus geen programmer) duurt het allemaal wat langer en heb je soms bij de simpelste zaken nog vragen.
@Niels: Ik ben bezig met een geheel nieuwe webapplicatie. Ik heb de applicatie op een locale server (usbwebserver) in Top-Down style (overigens niet OOP) gemaakt. Nu wilde ik de applicatie opnieuw maar dan OOP opzetten voordat ik de website live gooi. Maar als ik dan beter meteen maar de extra stap kan zetten door ZF te gebruiken/leren dan moet ik dat misschien maar doen. Kost wel wat meer tijd, maar dan hoef ik de komende tijd niet meer aan te sleutelen.
Een paar dingen die beter kunnen op welke ik mis, volgorde klopt niet ik schrijf gewoon op wat ik op dat moment denk.
- De benaming van je klasses en wat ze doen is niet geheel correct ( kom ik zo op terug )
- het script moet altijd openstaan voor uitbreiding, daarom kan je het beste al je variabelen protected maken.
- Ik zie allemaal underscores voor je variabelen staan, waarvoor is dat? Coding style? Ik vind dat altijd zo lelijk staan maar goed..
- over je constructor: Je kan het beste je variabelen een beteren benaming geven, $id zegt niet zoveel, kan het database id wezen, emial id, user id.
- Je kan ook voor de database een dependency afdwingen, dan krijg je dus dit:
- Verder is het niet gebruikelijk om in de constructor bepaalde queries of actie uit te voeren, daarvoor kan je gewoon het beste een andere methode voor realiseren.
- Je while is een beetje vaag? Waarom gebruik je $this->_db(fetchAssoc) ? Kan je het beste gewoon in dit veranderen $this->_db->fetchAssoc( $result );
- Ik mis PHPdoc
Goed meer heeft je klasse niet, en dat is juist het grootste probleem, de aanpak van je user klasse kan veel beter. Hier onder een voorbeeldje hoe ik een authentificatie aanpak. De klasses moet je zelf even realiseren, is gelijk een goede oefening voor je, het is overigens met het Zend_Framework gemaakt, maar dat maakt niet uit.
Code (php)
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
<?php
$authInstance = Zend_Auth::getInstance( );
// Controleren of er al een identity bestaat
if( !$authInstance->hasIdentity( ) ) {
// Redirecten naar login ( controller )
}
?>
$authInstance = Zend_Auth::getInstance( );
// Controleren of er al een identity bestaat
if( !$authInstance->hasIdentity( ) ) {
// Redirecten naar login ( controller )
}
?>
Mijn login controller ziet er dan zo uit.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
<?php
/**
* LoginController, controller welke verantwoordelijk is voor authenticeren van een klant
*
* @category GestioneCMS
* @package Controllers
* @subpackage LoginController
* @see BaseController
*
* @author Niels kieviet <[email protected]>
* @version $Revision v1.00$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
class LoginController extends BaseController
{
/**
* Action methode welke verantwoordelijk is voor het opvangen van een request
* wat is gedaan vanuit het login form. Aan de hand van de gegevens trachten tot het
* autenticeren van de opgegeven credentials
*
* @access Public
* @return Void
*/
public function indexAction( )
{
if( !Zend_Auth::getInstance( )->hasIdentity( ) ) {
$this->_helper->layout->setLayout( 'login' );
$errors = array( );
if( $this->getRequest( )->isPost( ) ) {
if( !Zend_Validate::is( $this->getRequest( )->getParam( 'customer' ), 'NotEmpty' ) ) {
$errors['customer'] = true;
}
if( !Zend_Validate::is( $this->getRequest( )->getParam( 'username' ), 'NotEmpty' ) ) {
$errors['username'] = true;
}
if( !Zend_Validate::is( $this->getRequest( )->getParam( 'password' ), 'NotEmpty' ) ) {
$errors['password'] = true;
}
if( count( $errors ) != 0 ) {
$this->view->errors = $errors;
}
else {
$customer = $this->getRequest( )->getParam( 'customer' );
$username = $this->getRequest( )->getParam( 'username' );
$password = $this->getRequest( )->getParam( 'password' );
if( $this->process( $customer, $username, $password ) ) {
$this->_redirect( 'index' );
}
}
}
}
}
/**
* Methode voor het controleren, authenticeren van de opgegeven credentials
*
* @param String $client
* @param String $username
* @param String $password
* @access Protected
* @return Void
*/
protected function process( $customer, $username, $password )
{
$authAdapter = $this->getAuthAdapter( );
$authAdapter->setCustomer( $customer );
$authAdapter->setIdentity( $username );
$authAdapter->setCredential( $password );
$authAdapter->_authenticateCreateSelect( );
$auth = Zend_Auth::getInstance( );
$result = $auth->authenticate( $authAdapter );
if( $result->isValid( ) ) {
$customer = $authAdapter->getResultRowObject( );
$auth->getStorage( )->write( $customer );
return true;
}
return false;
}
/**
* Methode tot het verkrijgen en retourneren van de authenticatie adapter
*
* @access Protected
* @return Adapter
*/
protected function getAuthAdapter( )
{
$dbAdapter = Zend_Db_Table::getDefaultAdapter( );
$authAdapter = new Adapter_Auth_Adapter( $dbAdapter );
$authAdapter->setTableName( 'auth_user' )
->setIdentityColumn( 'username' )
->setCredentialColumn( 'password' );
//->setCredentialTreatment( 'SHA1');
return $authAdapter;
}
}
?>
/**
* LoginController, controller welke verantwoordelijk is voor authenticeren van een klant
*
* @category GestioneCMS
* @package Controllers
* @subpackage LoginController
* @see BaseController
*
* @author Niels kieviet <[email protected]>
* @version $Revision v1.00$
* @copyright Copyright (c) 2010, Niels Kieviet
*/
class LoginController extends BaseController
{
/**
* Action methode welke verantwoordelijk is voor het opvangen van een request
* wat is gedaan vanuit het login form. Aan de hand van de gegevens trachten tot het
* autenticeren van de opgegeven credentials
*
* @access Public
* @return Void
*/
public function indexAction( )
{
if( !Zend_Auth::getInstance( )->hasIdentity( ) ) {
$this->_helper->layout->setLayout( 'login' );
$errors = array( );
if( $this->getRequest( )->isPost( ) ) {
if( !Zend_Validate::is( $this->getRequest( )->getParam( 'customer' ), 'NotEmpty' ) ) {
$errors['customer'] = true;
}
if( !Zend_Validate::is( $this->getRequest( )->getParam( 'username' ), 'NotEmpty' ) ) {
$errors['username'] = true;
}
if( !Zend_Validate::is( $this->getRequest( )->getParam( 'password' ), 'NotEmpty' ) ) {
$errors['password'] = true;
}
if( count( $errors ) != 0 ) {
$this->view->errors = $errors;
}
else {
$customer = $this->getRequest( )->getParam( 'customer' );
$username = $this->getRequest( )->getParam( 'username' );
$password = $this->getRequest( )->getParam( 'password' );
if( $this->process( $customer, $username, $password ) ) {
$this->_redirect( 'index' );
}
}
}
}
}
/**
* Methode voor het controleren, authenticeren van de opgegeven credentials
*
* @param String $client
* @param String $username
* @param String $password
* @access Protected
* @return Void
*/
protected function process( $customer, $username, $password )
{
$authAdapter = $this->getAuthAdapter( );
$authAdapter->setCustomer( $customer );
$authAdapter->setIdentity( $username );
$authAdapter->setCredential( $password );
$authAdapter->_authenticateCreateSelect( );
$auth = Zend_Auth::getInstance( );
$result = $auth->authenticate( $authAdapter );
if( $result->isValid( ) ) {
$customer = $authAdapter->getResultRowObject( );
$auth->getStorage( )->write( $customer );
return true;
}
return false;
}
/**
* Methode tot het verkrijgen en retourneren van de authenticatie adapter
*
* @access Protected
* @return Adapter
*/
protected function getAuthAdapter( )
{
$dbAdapter = Zend_Db_Table::getDefaultAdapter( );
$authAdapter = new Adapter_Auth_Adapter( $dbAdapter );
$authAdapter->setTableName( 'auth_user' )
->setIdentityColumn( 'username' )
->setCredentialColumn( 'password' );
//->setCredentialTreatment( 'SHA1');
return $authAdapter;
}
}
?>
Het is misschien even een lastig stukje om hierbij de juiste klasses te realiseren maar als je dat éénmaal doorhebt moet OO geen probleem meer opleveren. Ik zie net dat jelmer je al een opzet heeft gegeven. Aan de hand daarvan moet dit ook te doen zijn.
Goed, we gaan verder met de database, zoals ik net zei kan je beter een dependency aanmaken, nogmaals zo dus:
Om dit te laten werken moet je even weten hoe je de huidige database klasse moet veranderen. Ik heb een voorbeeld voor je gemaakt in gewoon mysql zodat je het goed kunt begrijpen.
Als je gaat beginnen met het maken van een klasse moet je eerst goed bedenken wat deze doet, schrijf dit in het begin ook gewoon op. Later zal dit allemaal vanzelf gaan.
Goed, database handler. Wie / Wat / Waar / Hoe / omschrijving dus even voor jou hieronder uitgewerkt:
Een database is een applicatie waarin alle data van een applicatie op een gestructureerde
manier opgeslagen kan worden. Data wordt opgeslagen in de vorm van tabellen die relaties
met elkaar hebben. De data kan gemanipuleerd worden doormiddel van zogeheten SQL queries.
Het resultaat van een query komt terug in de vorm van een resultset. Dit zijn de resultaten
in een intern formaat. Deze kunnen omgezet worden in voor PHP leesbare formaten.
Er zijn diverse databases in omloop. De meest gebruikte voor PHP is MySQL, maar er zijn ook
MSSQL, PostgreSQL en nog vele anderen.
Goed, als we de zelfstandige naam worden even enkelvoud maken en ze eruit plukken krijg je deze lijst:
- Database
- Applicatie
- Data
- Manier
- Tabel
- Relatie
- SQL query
- Resultaat
- Resultset
- Formaat
- PHP
- MySQL
- MSSQL
- PostgreSQL
Er staan nu een aantal woorden tussen die we niet nodig hebben bij het modelleren van de database, of er staan een aantal dubbele tussen, zo hebben we het woord 'applicatie' wat enkel verwijst naar de definitie van Database. Deze klasse dient geen enkel doel in onze applicatie.
Dan hebben we Manier; de manier waarop data opgeslagen wordt. Dit is niet iets voor onze applicatie, want wij willen alleen een laag op de database bouwen, dus niet de database zelf implementeren. De manier waarop de data opgeslagen wordt is dus niet van belang voor ons. Voor Formaat geldt precies hetzelfde.
PHP is de taal waarin we de code gaan implementeren daar is dus geen klasse voor nodig. Ook deze kunnen we uit ons lijstje strepen. Je houd dus de volgende lijst over:
- Database
- Data
- Tabel
- Relatie
- SQL query
- Resultaat
- Resultset
- MySQL
- MSSQL
- PostgreSQL
Ook in dit lijstje valt echter nog te strepen. Zo is resultaat en resultset ongeveer hetzelfde, beide representeren het resultaat van een query. We kunnen de klasse Resultaat dus wegstrepen. Dan hebben we nog een aantal klasse die we beter in een ander formaat dan een klasse kunnen representeren.
Zo hebben we data, maar dat is handiger om dat gewoon in een array neer te zetten, of bij het resultset de gebruiker zelf te laten kiezen welk formaat hij / zij de data in wil. Deze kan dus ook weg uit de lijst. Een beetje hetzelfde geldt voor SQL query. Dit kan gewoon in een string representatie.
Wat je vaak ziet tegenwoordig is dat er een hele bibliotheek omheen gebouwd wordt waarmee je doormiddel van code SQL queries kan samenstellen. Het nadeel hiervan is dat dit ontzettend ingewikkeld wordt; SQL is een complexe taal en dat het ook nog eens traag wordt terwijl gewoon de string representatie net zo flexibel is en een stuk eenvoudiger. We zullen dan ook gewoon gebruik maken van SQL queries. Deze klasse kan uit de lijst weggestreept worden.
Dan hebben we nog twee klassen die met de inhoud van de database te maken hebben. Dit is tabel en relatie. Dit is iets dat de database intern bij houdt, maar onze applicatie hoeft zich hier niet van bewust te zijn, deze kan gewoon toe met het uitvoeren van queries en de data die daar uit komt.
Ons lijstje wordt een stuk kleiner en komt er als volgt uit te zien:
- Database
- Resultset
- MySQL
- MSSQL
- PostgreSQL
Nu we een mooi compact lijstje over hebben , kunnen we gaan bedenken welke attributen er bij elke klasse horen.
De Database heeft in PHP code meestal een connectie handler, deze zal dus ergens in de database bijgehouden moeten worden. Dat is ook direct het enige dat PHP nodig heeft om queries uit te voeren op de database. Dat is dus het enige attribuut. Voor MySQL, MSSQL en PostgreSQL geldt precies hetzelfde. Deze gebruiken allemaal hun eigen functies, maar al deze functies maken gebruik van deze connectie handler.
Voor het resultset hebben we een vergelijkbare handler nodig. Als je een query uitvoert op de database krijg je altijd een result handler terug waarop je vervolgens een aantal functies uitvoert om de data eruit te krijgen. Wat alleen wel handig is om te onthouden is dat deze functies ook weer specifiek zijn voor elk database type. We hebben dus eigenlijk voor elke database type een Resultset klasse nodig.
Als we deze attributen en klassen toevoegen krijgen we de volgende lijst:
Database
- connectie
Resultset
- resultaat
MySQL
-connectie
En zo bijvoorbeeld ook voor de volgende database types
MSSQL
- connectie
PostgreSQL
- connectie
MySQLResult
- resultaat
MSSQLResult
- resultaat
PostgreSQLResult
- resultaat
We kunnen nu gaan bedenken welke methoden elke klasse zou moeten hebben, maar voordat we gaan doen zal je misschien al opgevallen zijn dat een aantal klassen sterk op elkaar lijken wat betreft ontwerp. Als je voor jezelf al wat methoden bedacht hebt, zal je zien dat voor deze klassen ook de methoden hetzelfde blijven. Alleen de implementatie van de methoden verschilt. Hier is waar overerving komt kijken in de OOP wereld.
Overerving doe je op het moment dat je kan zeggen: Klas1 is een Klas2. In dit geval gaat dat op voor MySQL, MSSQL en PostgreSQL. Dit zijn allemaal databases, dus zullen ze ook allemaal erven uit Database. Het zelfde geldt ook voor MySQLResult, MSSQLResult en PostgreSQLResult met Resultset. Dit zijn allemaal resultsets van de betreffende databases. Alleen de functies die gebruikt worden om de database aan te spreken verschillen.
Het volgende wat op valt is dat we voor Database en Resultset eigenlijk helemaal geen implementatie kunnen geven voor de verschillende methoden. Alle implementatie is immers database specifiek. Toch willen we deze overkoepelende klasse hebben, zodat we later ergens af kunnen dwingen dat er een Database verwacht wordt zonder aan te geven welke Database we eigenlijk afdwingen. Voor deze specifieke gevallen is in PHP de Interface in het leven geroepen. Database en Resultset zijn beide interfaces en hebben dus alleen methoden en geen attributen.
Voor consistentie is het ook handig om de klasse Resultset even te hernoemen. De andere resultaat klassen heten allemaal DatabasenaamKlasse. Dit kunnen we voor Resultset dus ook doen en deze DatabaseResult noemen.
Nu zijn we zo ver om methoden te bedenken. Aangezien we geen database specifieke methoden nodig hebben, hoeven we alleen methoden te bedenken voor beide interfaces.
De database klasse was voornamelijk bedoelt voor het bijhouden van de verbinding en het uitvoeren van queries. Hier hebben we dus een methode maak_verbinding() bij nodig en een methode query() om een query uit te voeren. Het resultaat van de methode query is vervolgens een DatabaseResult waarmee de data uit het resultaat gehaald kan worden.
De interface DatabaseResult heeft dan ook de methoden fetch_assoc(); haal data in de vorm van een array uit de database, aantal_regels(); het aantal regels dat het resultaat bevat en eventueel een methode om direct alle resultaten in een array te krijgen: fetch_alles().
De bedachte methoden komen geen van allen uit de beschrijving, maar zijn gewoon de meest gebruikte functies met databases. Het bedenken van deze methoden komt voornamelijk neer op ervaring hebben met database.
We krijgen nu de volgende klassen en interfaces:
Database
- maak_verbinding()
- query()
DatabaseResult
- fetch_assoc()
- fetch_alles()
- aantal_regels()
MySQL
- connectie
MySQLResult
- resultaat
Nu we dit allemaal weten is het tijd voor het schrijven van de klasses. Ik heb expres phpdoc eruit gelaten om het voor jouw overzichtelijk te houden.
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
<?php
interface Database
{
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam);
public function query($query);
}
interface DatabaResult
{
public function fetch_assoc();
public function fetch_alles();
public function aantal_regels();
}
class MySQL implements Database
{
private $connectie;
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam)
{
}
public function query($query)
{
}
}
class MSSQL implements Database
{
private $connectie;
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam)
{
}
public function query($query)
{
}
}
class PostgreSQL implements Database
{
private $connectie
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam)
{
}
public function query($query)
{
}
}
class MySQLResult implements DatabaseResult
{
private $resultaat;
public function fetch_assoc()
{
}
public function fetch_alles()
{
}
public function aantal_regels()
{
}
}
class MSSQLResult implements DatabaseResult
{
private $resultaat;
public function fetch_assoc()
{
}
public function fetch_alles()
{
}
public function aantal_regels()
{
}
}
class PostgreSQLResult implements DatabaseResult
{
private $resultaat;
public function fetch_assoc()
{
}
public function fetch_alles()
{
}
public function aantal_regels()
{
}
}
?>
interface Database
{
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam);
public function query($query);
}
interface DatabaResult
{
public function fetch_assoc();
public function fetch_alles();
public function aantal_regels();
}
class MySQL implements Database
{
private $connectie;
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam)
{
}
public function query($query)
{
}
}
class MSSQL implements Database
{
private $connectie;
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam)
{
}
public function query($query)
{
}
}
class PostgreSQL implements Database
{
private $connectie
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam)
{
}
public function query($query)
{
}
}
class MySQLResult implements DatabaseResult
{
private $resultaat;
public function fetch_assoc()
{
}
public function fetch_alles()
{
}
public function aantal_regels()
{
}
}
class MSSQLResult implements DatabaseResult
{
private $resultaat;
public function fetch_assoc()
{
}
public function fetch_alles()
{
}
public function aantal_regels()
{
}
}
class PostgreSQLResult implements DatabaseResult
{
private $resultaat;
public function fetch_assoc()
{
}
public function fetch_alles()
{
}
public function aantal_regels()
{
}
}
?>
En ook de MySQLResult klasse
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
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
<?php
class MySQLResult implements DatabaseResult
{
private $resultaat;
public function __construct($resultaat)
{
$this->resultaat = $resultaat;
}
public function fetch_assoc()
{
return mysql_fetch_assoc($this->resultaat);
}
public function fetch_alles()
{
$resultaat = array();
while($regel = $this->fetch_assoc())
{
$resultaat[] = $regel;
}
return $resultaat;
}
public function aantal_regels()
{
return mysql_num_rows($this->resultaat);
}
}
?>
class MySQLResult implements DatabaseResult
{
private $resultaat;
public function __construct($resultaat)
{
$this->resultaat = $resultaat;
}
public function fetch_assoc()
{
return mysql_fetch_assoc($this->resultaat);
}
public function fetch_alles()
{
$resultaat = array();
while($regel = $this->fetch_assoc())
{
$resultaat[] = $regel;
}
return $resultaat;
}
public function aantal_regels()
{
return mysql_num_rows($this->resultaat);
}
}
?>
Nu we de resultaat klasse hebben, kunnen we ook de MySQL klasse implementeren
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 MySQL implements Database
{
private $connectie;
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam)
{
if(!($this->connectie = mysql_connect($host, $gebruikersnaam, $wachtwoord)))
throw new DatabaseException('Kon geen verbinding maken');
if(!mysql_select_db($naam, $this->connectie))
throw new DatabaseException(mysql_error());
}
public function query($query)
{
$resultaat = mysql_query($query, $this->connectie);
if(!$resultaat)
throw new DatabaseException(mysql_error());
return new MySQLResult($resultaat);
}
}
?>
class MySQL implements Database
{
private $connectie;
public function maak_verbinding($host, $gebruikersnaam, $wachtwoord, $naam)
{
if(!($this->connectie = mysql_connect($host, $gebruikersnaam, $wachtwoord)))
throw new DatabaseException('Kon geen verbinding maken');
if(!mysql_select_db($naam, $this->connectie))
throw new DatabaseException(mysql_error());
}
public function query($query)
{
$resultaat = mysql_query($query, $this->connectie);
if(!$resultaat)
throw new DatabaseException(mysql_error());
return new MySQLResult($resultaat);
}
}
?>
Nu kan je dus de database gebruiken zoals ik een aantal regels hierboven verteld heb :) Snap je het nog een beetje?
Quote:
Maar als ik dan beter meteen maar de extra stap kan zetten door ZF te gebruiken/leren dan moet ik dat misschien maar doen. Kost wel wat meer tijd, maar dan hoef ik de komende tijd niet meer aan te sleutelen.
Dat raad ik je zeker aan ja.
Zoals ik vanmiddag heb verteld zal ik nog even ingaan op het 'dependency injection', maar ik denk dat het verstandiger is dat we dat in een nieuw topic doen?
Edit:
@Moe BE
Waarom? Ik vind juist dat zend framework helemaal niet uitgebreid is en makkelijk om te begrijpen. Verder vind ik codeigniter niet echt goed gecodeerd maar goed dat is mijn mening maar :) Dan zou ik je nog eerder symfony2 aanraden, dikke shizzle met hun dependency injection container :D
Oh, aan het eind van de rit nog even het volgende:
- Je hebt het in je startpost alleen maar over functies,, maar het zijn methoden.
- Je hoeft niet perse .class in elke klasse bestand te zetten, zeker als je volledig je applicatie in OO bouwt is dat vanzelf spreken, en bij het volgen van de MVC structuur ook niet. Dan noem je een bestand gewoon bv: TestController.php
Gewijzigd op 28/12/2010 19:12:45 door Niels K
Ik zal zo goed als mogelijk reageren op jouw bijzondere post.
Niels Kieviet op 28/12/2010 18:46:07:
Ok. Staat genoteerd. Was me aangeleerd bij OOP aangezien je dan gedwongen bent de waardes uit de classe zelf te gebruiken.- het script moet altijd openstaan voor uitbreiding, daarom kan je het beste al je variabelen protected maken.
Niels Kieviet op 28/12/2010 18:46:07:
Klopt. Ook een overblijfsel van mijn OOP-leergang. Daarbij heb ik mijzelf aangeleerd om een underscore te gebruiken voor private variables.- Ik zie allemaal underscores voor je variabelen staan, waarvoor is dat? Coding style? Ik vind dat altijd zo lelijk staan maar goed..
Niels Kieviet op 28/12/2010 18:46:07:
Ok, duidelijk.- over je constructor: Je kan het beste je variabelen een beteren benaming geven, $id zegt niet zoveel, kan het database id wezen, emial id, user id.
Niels Kieviet op 28/12/2010 18:46:07:
Dependency? Is dat waarom het woord ‘Database’ daar tussen de arguments staat?- Je kan ook voor de database een dependency afdwingen, dan krijg je dus dit:
Niels Kieviet op 28/12/2010 18:46:07:
Ok. Dat was inderdaad ook een van mijn vragen en iets wat veel mensen mij aanraadden maar waar ik altijd mijn twijfels over heb gehad.- Verder is het niet gebruikelijk om in de constructor bepaalde queries of actie uit te voeren, daarvoor kan je gewoon het beste een andere methode voor realiseren.
Niels Kieviet op 28/12/2010 18:46:07:
Ok. Thanks.- Je while is een beetje vaag? Waarom gebruik je $this->_db(fetchAssoc) ? Kan je het beste gewoon in dit veranderen $this->_db->fetchAssoc( $result );
Niels Kieviet op 28/12/2010 18:46:07:
Klopt. Was net begonnen aan de class. Nog geen tijd gehad voor documentatie. Doe ik normaal gesproken wel.- Ik mis PHPdoc
Niels Kieviet op 28/12/2010 18:46:07:
Ok. Zal vanavond/morgen proberen om een OOP authenticatie te maken op basis van jouw voorbeeld. Heb zojuist toevallig ook een uitgebreide tut over Zend_Authentication gekeken dus dat komt goed van pas. Goed meer heeft je klasse niet, en dat is juist het grootste probleem, de aanpak van je user klasse kan veel beter. Hier onder een voorbeeldje hoe ik een authentificatie aanpak. De klasses moet je zelf even realiseren, is gelijk een goede oefening voor je, het is overigens met het Zend_Framework gemaakt, maar dat maakt niet uit.
Niels Kieviet op 28/12/2010 18:46:07:
Yup, zeer tof van je. Duidelijke uitleg.Goed, we gaan verder met de database, zoals ik net zei kan je beter een dependency aanmaken, nogmaals zo dus:
Om dit te laten werken moet je even weten hoe je de huidige database klasse moet veranderen. Ik heb een voorbeeld voor je gemaakt in gewoon mysql zodat je het goed kunt begrijpen.
Om dit te laten werken moet je even weten hoe je de huidige database klasse moet veranderen. Ik heb een voorbeeld voor je gemaakt in gewoon mysql zodat je het goed kunt begrijpen.
Niels Kieviet op 28/12/2010 18:46:07:
Het duizelt me een beetje, maar ik geloof dat ik je redelijk kan volgen ;-)[/quote]Nu kan je dus de database gebruiken zoals ik een aantal regels hierboven verteld heb :) Snap je het nog een beetje?
Niels Kieviet op 28/12/2010 18:46:07:
Ben daar eerlijk gezegd wel benieuwd naar. Zal er eens op googelen.Zoals ik vanmiddag heb verteld zal ik nog even ingaan op het 'dependency injection', maar ik denk dat het verstandiger is dat we dat in een nieuw topic doen?
Niels Kieviet op 28/12/2010 18:46:07:
Ja, het noemen van de juiste benaming (methods,arguments,etc.) blijft een probleem.Oh, aan het eind van de rit nog even het volgende:
- Je hebt het in je startpost alleen maar over functies,, maar het zijn methoden.
- Je hebt het in je startpost alleen maar over functies,, maar het zijn methoden.
Niels Kieviet op 28/12/2010 18:46:07:
Ik zag het inderdaad al in de ZF tutorial. Ik doe dat op dit moment wel aangezien ik het netjes vind staan. In OOP zal ik het waarschijnlijk zo blijven doen. Wanneer ik gebruik ga maken van ZF gaat dit er uiteraard direct aan.- Je hoeft niet perse .class in elke klasse bestand te zetten, zeker als je volledig je applicatie in OO bouwt is dat vanzelf spreken, en bij het volgen van de MVC structuur ook niet. Dan noem je een bestand gewoon bv: TestController.php
Ok. Morgen zet ik – als het goed gaat – mijn authentication classe online op basis van het ZF voorbeeld dat jij mij gaf.
Quote:
Holy! Dat is pas een uitleg! Wow... wordt er zelfs een beetje stil van
Haha, dankjewel daar doen we het voor ;)
Quote:
Dependency? Is dat waarom het woord ‘Database’ daar tussen de arguments staat?
Ja, het houd gewoon in dat er een database klasse wordt verwacht die voldoet aan de interface.
Quote:
Ok. Dat was inderdaad ook een van mijn vragen en iets wat veel mensen mij aanraadden maar waar ik altijd mijn twijfels over heb gehad.
Dan weet je dat nu ook weer :)
Quote:
Ok. Zal vanavond/morgen proberen om een OOP authenticatie te maken op basis van jouw voorbeeld. Heb zojuist toevallig ook een uitgebreide tut over Zend_Authentication gekeken dus dat komt goed van pas.
Prima, prima we wachten rustig af :-)
Quote:
Yup, zeer tof van je. Duidelijke uitleg.
Geen probleem, het geeft ook voldoening om mensen te helpen.
Quote:
Het duizelt me een beetje, maar ik geloof dat ik je redelijk kan volgen
Dat is mooi, want dat is echt de basis van OO. en als je nog vragen hebt, stel ze gerust, dan zal ik zover mijn kennis het toelaat ze beantwoorden.
Quote:
Ben daar eerlijk gezegd wel benieuwd naar. Zal er eens op googelen.
Wil daar wel een stuk over schrijven, maar dat wordt dan denk ik een nieuw topic? Of zeg jij doe maar in deze?
Quote:
Ja, het noemen van de juiste benaming (methods,arguments,etc.) blijft een probleem.
Dat blijft een stukje ervaring, je leert het vanzelf.
Quote:
Ok. Morgen zet ik – als het goed gaat – mijn authentication classe online op basis van het ZF voorbeeld dat jij mij gaf.
Prima ;)
Wat overigens ook een mooi topic voor het ontwerpen van een applicatie in OO is het volgende: klik.
@Mike
Goede reacties van lezers stimuleren mij om lange antwoorden / uitleggingen te schrijven.
Gewijzigd op 28/12/2010 20:28:16 door Mike Smit
Pagina: « vorige 1 2 3 4 volgende »