[PHP] database verbinding in elke klasse

[Kaastosti]

Lekker aan het knutselen met klassen en nu kom ik op het punt dat ik in al die klassen een database verbinding nodig ga hebben. Het bouwen van een verbinding is het probleem niet, het gaat me meer om de manier waarop.

Ik kan natuurlijk in elke klasse een functie schrijven die een verbinding opbouwd, maar dat krijg je uiteindelijk toch weer dubbele coding, aangezien dat stukje in elke klasse voor gaat komen. Een function includen kan natuurlijk ook, maar dat vind ik niet erg netjes binnen een klasse.

Wat is een nette manier om dit te doen? Eigenlijk wil ik binnen een klasse kunnen zeggen iets als connect('blaat'), om te verbinding met de database 'blaat'. Dat lijkt me gewoon een functie, maar op welke manier is dat nou netjes?

[Sybr_E-N]

Je kunt ook overwegen om een Database klasse te gaan maken. Dan hoef je alleen maar een instantie van die klasse te maken in je andere klassen. Dus schrijf je die database connections e.d. maar 1 keer.

Op het moment dat je een database verbinding nodig hebt roep je die Database klasse aan en kun je gebruik maken van alle functionaliteit die de Database klasse je biedt.

[Kaastosti]

Owkee da's inderdaad wel een idee... dan krijg ik dus ongeveer dit:

code:

class Database
{
    function Database()
    {
        $db_servername  = 'server';
        $db_username        = 'user';
        $db_password        = 'pass';
        
        if (!$db = @mysql_connect("$db_servername","$db_username","$db_password"))
        {
            echo 'Could not connect to MySQL Server';
            die;
        }
    }
    
    function connect($database)
    {
        mysql_select_db($database);
    }
}

Waarna ik in de constructor van elke andere klasse iets kan zetten als:

code:

$db = new Database()

En in de functie waar ik een specifieke database nodig heb:

code:

$db->connect('blaat')

Tenminste... dat zou dan mijn interpretatie zijn hiervan

[Sybr_E-N]

Kaastosti schreef op donderdag 24 februari 2005 @ 11:32:
Tenminste... dat zou dan mijn interpretatie zijn hiervan

Je slaat de spijker op z'n kop!

tip: Lees je eens wat meer in OOP, object georienteerd programmeren, er is meer dan alleen losse klassen aanmaken.

[Kaastosti]

Heb je, met betrekking tot OOP en PHP nog een tip voor een goede uitleg? Ik heb verscheidene OO-handleidingen gelezen, met telkens een andere taal voor ogen. Het principe blijft gelijk, maar op de een of andere manier begrijp ik het in PHP het snelst, ook omdat het zo lekker makkelijk zelf na te bouwen en te testen is

[Sybr_E-N]

Om OOP te leren? Geen idee zo 1 2 3, heb het zelf aan de hand van Object Pascal ( Delphi ), Java en c++ geleerd. Die principes die ik op school heb geleerd pas ik zelf toe in PHP, tegenwoordig in PHP5.

Er zijn vast en zeker tutorials, boeken (e-books misschien wel), artikelen (waarin zaken worden toegelicht/beschreven/best practices e.d.) waarin OOP incombinatie met PHP wordt beschreven/uitgelegd te vinden via bijvoorbeeld Google.

[Kaastosti]

Okee, ik ga er weer eens naar kijken Eigenlijk had ik het allaaaaang moeten leren voor m'n opleiding, maar op de een of andere manier heb ik me er altijd uit weten te babbelen. Toen was 't wel makkelijk, nu mis ik kennis.. helaasch

[Michali]

Kaastosti schreef op donderdag 24 februari 2005 @ 11:32:
Owkee da's inderdaad wel een idee... dan krijg ik dus ongeveer dit:

Dan zou ik er iig dit van maken:

PHP:

<?

class Database
{
    var $connection;
    var $result;
    
    function Database($host, $username, $password)
    {
        $this->connection = mysql_connect($host, $username, $password) or die(mysql_error($this->connection));
    }
    
