OOP Datenbankverbindung

[Masterkroko1]

Hallo Com,

als noob in der OOP hab ich mal eine Frage bezüglich dem Aufbau der Datenbankverbindung (mysqli).

Wie schon gesagt ich habe mit OOP bis jetzt kaum bis gar nicht gearbeitet. Da ich die Verwendung von OOP eig. einige Vorteile sehe möchte ich dies auch öfters verwenden.

Einer meiner Hauptprobleme ist das ich nie weiß wo ich die Datenbankverbindung aufbauen soll.
1. außerhalb der Klasse und wird dann per Klassenaufruf mitgegeben
2. immer im __construct oder eine eigene Methode in jeder Klasse?
3. eine Mainklasse für alle Klassen erstellen in der die Verbindung hergestellt wird und die Logs gesetzt werden
4. weitere Ideen?

Ich wäre froh wenn mir hier jemand ein guten Ratschlag geben könnte.

Mfg,
Kroko

[algernong]

Du brauchst eigentlich nur eine Verbindung, aber vermutlich brauchen mehrere Klassen während einem Request eine Verbindung. Also wäre es unvorteilhaft, in jeder Klasse eine neue Verbindung aufzubauen.

Ich würde die Verbindung einmal aufbauen, und dann an jede Klasse übergeben (z.B. Konstruktor), die sie benötigt. Denn dadurch hast du folgende Vorteile (die mir spontan einfallen):
*) Du hast nur eine Verbindung.
*) Das Aufbauen der Verbindung ist von der Klasse getrennt: Auch wenn du deine Datenbankverbindung irgendwann völlig anders aufbaust, kannst du deine Klassen 1:1 weiter verwenden. Andernfalls müsstest du für eine Änderung (Verbindung wird anders aufgebaut) ewig viele Codestellen (jede Klasse) bearbeiten - das ist viel anfälliger für Bugs.
*) Du hast keinen duplizierten Code (eine Verbindung wird schließlich immer gleich aufgebaut).
*) Du kannst Unit-Tests machen (andernfalls hättest du keinen Einfluss, welche Datenbank deine Klasse verwendet).

Mit 3. meinst du sowas wie ein Singleton für die Datenbankverbindung? Für sowas sehe ich folgende Nachteile:
*) Wenn jemand neues mit deiner Klasse arbeitet, weiß er nicht, ob die Klasse überhaupt eine Datenbank benötigt (=> werden Methoden dieser Klasse Auswirkungen auf meine Datenbank haben?). Mit deiner Lösung 1. wird das durch den Konstruktor klar.
*) Du hast wieder keinen Einfluss, welche Datenbankverbindung die Klasse nutzt (=> Unit-Tests).

Persönlich finde ich also deine Lösung 1. am besten.

Anstatt in einer Klasse direkt mit der Datenbank zu kommunizieren, kannst du dir auch das DAO "Pattern" anschauen: Du hast eine Klasse, die die ganzen Queries ausführt, und dann einfache POJOs (oder Arrays an POJOs) zurückgibt. Dadurch hast du zum Beispiel folgende Vorteile:
*) Alle Queries sind zentral an einer Stelle, und fliegen nicht so im Code rum.
*) Die Datenbank ist von deiner Logik abstrahiert: Mit anderen DAO Klassen könntest du eine andere Datenbank verwenden.
*) Folglich kannst du bei Unit-Tests ganz auf eine richtige Datenbank verzichten (=> DAOs, die Dummy-Daten zurückgeben und Objekte in Attributen speichern).

[Masterkroko1]

Mit Punkt 3 sowas gemeint: (habt erbarmen hab es schnell niedergeschrieben)

 Spoiler

PHP Code:

class Main {
    public $oConnection = false;

    public function connectDb() {
        $oMysqli = new mysqli("test_db", "test_pw", "", "test");

        if ( !$oMysqli->connect_error ) {
            $this->oConnection = $oMysqli;
            return true;
        }
    }
}

class test extends Main {
    public function bla() {
        return "<pre>" . print_r($this->oConnection, true) . "</pre>";
    }
}

class User extends Main {
    public function setLogin() {
        return "<pre>" . print_r($this->oConnection, true) . "</pre>";
    }
}


$oTest = new test();
$oTest->connectDb();
echo $oTest->bla();

$oUser = new User();
$oUser->connectDb();
echo $oUser->setLogin();


$oMain = new Main();
$oMain->connectDb();
echo "<pre>" . print_r($oMain->oConnection, true) . "</pre>"; 


Das "DAO Pattern" kenn ich derzeit noch nicht werde es mir heut Abend mal angucken.

Punkt 2 streich ich dann schonmal generell aus meinem Kopf

[Wieland11]

1. außerhalb der Klasse und wird dann per Klassenaufruf mitgegeben
2. immer im __construct oder eine eigene Methode in jeder Klasse?

