PHP-Ausnahmen | Envato Tuts+

German (Deutsch) translation by Alex Grigorovich (you can also view the original English article)

In diesem Artikel lernen wir PHP-Ausnahmen von Grund auf kennen. Diese Konzepte werden in vielen großen, skalierbaren und objektorientierten Anwendungen und Frameworks verwendet. Nutzen Sie diese Sprachfunktion, um Ihre Fähigkeiten als Webanwendungsentwickler zu verbessern.

1 Zuerst ein Beispiel

Bevor wir mit allen Erklärungen beginnen, möchte ich zunächst ein Beispiel zeigen.

Sie möchten die Fläche eines Kreises anhand des angegebenen Radius berechnen. Diese Funktion erledigt das:

 
	function circle_area($radius) { 
 
		return pi() * $radius * $radius; 
 
	}

Es ist sehr einfach, prüft jedoch nicht, ob der Radius eine gültige Zahl ist. Jetzt werden wir das tun und eine Ausnahme auslösen, wenn der Radius eine negative Zahl ist:

 
	function circle_area($radius) { 
 
		// radius can't be negative 
		if ($radius < 0) { 
			throw new Exception('Invalid Radius: ' . $radius); 
		} else { 
			return pi() * $radius * $radius; 
		} 
 
	}

Mal sehen, was passiert, wenn wir es mit einer negativen Nummer anrufen:

 
	$radius = -2; 
 
	echo "Circle Radius: $radius => Circle Area: ". 
				circle_area($radius) . "\n"; 
 
 
	echo "Another line";

Das Skript stürzt mit der folgenden Meldung ab:

 
	<br /> 
	<b>Fatal error</b>:  Uncaught exception 'Exception' with message 'Invalid Radius: -2' in C:\wamp\www\test\test.php:19 
	Stack trace: 
	#0 C:\wamp\www\test\test.php(7): circle_area(-2) 
	#1 {main} 
	  thrown in <b>C:\wamp\www\test\test.php</b> on line <b>19</b><br />

Da es sich um einen schwerwiegenden Fehler handelte, wurde danach keine Codeausführung mehr durchgeführt. Möglicherweise möchten Sie jedoch nicht immer, dass Ihre Skripte angehalten werden, wenn eine Ausnahme auftritt. Zum Glück können Sie sie "catch und damit umgehen.

Lassen Sie uns diesmal ein Array mit Radiuswerten erstellen:

 
	$radius_array = array(2,-2,5,-3); 
 
	foreach ($radius_array as $radius) { 
 
		try { 
			echo "Circle Radius: $radius => Circle Area: ". 
				circle_area($radius) . "\n"; 
		} catch (Exception $e) { 
			echo 'Caught Exception: ',  $e->getMessage(), "\n"; 
		} 
 
	}

Jetzt erhalten wir diese Ausgabe:

 
	Circle Radius: 2 => Circle Area: 12.566370614359 
	Caught Exception: Invalid Radius: -2 
	Circle Radius: 5 => Circle Area: 78.539816339745 
	Caught Exception: Invalid Radius: -3

Es gibt keine Fehler mehr und das Skript wird weiterhin ausgeführt. So fangen Sie Ausnahmen.

Vollbild

2 Was ist eine Ausnahme?

Ausnahmen gibt es schon seit geraumer Zeit in anderen objektorientierten Programmiersprachen. Es wurde erstmals in PHP mit Version 5 übernommen.

Per Definition wird eine Ausnahme "thrown", wenn ein außergewöhnliches Ereignis eintritt. Dies kann so einfach sein wie eine "division by zero" oder eine andere Art von ungültiger Situation.

1
2	throw new Exception('Some error message.');

Dies klingt möglicherweise ähnlich wie andere grundlegende Fehler, die Sie bereits oft gesehen haben. Ausnahmen haben jedoch einen anderen Mechanismus.

Ausnahmen sind tatsächlich Objekte, und Sie haben die Möglichkeit, sie zu "catch" und bestimmten Code auszuführen. Dies geschieht mithilfe von 'try-catch'-Blöcken:

 
	try { 
 
		// some code goes here 
		// which might throw an exception 
 
	} catch (Exception $e) { 
 
		// the code here only gets executed 
		// if an exception happened in the try block above 
 
	}