    function selectDatabase($name)
    {
        mysql_select_db($name, $this->connection);
    }
    
    function query($query)
    {
        $this->result = mysql_query($query, $this->connection) or die(mysql_error($this->connection));
    }
    
    function fetch()
    {
        return mysql_fetch_assoc($this->result);
    }
}

?>

Zo kun je nog connecties maken met meerdere databases en/of hosts. Overigens kun je het fetchen van een result beter verplaatsen naar een aparte RecordSet class oid. Op deze manier kun je namelijk maar 1 result te gelijk gebruiken.

[Kaastosti]

Je bedoelt dat je voor elke result een apart object aanmaakt zodat die beschikbaar blijft door je hele script heen... hmm da's inderdaad ook nog een interessante optie. Op dit moment heb ik gewoon bij elk stukje waar ik een database nodig heb iets als:

code:

$query = "SELECT blahdiblah FROM meuk WHERE iets";
$result = mysql_query($query);
$row = mysql_fetch_object($result)
$var = $row->var

Aangezien het meestal maar 1 record betreft werkt dat, anders moet ik er een while-loopje van maken. Maar jouw idee is misschien nog wel een probeerseltje waard. Alhoewel ik niet weet of ik uitkomsten van queries daadwerkelijk vaker wil gebruiken, kan het nooit kwaad ze even wat langer te bewaren

[JHS]

Persoonlijk zou ik eerder in de constructor van je database class de connectie aanmaken, en in de destructor je connectie opruimen, of iig een check inbouwen of je niet al een verbinding open hebt, om te voorkomen dat je steeds blijft verbinden.

[Michali]

Je hoeft er toch geen while loop van te maken? Je kunt toch iets als dit doen:

PHP:

$recordSet = $database->query($query);
$recordSet->fetch();
$var = $recordSet->get('var');

of

PHP:

$recordSet = $database->queryAndFetch($query);
$var = $recordSet->get('var');

maar moet je zelf maar uitmaken.

[Kaastosti]

Persoonlijk zou ik eerder in de constructor van je database class de connectie aanmaken

Maar ik maak gebruik van verschillende databases en dat kan verschillen binnen een klasse. Dan lijkt me het niet handig om elke keer opnieuw een object aan te maken per query

of iig een check inbouwen of je niet al een verbinding open hebt, om te voorkomen dat je steeds blijft verbinden.

PHP Maakt geen nieuwe connectie aan als die er al is... tenminste, dat is zo als je het zonder classes doet.

Ik doe meestal iets als:

PHP:

while($row = mysql_fetch_object($result))
{
   $results[] = $row->var      ..of Array("iets" => $row->var)
}

Werkt jouw systeem ongeveer hetzelfde?

[ Voor 34% gewijzigd door Kaastosti op 24-02-2005 14:41 ]

[SchizoDuckie]

ik heb het zo gedaan (is al een iets oudere versie, maar wel php5 )

Wil je deze aan de praat krijgen op PHP4 dan moet je ff de __construct() hernoemen naar dbConnection() uiteraard.

link: http://cv.zapguide.nl/database.class.txt

misschien heb je er wat aan

[ Voor 5% gewijzigd door SchizoDuckie op 24-02-2005 14:51 ]

[Kaastosti]

Die is wel heel erg uigebreid Maar ziet er zeker mooi uit, daar gaan we eens mee knutselen. Ik ben idd aan het werk in PHP4... hoe zit het eigenlijk in PHP5 met overloading van functies? Dat is namelijk een beperking in PHP4 die ik graag zou zien verdwijnen

[Sybr_E-N]

Kaastosti schreef op donderdag 24 februari 2005 @ 14:56:
Die is wel heel erg uigebreid Maar ziet er zeker mooi uit, daar gaan we eens mee knutselen. Ik ben idd aan het werk in PHP4... hoe zit het eigenlijk in PHP5 met overloading van functies? Dat is namelijk een beperking in PHP4 die ik graag zou zien verdwijnen

Lees deze maar eens door.