[kampfgnom]

Hi,
ich sitz ma wider an meinem Blog, fang aber grad neu an...in den alten code find ich mich nimmer rein

Es geht (mal wieder) um den ErrorController (Exceptionshandler wäre wahrscheinlich passender).

Es geht darum, das er alle Ausnahmen auffangen soll, die irgendwo im Ablauf auftreten. Danach soll eine Fehlerseite Produziert werden.

Mein Prinzipielles Vorgehen wäre so:
Request kommt -> Frontcontroller ---(routet zum Controller)-->View-->Ausgabe

Nur irgendwo muss jetzt gewährleistet werden, das bei einem Fehlerfall nicht das normale Template angezeigt wird, sondern meine Fehlerseite...
Ich steh irgendwie auf'm Schlauch

[mepeisen]

PHP-Exceptions nutzen und die an geeigneter Stelle im Frontcontroller zu fangen. Anschliessend auf einen speziellen Fehlercontroller verzweigen. Wirft der auch nen Fehler hast nen Problem und gibts beispielsweise
die("Alles kaputt!")
aus. Prinzipiell macht es auch das Zend Framework so.

[kampfgnom]

Also als exceptions_handler nicht eine eigene klasse, sondern den FrontController registrieren. Der das wiederum an ne Errorklasse weitergibt?!

[robo47]

Zitat von kampfgnom

Also als exceptions_handler nicht eine eigene klasse, sondern den FrontController registrieren. Der das wiederum an ne Errorklasse weitergibt?!

Ne Möglichkeit wäre, der Schnittstelle deiner Module eine eigene Error-Methode zu verpassen, wenn der Frontcontroller dann das Modul instanziert und ausführt (dispatch) und dort ne Exceptions fliegt, wird die im Frontcontroller abgefangen und automatisch die Error-Methode des jeweiligen Moduls aufgerufen (und die Exception mit übergeben).

Dann kannst du in jedem Modul anders reagieren und wenn du eigene Exceptions schmeißt die dort auch für das Modul passend und global in einer Error-Methode verarbeiten.

Wenn du eine Elternklasse für die Module hast, kannst du dort ja eine "Standard-Error-Methode" implementieren, für den Fall, dass du nicht extra für ein Modul eine "andere" ErrorMethode schreiben willst / brauchst

[kampfgnom]

Das Problem ist, die Exception wird eigentlich nie in der Controller klasse geworfen, sondern in klassen wie zum Beispiel die verbindung zur DB oder sowas...

da wollt ich einen globalen error handler registrieren, der sich dann um die verarbeitung kümmert. Wenn es ausgegeben werden soll, dann wird statt auf das aufgerufene Template auf ein errortemplate umgeleitet...

[kampfgnom]

Sorry für den Dopplepost, aber das passt in den alten nicht rein!

Ich hab es jetzt erstmal so gelösst, das ich ein Application_Controller dazwischen schalte.
Heißt, der aufruf in der Bootstrapper geht dann so:

PHP-Code:

$application = Application_Controller::getInstance();
$application->init();
/**
 * viel Konfigurationsspaß
 *....
 **/
$application->run(); 


so dann der Code des Application Controllers:

PHP-Code:

<?php
class Application_Controller
{
    protected static $instance = null;

    protected function __construct()
    {
    }
    
    public static function getInstance()
    {
        if (self::$instance === null)
        {
            self::$instance = new Application_Controller();
        }
            return self::$instance;
    }
    public function init()
    {
        $FrontController = Front_Controller::getInstance();
        $request = $FrontController->getRequest();
        Debug::Dump($request);
    }
    
    public function run()
    {
        /**
         * @todo 
         */
    }
    
    public function loadController()
    {
     /**
      * @todo: Code....
      */
    }
    
    public function loadView()
    {
       /**
      * @todo: Code....
      */
    }
}
?>

so die unterne methode interresieren erstmal nicht.
Mir geht es um init();
Dort hole ich mir aus dem Front_Controller den Request in Form eines Arrays:

array(4) {
  ["module"]=>
  string(5) "index"
  ["controller"]=>
  string(4) "test"
  ["action"]=>
  string(3) "lol"
  ["QUERY_STRING"]=>
  array(2) {
    ["GET"]=>
    array(0) {
    }
    ["POST"]=>
    array(0) {
    }
  }
}

sieht im normalfall in etwa so aus...
Wenn jetzt irgendwo eine Exception geworfen wird, dann hab ich einen Error_Controller registriert, der sich um die Verarbeitung kümmert.
Er wiederum manipuliert den Front_Controller, wenn die Exception ausgegeben werden soll. Das sieht dann so aus:

PHP-Code:

$echo = Front_Controller::getInstance();
        $echo->setController('error');
        $echo->setAction('index');
        Debug::Dump($echo);
        $application = Application_Controller::getInstance();
        $application->init(); 


das Debug::Dump(); gibt mir lediglich ein formatiertes var_dump()...