Wir können jeden Code in einen 'try'-Block einschließen. Der folgende 'catch'-Block wird zum Abfangen von Ausnahmen verwendet, die möglicherweise aus dem try-Block ausgelöst wurden. Der catch-Block wird niemals ausgeführt, wenn keine Ausnahmen vorhanden waren. Sobald eine Ausnahme auftritt, springt das Skript sofort zum catch-Block, ohne weiteren Code auszuführen.

Weiter unten im Artikel finden Sie weitere Beispiele, die die Leistungsfähigkeit und Flexibilität der Verwendung von Ausnahmen anstelle einfacher Fehlermeldungen demonstrieren sollen.

3 Ausnahmen sprudeln

Wenn eine Ausnahme von einer Funktion oder einer Klassenmethode ausgelöst wird, geht sie an denjenigen, der diese Funktion oder Methode aufgerufen hat. Und das so lange, bis es die Spitze des Stapels erreicht ODER gefangen wird. Wenn es die Spitze des Stapels erreicht und nie aufgerufen wird, wird ein schwerwiegender Fehler angezeigt.

Hier haben wir zum Beispiel eine Funktion, die eine Ausnahme auslöst. Wir nennen diese Funktion eine zweite Funktion. Und schließlich rufen wir die zweite Funktion aus dem Hauptcode auf, um diesen Blaseneffekt zu demonstrieren:

 
	function bar() { 
 
		throw new Exception('Message from bar().'); 
 
	} 
 
	function foo() { 
 
		bar(); 
 
	} 
 
 
	try { 
 
		foo(); 
 
	} catch (Exception $e) { 
		echo 'Caught exception: ',  $e->getMessage(), "\n"; 
	}

Wenn wir also foo() aufrufen, versuchen wir, mögliche Ausnahmen abzufangen. Obwohl foo() keinen wirft, aber bar(), sprudelt es immer noch und wird oben abgefangen, sodass wir eine Ausgabe erhalten, die besagt: "Caught exception: Message from bar()."

4 Ausnahmen verfolgen

Da Ausnahmen auftauchen, können sie von überall her kommen. Um unsere Arbeit zu vereinfachen, verfügt die Exception-Klasse über Methoden, mit denen wir die Quelle jeder Ausnahme ermitteln können.

Sehen wir uns ein Beispiel an, das mehrere Dateien und mehrere Klassen umfasst.

Erstens haben wir eine Benutzerklasse und speichern sie als user.php:

 
	class User { 
 
		public $name; 
		public $email; 
 
		public function save() { 
 
			$v = new Validator(); 
 
			$v->validate_email($this->email); 
 
			// ... save 
			echo "User saved."; 
 
			return true; 
		} 
 
	}

Es verwendet eine andere Klasse namens Validator, die wir in validator.php einfügen:

 
	class Validator { 
 
		public function validate_email($email) { 
 
			if (!filter_var($email, FILTER_VALIDATE_EMAIL)) { 
				throw new Exception('Email is invalid'); 
			} 
 
		} 
 
	}

Aus unserem Hauptcode erstellen wir ein neues Benutzerobjekt, legen den Namen und die E-Mail-Werte fest. Sobald wir die save() -Methode aufrufen, wird die Validator-Klasse zum Überprüfen des E-Mail-Formats verwendet, wodurch möglicherweise eine Ausnahme zurückgegeben wird:

 
	include('user.php'); 
	include('validator.php'); 
 
 
	$u = new User(); 
	$u->name = 'foo'; 
	$u->email = '$!%#$%#*'; 
 
	$u->save();

Wir möchten jedoch die Ausnahme abfangen, sodass keine schwerwiegende Fehlermeldung angezeigt wird. Und dieses Mal werden wir uns die detaillierten Informationen zu dieser Ausnahme ansehen:

 
	include('user.php'); 
	include('validator.php'); 
 
	try { 
 
		$u = new User(); 
		$u->name = 'foo'; 
		$u->email = '$!%#$%#*'; 
 
		$u->save(); 
 
	} catch (Exception $e) { 
 
		echo "Message: " . $e->getMessage(). "\n\n"; 
		echo "File: " . $e->getFile(). "\n\n"; 
		echo "Line: " . $e->getLine(). "\n\n"; 
		echo "Trace: \n" . $e->getTraceAsString(). "\n\n"; 
 
	}

