Echte Welt OOP mit PHP und MySQL

() translation by (you can also view the original English article)

Zahlreiche Beispiele von Robotern bis zu Fahrrädern wurden als „einfache“ Erklärung für OOP angeboten. Ich habe mich entschieden, Ihnen zu zeigen, wie OOP mit einem realen Beispiel für einen Programmierer funktioniert. Durch das Erstellen einer MySQL-CRUD-Klasse können Sie problemlos Einträge in einem Ihrer Projekte erstellen, lesen, aktualisieren und löschen, unabhängig davon, wie die Datenbank entworfen ist.

Das Skelett unserer Klasse einzurichten ist ziemlich einfach, wenn wir genau herausfinden, was wir brauchen. Zuerst müssen wir sicherstellen, dass wir unsere grundlegenden MySQL-Funktionen ausführen können. Dazu benötigen wir folgende Funktionen:

Wählen (Select)
Einfügen (Insert)
Löschen (Delete)
Aktualisieren (Update)
Verbinden (Connect)
Trennen (Disconnect)

Das scheint ziemlich einfach zu sein, aber ich bin mir sicher, dass wir beim Durchlaufen feststellen werden, dass viele von ihnen einige ähnliche Aspekte nutzen, sodass wir möglicherweise mehr Klassen erstellen müssen. So sollte Ihre Klassendefinition aussehen. Beachten Sie, dass ich sichergestellt habe, dass die Methoden mit dem öffentlichen Schlüsselwort erstellt wurden.

class Database
{
  public function connect()	{	}
	public function disconnect()	{	}
	public function select()		{	}
	public function insert()		{	}
	public function delete()		{	}
	public function update()	{	}
}

function connect()

Diese Funktion wird ziemlich einfach sein, aber um sie zu erstellen, müssen wir zuerst einige Variablen erstellen. Da wir sicherstellen möchten, dass sie nicht von außerhalb unserer Klasse abgerufen werden können, werden wir sie als privat definieren. Diese Variablen werden verwendet, um den Host, den Benutzernamen, das Kennwort und die Datenbank für die Verbindung zu speichern. Da sie nahezu konstant bleiben, müssen wir nicht einmal Modifikator- oder Accessor-Methoden dafür erstellen. Danach müssen wir nur eine einfache mysql-Anweisung erstellen, um eine Verbindung zur Datenbank herzustellen. Da wir als Programmierer natürlich immer davon ausgehen müssen, dass der Benutzer (selbst wenn es uns ist) etwas Dummes tut, können wir eine zusätzliche Ebene der Vorsorge hinzufügen. Wir können prüfen, ob der Benutzer tatsächlich eine Verbindung zur Datenbank hergestellt hat. Wenn dies der Fall ist, besteht keine Notwendigkeit, die Verbindung erneut herzustellen. Wenn das nicht der Fall ist, können wir ihre Anmeldeinformationen verwenden, um eine Verbindung herzustellen.

private db_host = ‘’; 
private db_user = ‘’; 
private db_pass = ‘’; 
private db_name = ‘’; 

public function connect()
    {
        if(!$this->con)
        {
            $myconn = @mysql_connect($this->db_host,$this->db_user,$this->db_pass);
            if($myconn)
            {
                $seldb = @mysql_select_db($this->db_name,$myconn);
                if($seldb)
                {
                    $this->con = true; 
                    return true; 
                } else
                {
                    return false; 
                }
            } else
            {
                return false; 
            }
        } else
        {
            return true; 
        }
    }

Wie Sie sehen, werden einige grundlegende MySQL-Funktionen und einige Fehlerüberprüfungen verwendet, um sicherzustellen, dass alles nach Plan läuft. Wenn die Verbindung zur Datenbank erfolgreich hergestellt wird, wird true zurückgegeben. Andernfalls wird false zurückgegeben. Als zusätzlichen Bonus wird auch die Verbindungsvariable auf true gesetzt, wenn die Verbindung erfolgreich hergestellt wurde.

public function disconnect()

Diese Funktion überprüft einfach unsere Verbindungsvariable, um zu sehen, ob sie auf true gesetzt ist. Wenn das der Fall ist, bedeutet das, dass es mit der Datenbank verbunden ist, und unser Skript wird die Verbindung trennen und true zurückgeben. Wenn nicht, dann besteht wirklich keine Notwendigkeit, überhaupt etwas zu tun.

public function disconnect()
{
	if($this->con)
	{
		if(@mysql_close())
		{
                       $this->con = false; 
			return true; 
		}
		else
		{
			return false; 
		}
	}
}

public function select()