So mein Problem ist jetzt, das der Front controller zwar richtig manipuliert wird, aber in der init(); methode nicht das richtige ankommt.
Ich denke ja, es liegt daran, dass der Application_Controller Singletone ist und dadurch die init() methode nicht wirklich neu aufgerufen wird, und den neuen request bekommt...
hat da jemand ne idee wie ich es schaffe, das der Application_Controller den neuen Request bekommt?

[Basti]

Warum liegt der FrontController hinter dem ApplicationController? Und warum willst du den Request manipulieren?

Mein Vorschlag:

PHP-Code:


set_error_handler('errorHandler');

function errorHandler(...)
{
    die('bootstrap error ...');
}

class FrontController
{
    protected $Context;

    public function __construct()
    {
        $this->Context = $this->buildContext();
    }

    public function run()
    {
        $Ac = new ApplicationController($this->Context);
        $Ac->run();
    }
}

class ApplicationController extends Controller
{
    protected function init()
    {
        set_error_handler(array($this, 'errorHandler'));
    }

    public function run()
    {
        $sController = $this->Request->get('controller');
        $sAction = $this->Request->get('action');

        try {

            $Controller = $this->addChild('controller', $sController);
            $Conroller->execute($sAction);

        } catch (Exception $E) {

            $Controller = $this->addChild('controller', 'Error');
            $Controller->setError($E);
        }

        $this->display();
    }
}

abstract class Controller
{
    protected $Request;

    final public function __construct(Context $Context)
    {
        $this->Request = $Context->getRequest();
        $this->init();
    }

    protected function init()
    {
    }
} 


Oder so halt…

Basti

[kampfgnom]

ok, ich bin noch nicht ganz mitgekommen.
Also die buildContext Methode ist dafür da die aufgerufene adresse richtig zu routen? und danach zu entscheiden welcher Controller aufgerufen werden muss, oder wie?

Und in der Run methode setzt du alles in einen try-catch block, da ja alle Exceptions innerhalb dieses blocks geworfen werden...stimmt!
Danke basti!
da kann ich mir was draus basteln!

Vielen Dank!!!

[Basti]

Zitat von kampfgnom

ok, ich bin noch nicht ganz mitgekommen.
Also die buildContext Methode ist dafür da die aufgerufene adresse richtig zu routen? und danach zu entscheiden welcher Controller aufgerufen werden muss, oder wie?

Nein, das ist bei mit nur ein Objekt, dass Request, Session und Config enthält – z.T. auch gefiltert, damit die Controller nur „ihren“ Request bekommen, unabhängig davon, wo sie wie eingebaut sind (Decorierer).

Die Entscheidung, welcher Controller eingebunden wird trifft hier der ApplicationController aufgrund z.B. der Infos, die er aus dem Request zieht.

Basti

[kampfgnom]

Zitat von Basti

Nein, das ist bei mit nur ein Objekt, dass Request, Session und Config enthält – z.T. auch gefiltert, damit die Controller nur „ihren“ Request bekommen, unabhängig davon, wo sie wie eingebaut sind (Decorierer).

Die Entscheidung, welcher Controller eingebunden wird trifft hier der ApplicationController aufgrund z.B. der Infos, die er aus dem Request zieht.

Basti

Das ist mir dann beim weiteren auseinandernehmen deines Codes auch aufgefallen.
Mittlerweile funtkioniert es ziemlich gut!
jetzt steh ich nur noch mit den header mehr oder weniger auf kriegsfuss. Aber das ist nur ne stilfrage bzw eine frage der codelänge...
Danke!!

kann man header auch so senden:

PHP-Code:

        $code = 404;
        header("HTTP/1.0 ".$code); 


oder muss ich immer alles mit senden? also auch das Notfound?
Ich mein, wenns nicht geht mach ich mir nen array mit diesen beschriebungen aber das wäre ja mehr arbeit^^

[Dennis]

Zitat von kampfgnom

HEs geht darum, das er alle Ausnahmen auffangen soll, die irgendwo im Ablauf auftreten. Danach soll eine Fehlerseite Produziert werden.

Mein Prinzipielles Vorgehen wäre so:
Request kommt -> Frontcontroller ---(routet zum Controller)-->View-->Ausgabe

Nur irgendwo muss jetzt gewährleistet werden, das bei einem Fehlerfall nicht das normale Template angezeigt wird, sondern meine Fehlerseite...
Ich steh irgendwie auf'm Schlauch

Wo ist das Problem? Ein Fehler tritt auf, d.h. eine Exception wird geworfen. Sofern sie an Ort und Stelle abgefangen werden kann, kein Problem, ansonsten läuft sie durch, bis sie jmd. fängt. Die letzte Instanz wäre der Front-Controller, der JEDE Exception aus den Controllern fangen sollte und diese dann ggf. an einen Error-Controller übergeben. Wirft der Error-Controller auch eine Exception, schreib ein Logfile und kill die Anwendung. Weitere Fehlerbehandlung wäre zwecklos, nun sollten Bugs bereinigt werden.

[kampfgnom]

Das problem war schon beseitigt^^

aber trzd danke für deine antwort!