Der obige Code erzeugt diese Ausgabe:

 
	Message: Email is invalid 
 
	File: C:\wamp\www\test\validator.php 
 
	Line: 7 
 
	Trace: 
	#0 C:\wamp\www\test\user.php(11): Validator->validate_email('$!%#$%#*') 
	#1 C:\wamp\www\test\test.php(12): User->save() 
	#2 {main}

Ohne eine einzige Codezeile zu betrachten, können wir also feststellen, woher die Ausnahme stammt. Wir können den Dateinamen, die Zeilennummer, die Ausnahmemeldung und mehr sehen. Die Trace-Daten zeigen sogar die genauen Codezeilen, die ausgeführt wurden.

Die Struktur der Standard-Ausnahmeklasse wird im PHP-Handbuch gezeigt, in dem Sie alle Methoden und Daten sehen können, mit denen sie geliefert wird:

5 Ausnahmen erweitern

Da dies ein objektorientiertes Konzept ist und Exception eine Klasse ist, können wir es tatsächlich erweitern, um unsere eigenen benutzerdefinierten Ausnahmen zu erstellen.

Beispielsweise möchten Sie dem Benutzer möglicherweise nicht alle Details einer Ausnahme anzeigen. Stattdessen können Sie eine benutzerfreundliche Nachricht anzeigen und die Fehlermeldung intern protokollieren:

 
	// to be used for database issues 
	class DatabaseException extends Exception { 
 
		// you may add any custom methods 
		public function log() { 
 
			// log this error somewhere 
			// ... 
		} 
	} 
 
	// to be used for file system issues 
	class FileException extends Exception { 
 
		// ... 
 
	}

Wir haben gerade zwei neue Arten von Ausnahmen erstellt. Und sie können benutzerdefinierte Methoden haben.

