service container truc?
Wie durft even mee te denken?
Een tijdje terug heb ik een vraag gesteld over het nut van exceptions. Oké, goed. Het lijkt me nu wel wat om exceptions te gaan gebruiken, maaar...
Ik werk dus met een service container waarin ik ook wat gegevens van een website opsla, bijv. de naam en de url. Stel nu dat ik ga werken met exceptions, dan zou ik die gegevens (naam van de website en de url) willen loggen. Op die manier kan ik dus zien op welke url er een exception wordt getriggerd. Waar het nu om gaat, hoe krijg ik die gegevens vanuit de service container in de exception class??? Klein voorbeeldje (totaal niet kloppend, maar het gaat enkel even om het idee!):
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<?php
class Core {
private $container;
public function __construct() {
$this->container->getWebsiteData()->setName(); // stop de naam van de website in de container
$this->container->getWebsiteData()->setUrl(); // stop de URL van de website in de container
}
public function foo() {
if ($er_gaat_iets_fout) {
throw new Exception('Je doet iets verkeerd!');
}
}
}
?>
class Core {
private $container;
public function __construct() {
$this->container->getWebsiteData()->setName(); // stop de naam van de website in de container
$this->container->getWebsiteData()->setUrl(); // stop de URL van de website in de container
}
public function foo() {
if ($er_gaat_iets_fout) {
throw new Exception('Je doet iets verkeerd!');
}
}
}
?>
Oké, even een stom voorbeeldje dus... maar waar het om gaat is dat in de function foo een exception wordt gegooid. Hoe kan die exception nu de informatie verkrijgen die in de container zit? Ja... zullen jullie zeggen... doe dan zoiets:
Code (php)
1
throw new Exception('Je doet iets verkeerd!', $this->container);
Maar dat wil ik niet, want dan moet ik overal waar ik een exception wil gooien die container gaan meegeven. Dan sla ik volgens mij de plank mis. Ik vraag me dus af of er een andere handige manier is, waardoor die exception toch aan het container object kan komen. Het enige wat ik me zou kunnen bedenken is een singleton gebruiken voor de container, maar het gebruik van singletons wordt afgeraden. Wie heeft een ideetje?
Ik gooi een Exception... vanuit die exception wordt een loggen aangeroepen denk ik dan? Maar hoe weet die logger dan van de container variabelen? Dan heb je toch weer hetzelfde probleem?
Zoals jij het zegt, zou ik zoiets denken...
Code (php)
Waar ga ik de fout in?
Toevoeging op 01/10/2013 23:59:40:
Dat een exception alleen data vast houdt en je pas in de catch bepaalt wat je met die data doet, bijv. het loggen
Kan dit trouwens:
Of moet je een exception altijd in een try-catch blok zetten?
Voorbeeldje:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
<?php
// bootstrap file of service config
$excephandler = new ExceptionHandler($container->get('logger'));
$excephandler->setUrl($container->get('site.url'));
try {
throw new \Exception('fool! Do it correct');
} catch (\Exception $e) {
$excephandler->handle($e);
}
?>
// bootstrap file of service config
$excephandler = new ExceptionHandler($container->get('logger'));
$excephandler->setUrl($container->get('site.url'));
try {
throw new \Exception('fool! Do it correct');
} catch (\Exception $e) {
$excephandler->handle($e);
}
?>
Of gebruik set_exception_handler
Tot zover is het dan duidelijk!
Misschien kun je me dan ook nog iets anders uitleggen... (maar dat mag ook morgen!)
1) Wanneer moet ik een try/catch blok ergens omheen zetten, en wanneer een if statement?
2) Hoe zorg ik dat bij een ernstige fout de applicatie compleet stopt (bijvoorbeeld indien er geen database connectie tot stand kan komen), maar dat ie bij een minder ernstige fout (bijv. een user die een getal invoert ipv een string) de applicatie gewoon doorgaat, maar er uitsluitend een error wordt gelogd?
Hmmm, nog eentje dan... de laatste...
3) Stel dat ik ergens bestanden moet inladen (dit zijn gewoon "vaste" bestanden) via require, moet ik daar dan ook een try/catch blok (of if-statement) omheen zetten, of gaat dat te ver?
Alvast bedankt!
2) ernstige fout: exception nergens opvangen en laten afhandelen door de set_exception_handler (die pas wordt aangeroepen als de exception nergens wordt gevangen)
minder ernstige fout: exception wel opvangen en er iets leuks mee doen
3) doe wat je wilt, zelf gebruik ik bijna nergens try..catch blocken
Ik kan me herinneren dat jij allerlei verschillende exceptions kan gooien in je code, maar hoe doe je dat dan? Stel ik wil input valideren (of iets een int is). Gebruik je dan telkens een try/catch blok?
Kun je dan niet een exception in een if-statement gooien, en dat die exception ergens anders in een try/catch blok wordt opgevangen?
(ik ben ff de weg nu kwijt... )
Ozzie PHP op 02/10/2013 00:19:59:
1) Wanneer moet ik een try/catch blok ergens omheen zetten, en wanneer een if statement?
Wouter J op 02/10/2013 01:05:22:
1) hoe wil je exceptions catchen met een if statement?
Ik snap'm even niet. Jij zegt dat je ze niet kunt vangen in een if-statement, maar je gebruikt in jouw voorbeeld zelf ook een if-statement? What am I missing?
Catch = vangen
Ik gebruik een if en daarna gooi ik een exception. Vervolgens wordt deze ergens anders in een try..catch block gevangen
Heb jij dan (ergens in je core) een heel groot try/catch blok om je code heen staan die alle exceptions afvangt?
Bij een try/catch wordt daadwerkelijk andere PHP-code uitgevoerd. Het lijkt op een if/else met een exception als de trigger voor de else:
Code (php)
Een exception hoeft niet per se een fout te zijn: het is letterlijk meer een uitzondering. Je kunt exceptions bovendien gebruiken om fouten op te lossen — wat vaak beter is dan fouten alleen maar melden.
Neem bijvoorbeeld deze invulling van een business rule. Hier wordt een fout niet slechts gemeld, maar meteen verholpen:
Code (php)
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
<?php
try {
if ($aantal > 5) {
throw new Exception('Maximaal 5 per klant.');
}
} catch (Exception $e) {
$aantal = 5;
}
?>
try {
if ($aantal > 5) {
throw new Exception('Maximaal 5 per klant.');
}
} catch (Exception $e) {
$aantal = 5;
}
?>
Verder ben je niet beperkt tot één exception, maar kun je een hele stack met exceptions bouwen. Dat kan bijvoorbeeld volgens een hiërarchische logica:
Code (php)
Verder kun je klassen ook nog hun eigen exceptions meegeven. Dan heb je bijvoorbeeld één exception-klasse voor een compleet project plus een tweede exception-klasse voor het databasegebeuren binnen het project:
• class FooCore_Exception extends Exception {}
• class FooCore_Database_Exception extends FooCore_Exception {}
En een namespace-indeling die er zo uitziet:
• ../library/FooCore/Exception.php
• ../library/FooCore/Database/Exception.php
Wouter J op 02/10/2013 01:25:12:
Ik gebruik een if en daarna gooi ik een exception. Vervolgens wordt deze ergens anders in een try..catch block gevangen
Wouter J op 02/10/2013 07:51:41:
Nee, die handel ik af met de exceptionhandler.
Euh, gebruik je dan én een exceptionhandler én try/catch blokken?
@Ward: thanks. Wat ik me afvraag... volgens Wouter doe je het loggen niet vanuit een Exception class, maar bepaal je in het catch-blok of er iets gelogd moet worden. Waarom zou je dan verschillende types exceptions gebruiken? In een tutorial zag ik dat je bijv. in een MathException zou kunnen zetten "Er is een wiskundige fout opgetreden:".
Code (php)
1
2
3
4
5
2
3
4
5
<?php
if ('er is een wiskundige fout...') {
throw new MathException('er mogen geen negatieve getallen worden gebruikt.');
}
?>
if ('er is een wiskundige fout...') {
throw new MathException('er mogen geen negatieve getallen worden gebruikt.');
}
?>
De uiteindelijke erorrmelding zou dan bijv. worden:
EXCEPTION: Er is een wiskundige fout opgetreden: er mogen geen negatieve getallen worden gebruikt.
En bij bijv. een verkeerde input fout zou je kunnen zeggen:
EXCEPTION: Er is verkeerde input geconstateerd: telefoonnummer mag geen letters bevatten.
Zoals je ziet is het enige dat verschilt de omschrijving van het soort fout. Maar moet je daar dan allerlei verschillende exception classes voor maken?
Gewijzigd op 02/10/2013 09:09:49 door Ozzie PHP
Het draait voor een deel om verantwoordelijkheden. Zoals wel vaker bij OOP. In jouw voorbeeld van een MathException meld je de fout, maar doe je er niets mee.
Code (php)
1
2
3
4
5
2
3
4
5
<?php
if ($getal < 0) {
throw new MathException('Er mogen geen negatieve getallen worden gebruikt.');
}
?>
if ($getal < 0) {
throw new MathException('Er mogen geen negatieve getallen worden gebruikt.');
}
?>
Je hebt een beslissingsregel geformaliseerd (hier geen negatieve getallen), maar je toezicht op die regel blijft beperkt tot mopperen over fouten. Je kunt er echter ook voor kiezen om de afgevangen fout te verhelpen:
Code (php)
Als je de MathException alleen verantwoordelijk wilt maken voor rekenwerk met getallen, en bijvoorbeeld niet voor inputfouten, krijg je zoiets:
Code (php)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
2
3
4
5
6
7
8
9
10
11
12
13
14
<?php
try {
if (!is_numeric($getal)) {
throw new Exception('Het argument is geen getal.');
}
if ($getal < 0) {
throw new MathException('Er mogen geen negatieve getallen worden gebruikt.');
}
} catch (MathException $e) {
$getal = abs($getal);
} catch (Exception $e) {
echo 'Er is een fout opgetreden. ' . $e->getMessage();
}
?>
try {
if (!is_numeric($getal)) {
throw new Exception('Het argument is geen getal.');
}
if ($getal < 0) {
throw new MathException('Er mogen geen negatieve getallen worden gebruikt.');
}
} catch (MathException $e) {
$getal = abs($getal);
} catch (Exception $e) {
echo 'Er is een fout opgetreden. ' . $e->getMessage();
}
?>