Das sind ebenfalls zwei Sachen die ich seit einigen Wochen immer noch nicht richtig kann. Kann mir da jemand eine erklärung für doofe geben?

[callinq]

Originally Posted by Wieland11

Das sind ebenfalls zwei Sachen die ich seit einigen Wochen immer noch nicht richtig kann. Kann mir da jemand eine erklärung für doofe geben?

Geht es allgemein ums OOP oder um diesen Fall einer eigenen mysqli Klasse?

Hier dazu noch ein mögliches Beispiel:
Info: Habe hier mit einer extra Methode gearbeitet, d.h. die Verbindung wird nicht im Konstruktor erstellt. Somit kann ich überprüfen ob die Verbindung steht und darüberhinaus auch ob die Verwendung mit dem utf8-Charset funktioniert.

 Spoiler

PHP Code:

class Connection{
    private $conn;

    function __contruct(){}

    public function initializeConnection(){
        $this->conn = new mysqli(SERVERNAME, USERNAME, PASSWORD, DBNAME);
        if ($this->conn->connect_error) {
            echo 'Connection failed: ' . $conn->connect_error;
            return false;
        }else if (!$this->conn->set_charset('utf8')){
            echo('Charset failed to set'. $conn->error);
            return false;
        }else{
            return true;
        }
    }

    public function getConn(){
        return $this->conn;
    }
} 


Diese Klasse kannst du dann so z.B. verwenden:

 Spoiler

PHP Code:

class User{
    private $Username;
    private $Password;

    function __construct(){
        $this->Username = 'unknown';
    }

