[dr.e.]

Das ist ja mein Aktuelles Problem...

Hier kann ich dir UML konzentriert von Martin Fowler empfehlen. Im Buch beschreibt er an Hand von Anwendungsbeispielen UML. Solltest dein Gutschein dazu nicht mehr reichen -> PN.

[ljungi]

Für UML kann ich folgendes Buch auch noch empfehlen:

ISBN: 3937137610

[kampfgnom]

Danke für eure Tipps:

Ich habe mir jetzt das Teilproblem Error handling herausgepickt und habe dazu folgendes UML Diagramm erstellt:


aufgerufen wird das ganze wie folgt:

PHP-Code:

$error = new Error_Error('html');
$error->setException(new Exception('Unbekanter Fehler', 5));
$error->out(); 


in der error Klasse wird dann geprüft ob der Typ existiert, wenn nicht -> Exception.

Dann wird je nach Typ die bestimmte Klasse initialiesiert und über set Exception kann der Fehler gesetzt werden.
Mit der Funktion out() wird das ganze dann so verarbeitet wie es der Typ verlangt. Also ausgegeben oder in den Log geschrieben. je nach dem.
Der Code sieht bisher so aus:

PHP-Code:

class Error_Error 
{
    protected $errorInstance = null;
    
    protected $exception = null;
    
    protected $message;
    
    protected $number;
    
    public function __construct($type)
    {
        switch ($type)
        {
            case 'html':
                $error = new Error_HTML();
                break;
            case 'log':
                $error = new Error_Log();
                break;
            default:
                throw new Exception('Unknown Errortype');
        }
        
        $this->errorInstance = $error;
        
    }
    public function setException (Exception $exception)
    {
        $this->exception = $exception;    
    }
    
    
    public function out()
    {
        $this->errorInstance->errorMessage($this->exception->getMessage());
        $this->errorInstance->errorNumber($this->exception->getCode());
        
        $this->errorInstance->out();
    }
} 


So nun möchte ich mal eure Meinung dazu hören. Kann man das so lassen?
Oder verstoße ich gegen ein Design Grundsatz?!

Hier kommt natürlich noch mehr dazu. Also es wird noch geprüft ob überhaupt eine Exeption vorhanden ist. Außerdem wird die Funktionalität erweitert.
Zum Beispiel Ausgabe des Pfades etc.

Aber es geht mir hier um die herangehensweise

[dr.e.]

Hallo,

Kannst du mir mal ein Beispiel machen, wie das in der konkreten Applikation eingesetzt werden soll? Der Code-Schnipsel dazu ist IMHO nicht praktikabel, weil zu lang/umständlich...

[kampfgnom]

z.b.

PHP-Code:

/* errorklasse */

$error = Error_Error('log');

try
{

//some code
}catch (Exception $e)
{
    $error->setException($e);
    $error->out();
} 


in etwa so hab ich mir das vorgestellt

[$traight-$hoota]

also du initialisierst erst einen Errorhandler, der einen möglichen Error ausgeben soll und hinterher wird der dann bei einer Exception mit dieser gefüttert und gibt diese aus.
Das ist imo nicht so sinnvoll, weil so von vorneherein festgelegt ist, was mit einem Error passiert. Einerseits muss der Errorhandler dazu immer initialisiert werden, auch wenn er nicht gebraucht wird (was ja der Normalfall sein sollte), und andererseits werden so alle fehler gleich behandelt. Aber verschiedene Fehler sollten auch verschiedene Reaktionen hervorrufen. Wenn ein grundlegendes Problem vorliegt (beispielsweise DB nicht erreichbar), sollte auf jeden Fall der Admin benachrichtigt werden und nicht nur ein Eintrag ins Log geschehen. Ein Fehler, der durch eine Benutzereingabe hervorgerufen wird hat aber nicht unbedingt etwas im Log zu suchen.

[dr.e.]

Hallo kampfgnom,

das hatte ich schon fast befürchtet und da muss ich $traight-$hoota Recht geben, das ist nicht zielführend. Ich würde hier besser einen globalen ExceptionHandler implementieren und diesen mit http://de.php.net/manual/en/function...on-handler.php verwenden. Dort kannst du dir dann derartige Konstrukte oder Maßnahmen überlegen. Man könnte dort z.B. eine Config von "known exceptions" laden um entsprechend reagieren zu können oder falls die Exception nicht bekannt ist eine "unknown exception" werfen. Da man von "Exception" erben kann ist es ein leichtes verschiedene Exceptions zu definieren und beispielsweise per