Das ist die erste Funktion, bei der die Dinge etwas komplizierter werden. Jetzt werden wir uns mit Benutzerargumenten befassen und die Ergebnisse korrekt zurückgeben. Da wir die Ergebnisse nicht unbedingt sofort verwenden möchten, werden wir auch eine neue Variable namens result einführen, die die Ergebnisse ordnungsgemäß speichert. Außerdem erstellen wir eine neue Funktion, die prüft, ob eine bestimmte Tabelle in der Datenbank vorhanden ist. Da alle unsere CRUD-Operationen dies erfordern, ist es sinnvoller, sie separat zu erstellen, anstatt sie in die Funktion zu integrieren. Auf diese Weise sparen wir Platz in unserem Code und können später die Dinge besser optimieren. Bevor wir in die eigentliche select-Anweisung einsteigen, sind hier die tableExists-Funktion und die private Ergebnisvariable.

private $result = array(); 

private function tableExists($table)
    {
        $tablesInDb = @mysql_query('SHOW TABLES FROM '.$this->db_name.' LIKE "'.$table.'"');
        if($tablesInDb)
        {
            if(mysql_num_rows($tablesInDb)==1)
            {
                return true; 
            }
            else
            { 
                return false; 
            }
        }
    }

Diese Funktion prüft einfach die Datenbank, um festzustellen, ob die erforderliche Tabelle bereits vorhanden ist. Wenn das der Fall ist, wird es wahr zurückgegeben, und wenn nicht, wird es falsch zurückgegeben.

public function select($table, $rows = '*', $where = null, $order = null)
    {
        $q = 'SELECT '.$rows.' FROM '.$table;
        if($where != null)
            $q .= ' WHERE '.$where;
        if($order != null)
            $q .= ' ORDER BY '.$order;
        if($this->tableExists($table))
       {
        $query = @mysql_query($q);
        if($query)
        {
            $this->numResults = mysql_num_rows($query);
            for($i = 0; $i < $this->numResults; $i++)
            {
                $r = mysql_fetch_array($query);
                $key = array_keys($r); 
                for($x = 0; $x < count($key); $x++)
                {
                    // Sanitizes keys so only alphavalues are allowed
                    if(!is_int($key[$x]))
                    {
                        if(mysql_num_rows($query) > 1)
                            $this->result[$i][$key[$x]] = $r[$key[$x]];
                        else if(mysql_num_rows($query) < 1)
                            $this->result = null; 
                        else
                            $this->result[$key[$x]] = $r[$key[$x]]; 
                    }
                }
            }            
            return true; 
        }
        else
        {
            return false; 
        }
        }
else
      return false; 
    }

Auf den ersten Blick wirkt es etwas unheimlich, aber diese Funktion macht wirklich eine ganze Reihe von Dingen aus. Zunächst akzeptiert es 4 Argumente, von denen 1 erforderlich ist. Der Tabellenname ist die einzige Sache, die Sie an die Funktion übergeben müssen, um Ergebnisse zu erhalten. Wenn Sie jedoch etwas mehr anpassen möchten, können Sie dies tun, indem Sie hinzufügen, welche Zeilen aus der Datenbank abgerufen werden, und Sie können sogar eine where- und order-Klausel hinzufügen. Solange Sie den ersten Wert übergeben, werden die voreingestellten Werte standardmäßig übernommen, sodass Sie sich keine Gedanken darüber machen müssen, alle Werte einzustellen. Der Code hinter den Argumenten dient nur dazu, alle unsere Argumente in eine select-Anweisung zu übersetzen. Anschließend wird mit unserer früheren tableExists-Funktion geprüft, ob die Tabelle vorhanden ist. Wenn es existiert, wird die Funktion fortgesetzt und die Abfrage ausgeführt. Wenn nicht, wird es fehlschlagen.

Der nächste Abschnitt ist die wahre Magie des Codes. Dabei werden die Spalten und Daten erfasst, die von der Datenbank angefordert wurden. Es weist es dann unserer Ergebnisvariablen zu. Um dem Endbenutzer die Arbeit zu erleichtern, werden jedoch anstelle der automatischen Erhöhung der numerischen Tasten die Namen der Spalten verwendet. Wenn Sie mehr als ein Ergebnis erhalten, wird jede zurückgegebene Zeile mit einem zweidimensionalen Array gespeichert, wobei der erste Schlüssel numerisch und automatisch inkrementiert wird und der zweite Schlüssel der Name der Spalte ist. Wenn nur ein Ergebnis zurückgegeben wird, wird ein eindimensionales Array mit den Schlüsseln als Spalten erstellt. Wenn keine Ergebnisse angezeigt werden, wird die Ergebnisvariable auf null gesetzt. Wie ich bereits gesagt habe, scheint es etwas verwirrend zu sein, aber wenn Sie die Dinge in ihre einzelnen Abschnitte unterteilt haben, können Sie sehen, dass sie recht einfach und unkompliziert sind.