Wenn wir die Ausnahme abfangen, können wir eine feste Nachricht anzeigen und die benutzerdefinierten Methoden intern aufrufen:

 
	function foo() { 
 
		// ... 
		// something wrong happened with the database 
		throw new DatabaseException(); 
 
	} 
 
 
	try { 
 
		// put all your code here 
		// ... 
 
		foo(); 
 
	} catch (FileException $e) { 
 
		die ("We seem to be having file system issues. 
			We are sorry for the inconvenience."); 
 
	} catch (DatabaseException $e) { 
 
		// calling our new method 
		$e->log(); 
 
		// exit with a message 
		die ("We seem to be having database issues. 
			We are sorry for the inconvenience."); 
 
	} catch (Exception $e) { 
 
		echo 'Caught exception: '.  $e->getMessage(). "\n"; 
 
	}

Dies ist das erste Mal, dass wir uns ein Beispiel mit mehreren Catch-Blöcken für einen einzelnen Try-Block ansehen. Auf diese Weise können Sie verschiedene Arten von Ausnahmen abfangen, sodass Sie sie unterschiedlich behandeln können.

In diesem Fall wird eine DatabaseException abgefangen und nur dieser catch-Block wird ausgeführt. In diesem Blog können wir unsere neuen benutzerdefinierten Methoden aufrufen und dem Benutzer eine einfache Nachricht anzeigen.

Bitte beachten Sie, dass der catch-Block mit der Standard-Ausnahmeklasse der letzte sein muss, da unsere neuen untergeordneten Klassen auch weiterhin als diese Klasse betrachtet werden. Zum Beispiel wird 'DatabaseException' auch als 'Exception' betrachtet, sodass es dort abgefangen werden kann, wenn die Reihenfolge umgekehrt ist.

6 Umgang mit nicht erfassten Ausnahmen

Möglicherweise möchten Sie nicht immer in Ihrem gesamten Code nach Ausnahmen suchen, indem Sie alles in try-catch-Blöcke einschließen. Nicht erfasste Ausnahmen zeigen dem Benutzer jedoch eine detaillierte Fehlermeldung an, was auch in einer Produktionsumgebung nicht ideal ist.

Es gibt tatsächlich eine Möglichkeit, die Behandlung aller nicht erfassten Ausnahmen zu zentralisieren, sodass Sie die Ausgabe von einem einzigen Speicherort aus steuern können.

Dafür verwenden wir die Funktion set_exception_handler():

 
	set_exception_handler('exception_handler'); 
 
	function exception_handler($e) { 
 
		// public message 
		echo "Something went wrong.\n"; 
 
		// semi-hidden message 
		echo "<!-- Uncaught exception: " . $e->getMessage(). " -->\n"; 
 
	} 
 
 
	throw new Exception('Hello.'); 
	throw new Exception('World.');

Die erste Zeile weist PHP an, eine bestimmte Funktion aufzurufen, wenn eine Ausnahme auftritt und nicht abgefangen wird. Dies ist die Ausgabe:

1
2	Something went wrong.
3	<!-- Uncaught exception: Hello. -->

Wie Sie sehen, wurde das Skript nach der ersten Ausnahme abgebrochen und die zweite nicht ausgeführt. Dies ist das erwartete Verhalten von nicht erfassten Ausnahmen.

Wenn Sie möchten, dass Ihr Skript nach einer Ausnahme weiter ausgeführt wird, müssen Sie stattdessen einen try-catch-Block verwenden.

7 Erstellen einer MySQL-Ausnahmeklasse

Zum Abschluss dieses Tutorials erstellen wir eine benutzerdefinierte MySQL-Ausnahmeklasse mit einigen nützlichen Funktionen und sehen, wie wir sie verwenden können.

 
	class MysqlException extends Exception { 
 
		// path to the log file 
		private $log_file = 'mysql_errors.txt'; 
 
 
		public function __construct() { 
 
			$code = mysql_errno(); 
			$message = mysql_error(); 
 
			// open the log file for appending 
			if ($fp = fopen($this->log_file,'a')) { 
 
				// construct the log message 
				$log_msg = date("[Y-m-d H:i:s]") . 
					" Code: $code - " . 
					" Message: $message\n"; 
 
				fwrite($fp, $log_msg); 
 
				fclose($fp); 
			} 
 
			// call parent constructor 
			parent::__construct($message, $code); 
		} 
 
	}

Sie werden vielleicht bemerken, dass wir so ziemlich den gesamten Code in den Konstruktor eingefügt haben. Immer wenn eine Ausnahme ausgelöst wird, ist dies wie das Erstellen eines neuen Objekts, weshalb der Konstruktor immer zuerst aufgerufen wird. Am Ende des Konstruktors müssen wir auch den übergeordneten Konstruktor aufrufen.

Diese Ausnahme wird immer dann ausgelöst, wenn ein MySQL-Fehler auftritt. Anschließend werden die Fehlernummer und die Nachricht direkt von MySQL abgerufen und diese Informationen zusammen mit dem Zeitstempel in einer Protokolldatei gespeichert. In unserem Code können wir diese Ausnahme abfangen, dem Benutzer eine einfache Nachricht anzeigen und die Ausnahmeklasse die Protokollierung für uns übernehmen lassen.

Versuchen wir beispielsweise, eine Verbindung zu MySQL herzustellen, ohne Benutzer-/Kennwortinformationen anzugeben:

 
	try { 
 
		// attempt to connect 
		if (!@mysql_connect()) { 
			throw new MysqlException; 
		} 
 
	} catch (MysqlException $e) { 
 
		die ("We seem to be having database issues. 
			We are sorry for the inconvenience."); 
 
	}

Wir müssen den Fehlerunterdrückungsoperator (@) vor dem Aufruf von mysql_connect() voranstellen, damit der Fehler dem Benutzer nicht angezeigt wird. Wenn die Funktion fehlschlägt, lösen wir eine Ausnahme aus und fangen sie dann ab. Nur unsere benutzerfreundliche Nachricht wird dem Browser angezeigt.

Die MysqlException-Klasse kümmert sich automatisch um die Fehlerprotokollierung. Wenn Sie die Protokolldatei öffnen, finden Sie folgende Zeile:

1
2	[2010-05-05 21:41:23] Code: 1045 - Message: Access denied for user 'SYSTEM'@'localhost' (using password: NO)

Fügen wir unserem Beispiel mehr Code hinzu und geben Sie außerdem die richtigen Anmeldeinformationen an:

 
	try { 
 
		// connection should work fine 
		if (!@mysql_connect('localhost','root','')) { 
			throw new MysqlException; 
		} 
 
		// select a database (which may not exist) 
		if (!mysql_select_db('my_db')) { 
			throw new MysqlException; 
		} 
 
		// attempt a query (which may have a syntax error) 
		if (!$result = mysql_query("INSERT INTO foo SET bar = '42 ")) { 
			throw new MysqlException; 
		} 
 
 
	} catch (MysqlException $e) { 
 
		die ("We seem to be having database issues. 
			We are sorry for the inconvenience."); 
 
	}

Wenn die Datenbankverbindung erfolgreich ist, aber die Datenbank 'my_db' fehlt, finden Sie dies in den Protokollen:

1
2	[2010-05-05 21:55:44] Code: 1049 - Message: Unknown database 'my_db'

Wenn die Datenbank vorhanden ist, die Abfrage jedoch aufgrund eines Syntaxfehlers fehlschlägt, wird das im Protokoll angezeigt:

1
2	[2010-05-05 21:58:26] Code: 1064 - Message: You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near ''42' at line 1

Bonus Aufbau einer DB-Klasse mit PHP Magic

Wir können das obige Codebeispiel noch sauberer machen, indem wir unsere eigene Datenbankklasse schreiben, die das Auslösen der Ausnahmen behandelt. Dieses Mal werde ich einige 'magische' Funktionen von PHP verwenden, um diese Klasse zu erstellen.

Am Ende soll unser Hauptcode folgendermaßen aussehen:

 
	try { 
 
		Database::connect('localhost','root',''); 
 
		Database::select_db('test'); 
 
		$result = Database::query("INSERT INTO foo SET bar = '42 "); 
 
	} catch (MysqlException $e) { 
 
		die ("We seem to be having database issues. 
			We are sorry for the inconvenience."); 
 
	}

Es ist schön und clean. Wir prüfen nicht bei jedem einzelnen Datenbankaufruf, ob Fehler vorliegen. Diese neue Datenbankklasse hat die Verantwortung, Ausnahmen auszulösen, wenn Fehler auftreten. Und da diese Ausnahmen in die Luft sprudeln, werden sie am Ende von unserem Fangblock erfasst.

Und hier ist die magische Datenbankklasse:

 
	class Database { 
 
		// any static function call invokes this 
		public static function __callStatic($name, $args) { 
 
			// function to be called 
			$function = 'mysql_' . $name; 
 
			// does the function exist? 
			if (!function_exists($function)) { 
				// throw a regular exception 
				throw new Exception("Invalid mysql function: $function."); 
			} 
 
			// call the mysql function 
			$ret = @call_user_func_array($function , $args); 
 
			// they return FALSE on errors 
			if ($ret === FALSE) { 
				// throw db exception 
				throw new MysqlException; 
			} 
 
			// return the returned value 
			return $ret; 
		} 
 
	}

Es hat nur eine Methode und wird immer dann aufgerufen, wenn wir eine statische Methode für diese Klasse aufrufen. Weitere Informationen zu diesem Konzept finden Sie hier: PHP-Überladung.

Wenn wir also Database::connect() aufrufen, ruft dieser Code automatisch mysql_connect() auf, übergibt die Argumente, prüft auf Fehler, löst bei Bedarf Ausnahmen aus und gibt den vom Funktionsaufruf zurückgegebenen Wert zurück. Es verhält sich im Grunde wie ein Mittelsmann und erledigt die Drecksarbeit.

Abschluss

Ich hoffe, Ihnen hat dieses Tutorial gefallen und Sie haben daraus gelernt. Jetzt sollten Sie dieses Thema besser verstehen. Versuchen Sie herauszufinden, ob Sie PHP-Ausnahmen in Ihrem nächsten Projekt verwenden können. Bis zum nächsten Mal!