PHP-Code:

throw new MySQLException('Database not found',$this); 


eine benutzerdefinierte Exception zu schmeissen, die dann sogar auf Methoden der Klasse über die Referenz zugreifen und dort Aktionen oder Verhalten auslösen kann.

[kampfgnom]

Ok das klingt logisch.
Jetzt aber mal ne Frage:
Wie kann ich, wenn ich den Exception Handler nutze, erreichen, dass ich das in den log schriebe, oder das ganze ausgegeben wird!?
Weil das ist ja nur eine funktion oder verstehe ich das falsch?!

Naja aber deswegen frag ich ja hier damit ihr mir sagen könnt was ich falsch mache

[dr.e.]

Hallo,

schau dir mal set_exception_handler() an. Dort kannst du eine eigene Implementierung als ExceptionHandler einsetzen. In dieser Implementierung kannst du ganz einfach ein Logfile öffnen und deine Exception im gewünschten Format reinschreiben. Das erste Beispiel unter http://de.php.net/manual/en/function...on-handler.php zeigt eine Möglichkeit der Implementierung.

[kampfgnom]

Also quasie so:

PHP-Code:

function exception_handler($exception) 
{  
    $error = new Error_Error('log');  
    $error->setException($exception);  
    $error->out();
}
set_exceptions_handler("exception_handler"); 


Mein Problem ist jetzt grad (Ich sitz hier im Info unterricht und hab HTML ) Wie ich es schaffe mehrere Arten des Error-displays zu schaffen.
Vielleicht mit nem Array den ich druchlaufen lasse und da meine Arten auslese?!

Außerdem wurde gesagt, der Error handler soll nicht wissen welche art er hat. Aber wie Realiesier ich das? Wenn ich eine Globale Konstante festlege programmier ich ja nicht mehr gegen eine Schnittstelle sondern gegen eine konkrete Implementierung.
Wenn ich das aber über ein Argument im Konstruktor Übergeben, so meint $traight-$hoota das es auch flasch ist?!
Frag: Wie denn jetzt

[$traight-$hoota]

Zitat von kampfgnom

Wenn ich das aber über ein Argument im Konstruktor Übergeben, so meint $traight-$hoota das es auch flasch ist?!
Frag: Wie denn jetzt

Wenn du das so wie in dem letzten Beispiel machst, kann die Art der Ausgabe natürlich dem Konstruktor übergeben werden. Allerdings sollte es von der Exception abhängig sein, welcher Parameter verwendet wird.
Dazu könnte einfach jede Excepion einen entsprechenden wert haben, den du dann nur holen musst. Allerdings wäre mir dann zu viel, das die Funktionalität bestimmt, in der Exception gekapselt. Du kannst auch ein Array mit allen Fehlern an legen und denen Parameter zuweisen.
Also beispielsweise

PHP-Code:

$errors = array(
'DBError' => 'log',
'UserError' => 'message',
'FileError' => 'admin'
); 


oder so was in der art.
Oder, ein bischen aufwändiger, du gibst jeder Exception eigens definierte Errorlevel und entscheidest dann, was passiert, wenn eine Exception eine gewisse "Schwere" hat.

[Basti]

Schau dir mal das Observer-Pattern an. Damit könnte dein Error-Handler für unterschiedliche Fehlerstufen jeweils eine Methode anbieten, über die Beobachter an den Error-Handler bzw. die jeweilige Fehlerstufe gebunden werden können. diese Beobachter werden bei einem Fehler informiert und machen dann, was sie eben damit machen wollen:

PHP-Code:

<?php

$Logger    = new Logger($Config);
$HtmlError = new HtmlError;

$ErrorHandler = new ErrorHandler();

$ErrorHandler->addNoticeHandler($Logger);
$ErrorHandler->addErrorHandler($Logger);
$ErrorHandler->addErrorHandler($HtmlError);

…die Namen sind hier natürlich besch…eiden gewählt, aber das Prinzip sollte deutlich werden.

Ungünstig an dieser Lösung ist natürlich, dass a) mehrere Objekte im Vorfeld initialisiert werden müssen und ggf. noch, dass b) die Fehlerstufen fest in die Schnittstelle gegossen werden.

Die einzelnen Beobachter würden alle eine definierte Schnittstelle implementieren (IErrorObserver oder so).