public function insert()

Diese Funktion ist viel einfacher als die vorherige. Es erlaubt uns einfach, Informationen in die Datenbank einzufügen. Daher benötigen wir ein zusätzliches Argument für den Namen der Tabelle. Wir benötigen eine Variable, die den Werten entspricht, die wir eingeben möchten. Wir benötigen eine Variable, die den Werten entspricht, die wir eingeben möchten. Wir können jeden Wert einfach mit einem Komma trennen. Dann müssen wir nur noch schnell überprüfen, ob unsere tableExists vorhanden ist, und dann die Einfügeanweisung erstellen, indem wir unsere Argumente bearbeiten, um eine Einfügeanweisung zu bilden. Dann führen wir einfach unsere Abfrage aus.

public function insert($table,$values,$rows = null)
    {
        if($this->tableExists($table))
        {
            $insert = 'INSERT INTO '.$table;
            if($rows != null)
            {
                $insert .= ' ('.$rows.')'; 
            }

            for($i = 0; $i < count($values); $i++)
            {
                if(is_string($values[$i]))
                    $values[$i] = '"'.$values[$i].'"';
            }
            $values = implode(',',$values);
            $insert .= ' VALUES ('.$values.')';
            $ins = @mysql_query($insert);            
            if($ins)
            {
                return true; 
            }
            else
            {
                return false; 
            }
        }
    }

Wie Sie sehen, ist diese Funktion viel einfacher als unsere ziemlich komplexe select-Anweisung. Unsere Löschfunktion wird sogar noch einfacher sein.

public function delete()

Diese Funktion löscht einfach eine Tabelle oder eine Zeile aus unserer Datenbank. Als solche müssen wir den Tabellennamen und eine optionale where-Klausel übergeben. Die where-Klausel lässt uns wissen, ob wir eine Zeile oder die gesamte Tabelle löschen müssen. Wenn die where-Klausel übergeben wird, müssen die entsprechenden Einträge gelöscht werden. Nachdem wir all das herausgefunden haben, müssen Sie lediglich unsere delete-Anweisung kompilieren und die Abfrage ausführen.

public function delete($table,$where = null)
    {
        if($this->tableExists($table))
        {
            if($where == null)
            {
                $delete = 'DELETE '.$table; 
            }
            else
            {
                $delete = 'DELETE FROM '.$table.' WHERE '.$where; 
            }
            $del = @mysql_query($delete);

            if($del)
            {
                return true; 
            }
            else
            {
               return false; 
            }
        }
        else
        {
            return false; 
        }
    }

Und endlich kommen wir zu unserer letzten Hauptfunktion. Diese Funktion dient lediglich dazu, eine Zeile in der Datenbank mit neuen Informationen zu aktualisieren. Aufgrund der etwas komplexeren Natur wird es etwas größer und unendlich viel verwirrender. Keine Angst, es folgt weitgehend dem gleichen Muster unserer vorherigen Funktion. Zuerst werden unsere Argumente verwendet, um eine Aktualisierungsanweisung zu erstellen. Anschließend wird die Datenbank überprüft, um sicherzustellen, dass die tableExists angezeigt wird. Wenn es existiert, wird einfach die entsprechende Zeile aktualisiert. Der schwierige Teil kommt natürlich, wenn wir versuchen, die Aktualisierungsanweisung zu erstellen. Da die Aktualisierungsanweisung Regeln für die Aktualisierung mehrerer Einträge enthält (IE - unterschiedliche Spalten in derselben Zeile durch die listige Verwendung von Kommas), müssen wir dies berücksichtigen und einen Weg finden, um damit umzugehen. Ich habe mich entschieden, die where-Klausel als einzelnes Array zu übergeben. Das erste Element im Array ist der Name der Spalte, die aktualisiert wird, und das nächste Element ist der Wert der Spalte. Auf diese Weise wird jede gerade Zahl (einschließlich 0) der Spaltenname und jede ungerade Zahl der neue Wert. Der Code zum Ausführen ist sehr einfach und wird außerhalb der Funktion dargestellt:

1	for($i = 0; $i < count($where); $i++)
2	{
3	if($i%2 != 0)
4	{
5	if(is_string($where[$i]))
6	{
7	if(($i+1) != null)
8	$where[$i] = '"'.$where[$i].'" AND ';
9	else
10	$where[$i] = '"'.$where[$i].'"';
11	}
12	else
13	{
14	if(($i+1) != null)
15	$where[$i] = $where[$i]. ' AND ';
16	else
17	$where[$i] = $where[$i];
18	}
19	}
20	}