    public function initializeUser($Username, $Password){
        $conn = new Connection();
        if($conn->initializeConnection()){
            $conn = $conn->getConn();
            $statement = $conn->prepare('SELECT * FROM `account` WHERE username=? and password=?');
            $statement->bind_param('ss', $Username, $Password);
            $statement->execute();
            $result = $statement->get_result();

            if(mysqli_num_rows($result) == 1){
                $row = $result->fetch_assoc();
                $this->Username = $row['username'];
                $this->Password = $row['password'];
            }
            $conn->close();
        }else{
            $conn->close();
        }
    } 


Wenn jemand noch Verbesserungen an diesem Code hat bitte sagen, bin immernoch am lernen!!! Wäre wirklich dankbar!!

[Masterkroko1]

Bei mir ist das Problem ich wurde noch nie wirklich mit OOP konfrontiert deshalb weiß ich nicht genau wie die Klassen aufgebaut werden.

Hier ging es jetzt konkret über den Zusammenspiel mit der Datenbankverbindung & den einzelnen Klassen.

@callinq Ich selbst finde deine User-Klasse nicht optimal.
Du willst doch nicht in jeder Methode eine Datenbankverbindung aufbauen. Das sind dann doch wenn man pech hat pro Seite 5- x Verbindungen die aufgebaut werden. (Ergo das Script wird langsamer / Fehlerwahrscheinlichkeit erhöt sich / Code wird gedoppelt).

Da würde ich lieber die Verbindung außerhalb aufbauen und dann beim erstellen der Klasse die Verbindung mit geben und diese im __construct zuweisen.
^-- Das wäre dann Punkt 1



Ich denke ich habe nun dank algernong eine interessante Möglichkeit gefunden um dies Abzubilden. Ich werde es mal weiterhin Testen. Danke das du meine PNs solange beantwortet hast

[callinq]

Originally Posted by Masterkroko1

Bei mir ist das Problem ich wurde noch nie wirklich mit OOP konfrontiert deshalb weiß ich nicht genau wie die Klassen aufgebaut werden.

Vielleicht hilft dir diese Seite. Dort wird zwar JavaScript erklärt, aber u.a. auch den Umgang mit Objekten.

Originally Posted by Masterkroko1

@callinq Ich selbst finde deine User-Klasse nicht optimal.
Du willst doch nicht in jeder Methode eine Datenbankverbindung aufbauen. Das sind dann doch wenn man pech hat pro Seite 5- x Verbindungen die aufgebaut werden. (Ergo das Script wird langsamer / Fehlerwahrscheinlichkeit erhöt sich / Code wird gedoppelt).

Da würde ich lieber die Verbindung außerhalb aufbauen und dann beim erstellen der Klasse die Verbindung mit geben und diese im __construct zuweisen.
^-- Das wäre dann Punkt 1

Die Idee ist super, Danke! Hatte daran noch nicht gedacht.
Ich werde es direkt umsetzen.

[Masterkroko1]

@callinq
Wenn du eine Datenbankverbindung brauchst diese aber nicht aufbauen kannst dann kannst du eig das Script sofort beenden (natürlich mit einer Fehlermeldung)

Dann brauchst du nicht später im Script immer zu prüfen "ist die Verbindung gesetzt?"


Wieso benutzt du in deiner User-Klasse bei der Datenbankabfrage erst OOP ( $result = $statement->get_result() und 2 Zeilen später Prozedural (mysqli_num_rows($result)) & eine Zeile später wieder oop?
Hier solltest du dann eig. $result->num_rows verwenden.

Deine Klammerung trifft nicht mein Geschmacksstil. Da fehlen in meinen Augen ein paar Leerzeichen. In der Connection-Klasse schreibst du dein if einmal so " if () {" (meine bevorzugte schreibweise)
In der User-Klasse schreibst du es dann wieder so "if(){"
Beim "}else{" fehlen mir auch 2 Leerzeichen (naja ich mach eig. Umbrüche aber das ist wirklich Geschmacks / Vorschriftsache)

Nun zu dein Statement:
Wenn du schon deine Tabelle mit `` einschließt dann kannst du es auch bei den Spalten machen.
Die * suche sollte man eig. vermeiden damit selektierst du eig. immer mehr als du wirklich brauchst. Immer die gebrauchten Spalten einzeln auflisten.

Hm das wars erstmal von meiner Seite

[callinq]

Originally Posted by Masterkroko1

@callinq
Wenn du eine Datenbankverbindung brauchst diese aber nicht aufbauen kannst dann kannst du eig das Script sofort beenden (natürlich mit einer Fehlermeldung)

Dann brauchst du nicht später im Script immer zu prüfen "ist die Verbindung gesetzt?"

Habe ich genauso schon umgesetzt. :-)

Originally Posted by Masterkroko1

Wieso benutzt du in deiner User-Klasse bei der Datenbankabfrage erst OOP ( $result = $statement->get_result() und 2 Zeilen später Prozedural (mysqli_num_rows($result)) & eine Zeile später wieder oop?
Hier solltest du dann eig. $result->num_rows verwenden.

Das war noch eines meiner ersten Programmfragmente einer Datenbankverbindung, deshalb noch Prozedual bzw. habe ich mir zu dem Zeitpunkt darüber keine Gedanken gemacht. Habe zudem inzwischen meine User-Class umgeschrieben, sodass ich dort keine Datenbankverbindung aufbau.

Originally Posted by Masterkroko1

Deine Klammerung trifft nicht mein Geschmacksstil. Da fehlen in meinen Augen ein paar Leerzeichen. In der Connection-Klasse schreibst du dein if einmal so " if () {" (meine bevorzugte schreibweise)
In der User-Klasse schreibst du es dann wieder so "if(){"
Beim "}else{" fehlen mir auch 2 Leerzeichen (naja ich mach eig. Umbrüche aber das ist wirklich Geschmacks / Vorschriftsache)

Wie du sagst Geschmackssache, ich achte auf sowas nicht.

Originally Posted by Masterkroko1

Nun zu dein Statement:
Wenn du schon deine Tabelle mit `` einschließt dann kannst du es auch bei den Spalten machen.

Verstehe nicht was du damit meinst. Weißt du denn wozu bind_param() da ist?

Originally Posted by Masterkroko1

Die * suche sollte man eig. vermeiden damit selektierst du eig. immer mehr als du wirklich brauchst. Immer die gebrauchten Spalten einzeln auflisten.

Hm das wars erstmal von meiner Seite

In meiner eigenen User-Klasse selektiere ich nicht, brauche alle Daten, da ich alles in meine User-Klasse lade. War ja nur ein kurzes Beispiel, habe es aus meinem 'alten' Code abgeleitet.

Danke aber erstmal für dein Feedback.

[Masterkroko1]

Originally Posted by callinq

Wie du sagst Geschmackssache, ich achte auf sowas nicht.

Du solltest dich wenigstens für 1 "Schreibweise" entscheiden

Originally Posted by callinq

Verstehe nicht was du damit meinst. Weißt du denn wozu bind_param() da ist?

bind_param maskiert doch nur die Übergebene werten oder liege ich da falsch?
Ich meinte das mandie Spalten mit öhm backticks einschließt `` nicht '' erkennt man vll. nicht so schnell

[callinq]

Originally Posted by Masterkroko1

Ich meinte das mandie Spalten mit öhm backticks einschließt `` nicht '' erkennt man vll. nicht so schnell

Hab ich doch auch, passt doch inzwischen alles.. Danke dafür :-)

[.Weekend.]

wie wärs mit ner singleton klasse und ner persistenten verbindung?
singleton wird üblicherweise nicht verwendet aber für sowas eignet es sich schon
wenn du ne persistente verbindung zur datenbank halten willst solltest du aber immer abfragen ob das connection attribut noch ne instanz von mysqli/PDO ist da mysql gerne die verbindung nach ner gewissen zeit abbricht