Basti

[kampfgnom]

Hab mir jetzt mal das Observer Pattern angeschaut.

Das problem ist ja jetzt, ich müsste sozusagen immer schreiben:

PHP-Code:

if (bedingung)
{
   $this->notice();
    die();
} 


weil ja sonst das script auch mitfehler weitergeht oder?


Das mit dem Exceptionshandler klingt ja schon nicht schlecht...frage:
Wie kann ich sozusagen mit einem String Überprüfen ob die Exception eines bestimmten types ist
weil man müsste ja dann mit instance_of überprüfen was es für ein fehler ist.
und ich ja iwie festlegen will, was mit welchem felher passiert.

-_> war ein wenig unverständlich sry, weiß es aber nich besser auszudrücken...

[dr.e.]

Hallo kampfgnom,

zum Thema dynamischem ExceptionHandling kann man sich überlegen, dass die Exception selbst ihre mögliche Reaktion kennt. Diese kann der ExceptionHandler bei der Exception erfragen und entsprechend handeln. Das geht teilweise konträr zu obigem, ist aber trotzdem denkbar. Der ExceptionHandler kann dabei die Exception fragen, welche Klasse das Handling der Exception übernehmen soll. Entweder kann das die Instanz einer bereits bestehenden Klasse sein (siehe oben), oder die Information, welche Klasse zu instanziieren und zu verwenden ist.

[kampfgnom]

Naja ich würde halt gerne iwo zentral eine art config haben wollen, die festlegt welcher error wie behandelt wird also so:

PHP-Code:

$error->setExceptionHandling ('db', 'admin,log'); 


sowas in der art!

[dr.e.]

Das verstehe ich nicht ganz. Was ist für dich $error? Falls das dein Error-/Exception-Handler ist, ok, andernfalls sollte man das etwas "schöner" kapseln/konfigurieren.

[kampfgnom]

ok das war ein blödes Beispiel. Da ich ncoh kein Konkreten Code habe, versuch ich das nochmal in Worten wieder zugeben.
Mir schwebt vor, einen Exceptionshandler zu schreiben, der auswählt was mit welchen Exceptions passiert. Dabei ist es wichtig das man für jede Exception getrennt festlegen kann welcher, ich sag mal, errohanlder (also klassen die das z.b in den log schrieben) verwendet wirrd.
Das sollte möglichst über eine Methode gehen.

Meine idee war, das man alle exceptions an eine klasse übergibt .
bei dieser hat man vorher registriert, welcher error wie behandelt wird.

Mein Problem ist allerdings noch die identifiezierung des errors.

Also um das nochmal in eine konkrete Frage zu fassen:
Wie kann ich heruasbekommen von welchem Typ die Exception ist.

Sollte man ihr eine methode á la getExceptoinType() geben? oder wie könnte man das machen??




Weiß denn keiner wie ich den Name der Instanz als String bekomme?

Also ich hab eine Exceptionsklasse: myException();
Dann würde ich gerne heraus "myException" herausbekommen

[kampfgnom]

Ok hab mir jetzt nochmal was für meinen Exceptionshandler ausgedacht:

PHP-Code:

<?php
interface Exceptionhandler
{
    public function getType();
}


class MyException extends Exception implements Exceptionhandler 
{
    public function __construct($message, $code = 0) {
        // etwas Code
    
        // sicherstelen, dass alles korrekt zugewiesen wird
        parent::__construct($message, $code);
    }

    
    public function getType() {
        return "MyException";
    }
}
?>

Kann man das so machen?? Oder nicht. Denn so hätt ich zumindest schonmal eine möglichkeit zuÜberprüfen ob es wirklich "meine" Exceptions sind

PHP-Code:

__construct (Exceptionshandler $exception)
{
    //some Code
} 


Außerdem ich jetzt Konfigurieren wie die Exceptions behandelt werden. Hab ja jetzt ihren Type!

Also gebt mir euren Senf!!

[dr.e.]

Hallo kampfgnom,

ich würde ExceptionHandler und Exception trennen. Für beide kann es natürlich ein Interface geben, aber ein "Handler" ist schon sprachlich für die Behandlung zuständig. Das "was" definiert dann die Exception (siehe die Diskussion oben).

[kampfgnom]

Ok Namensgebung war scheiße haste recht. Aber vom Ansatz her, ein Interface zu definieren welches alle Exceptions implementieren is richtig/gut?