Im nächsten Abschnitt wird der Teil der Aktualisierungsanweisung erstellt, der sich mit dem tatsächlichen Setzen der Variablen befasst. Da Sie eine beliebige Anzahl von Werten ändern können, habe ich mich für ein Array entschieden, in dem der Schlüssel die Spalte und der Wert der neue Wert der Spalte ist. Auf diese Weise können wir sogar überprüfen, wie viele verschiedene Werte zur Aktualisierung übergeben wurden, und können entsprechend Kommas hinzufügen.

1	$keys = array_keys($rows);
2	for($i = 0; $i < count($rows); $i++)
3	{
4	if(is_string($rows[$keys[$i]]))
5	{
6	$update .= $keys[$i].'="'.$rows[$keys[$i]].'"';
7	}
8	else
9	{
10	$update .= $keys[$i].'='.$rows[$keys[$i]];
11	}
12	// Parse to add commas
13	if($i != count($rows)-1)
14	{
15	$update .= ',';
16	}
17	}

Nun, da wir diese beiden Bits der Logik aus dem Weg geräumt haben, ist der Rest der Aktualisierungsanweisung einfach. Hier ist es unten dargestellt:

public function update($table,$rows,$where)
    {
        if($this->tableExists($table))
        {
            // Parse the where values
            // even values (including 0) contain the where rows
            // odd values contain the clauses for the row
            for($i = 0; $i < count($where); $i++)
            {
                if($i%2 != 0)
                {
                    if(is_string($where[$i]))
                    {
                        if(($i+1) != null)
                            $where[$i] = '"'.$where[$i].'" AND ';
                        else
                            $where[$i] = '"'.$where[$i].'"';
                    }
                }
            }
            $where = implode('=',$where);
            
            
            $update = 'UPDATE '.$table.' SET ';
            $keys = array_keys($rows); 
            for($i = 0; $i < count($rows); $i++)
           {
                if(is_string($rows[$keys[$i]]))
                {
                    $update .= $keys[$i].'="'.$rows[$keys[$i]].'"';
                }
                else
                {
                    $update .= $keys[$i].'='.$rows[$keys[$i]];
                }
                
                // Parse to add commas
                if($i != count($rows)-1)
                {
                    $update .= ','; 
                }
            }
            $update .= ' WHERE '.$where;
            $query = @mysql_query($update);
            if($query)
            {
                return true; 
            }
            else
            {
                return false; 
            }
        }
        else
        {
            return false; 
        }
    }

Jetzt, da wir die letzte Funktion abgeschlossen haben, ist unsere einfache CRUD-Schnittstelle für MySQL vollständig. Sie können jetzt neue Einträge erstellen, bestimmte Einträge aus der Datenbank lesen, Einträge aktualisieren und Elemente löschen. Wenn Sie diese Klasse erstellen und wiederverwenden, werden Sie feststellen, dass Sie sich viel Zeit und Codierung sparen. Ah, die Schönheit der objektorientierten Programmierung.

Die Verwendung

Also haben wir unsere Klasse gemacht, aber wie verwenden wir sie? Dieser Teil ist einfach. Beginnen wir mit dem Erstellen einer sehr einfachen Systemdatenbank, die in unseren Tests verwendet werden soll. Ich habe eine Datenbank namens test erstellt und dann die MySQL-Anweisung ausgeführt. Sie können es in einer beliebigen Datenbank platzieren. Stellen Sie einfach sicher, dass Sie die Verbindungsvariablen oben im Skript ändern, damit sie übereinstimmen:

Die erste Zeile wird einfach auskommentiert, weil nicht jeder es brauchen wird. Wenn Sie das mehr als einmal ausführen müssen, müssen Sie es ein zweites Mal auskommentieren, um sicherzustellen, dass die Tabelle erstellt wird.

Jetzt, da unsere Tabelle erstellt und gefüllt ist, müssen einige einfache Abfragen ausgeführt werden.

<?php;
include('crud.php');
$db = new Database();
$db->connect();
$db->select('mysqlcrud');
$res = $db->getResult();
print_r($res);
?>

Bei korrekter Ausführung sollten Sie Folgendes sehen:

Ebenso können wir einen Schritt weiter gehen, eine Aktualisierungsabfrage ausführen und dann die Ergebnisse ausgeben:

<?php;
$db->update('mysqlcrud',array('name'=>'Changed!'),array('id',1));
$db->update('mysqlcrud',array('name'=>'Changed2!'),array('id',2));
$res = $db->getResult();
print_r($res);
?>

Wir sollten das sehen

Nun zu einer einfachen Einfügeanweisung:

;<?php;
$db->insert('mysqlcrud',array(3,"Name 4","this@wasinsert.ed"));
$res = $db->getResult();
print_r($res);
?>