PHP (OOP, MVC), HTML, MySQL, Javascript, AJAX und vieles mehr!

<< Zurück zur Übersicht

In diesem Kapitel geht es um etwas, was nicht unbedingt notwendig ist. Falls ihr es eilig habt, könnt ihr das auch überspringen. Es kann aber sein, dass bestimmte Teile des restlichen Frameworks später darauf aufbauen, was momentan jedoch nicht der Fall ist.

Und zwar geht es um Filter, mit denen man die Anfrage (Request) und die Antwort (Response) vor (PreFilter) bzw. nach (PostFilter) der Abarbeitung des Controllers manipulieren kann.

Dazu muss jeder Filter eine Methode implementieren, die ein FW_Http_Request- und ein FW_Http_Response-Objekt als Parameter hat. Wenn das nicht nach einem Interface schreit…

interface FW_Filter_Interface
{
  public function execute(FW_Http_Request $request, FW_Http_Response $response);
}

FW_Filter_Chain
Es soll möglich sein, mehrere Filter zusammenzufügen und nacheinander abarbeiten zu lassen. Dazu gibt es eine FW_Filter_Chain-Klasse, die so aussieht:

class FW_Filter_Chain implements FW_Filter_Interface
{
  private $filters = array();
  private $response = null;
  private $request = null;

  public function addFilter(FW_Filter_Interface $filter)
  {
    $this->filters[] = $filter;
  }

  public function execute(FW_Http_Request $req, FW_Http_Response $res)
  {
    foreach($this->filters as $filter)
    {
      $filter->execute($req, $res);
    }
  }
}

Wie man sieht, implementiert die Klasse das FW_Filter_Interface, weil sie nach außen wie ein Filter aussieht und auch so arbeitet. Der FrontController nimmt an, dass Objekte der Klasse FW_Filter_Chain die Filter selbst sind. Also ein Problem weniger!

Mit der addFilter-Methode kann man den eigentlichen Filter (oder wieder eine FW_Filter_Chain) hinzufügen. So läßt sich eine Baumstruktur realisieren.

Die execute-Methode ruft von jedem Filter die execute-Methode auf und sorgt so dafür, dass alle abgearbeitet werden.

Filter in den FrontController einbetten
Dazu ergänzt man einfach FW_FrontController um folgende Attribute:

  private $preFilters = array();
  private $postFilters = array();

und folgende Methoden:

  public function addPreFilter(FW_Filter_Interface $filter)
  {
    $this->preFilters->addFilter($filter);
  }

  public function addPostFilter(FW_Filter_Interface $filter)
  {
    $this->postFilters->addFilter($filter);
  }

Der Konstruktor sorgt dafür, dass $preFilters und $postFilters FW_Filter_Chain-Objekte sind, so dass mit addFilter gearbeitet werden kann:

  private function __construct()
  {
    $this->preFilters = new FW_Filter_Chain;
    $this->postFilters = new FW_Filter_Chain;
  }

In der run()-Methode des FrontControllers wird dann am Anfang die Filterkette $preFilters und am Ende $postFilters abgearbeitet. Der Aufbau der Methode ist dann in etwa so:

public function run(FW_Http_Request $request, FW_Http_Response $response)
  {
    $this->preFilters->execute($request, $response);
    $debugger = FW_Debugger::getInstance();

    $module = $request->getControllerName();
    $action = $request->getActionName();
    $action .= "_Action";

    $controllers = $this->controllerpath;
    $path = $controllers."/".FW_Controller_Abstract::getValidControllerFileName($module);
    if(file_exists($path))
    {
        require_once($path);
        $controller = "Controller_".$module;
        if(class_exists($controller, false))
        {
            $this->runSubControllers($request, $response, true); //runBeforeMainController
            $controller = new $controller($request, $response);
            if(FW_Controller_Abstract::isValid($controller))
            {
                try
                {

                  if(is_callable(array($controller, $action)))
                  {
                    $controller->$action();
                  }
                  else
                  {
                    $response->redirect("Error", "error404");
                  }
                  $this->runSubControllers($request, $response, false); //runAfterMainController
                  //Display Data with View
                  $view = FW_View::getView();
                  $view->display($response);
                }
                catch(Exception $e)
                {
                  echo $e->getMessage();
                }
            }
            else
            {
              $debugger->log("Der Controller ist nicht valid", __FILE__, __LINE__, "error");
            }
       }
       else
       {
        $debugger->log("Controllerklasse nicht gefunden: ".$controller, __FILE__, __LINE__, "error");
       }
    }
    else
    {
       $debugger->log("Controllerdatei nicht gefunden: ".$path."\n Eventuell ist der erste Buchstabe des Datein
                           amens nicht groß geschrieben. ", __FILE__, __LINE__, "error");
    }
    $this->postFilters->execute($request, $response);
    $response->send();
  }

Lasst euch vom Debugger nicht iritieren! Der wird später noch genau beschrieben.

Ein Beispiel für einen Filter
Ein mögliches Beispiel für einen FW_Filter wäre z.B. ein Filter, der die GET-Parameter prüft. Dieser wäre dann selbstverständlich ein PreFilter.

Hier zeige ich euch einen PostFilter, der vor dem Absenden der Response alles in Großbuchstaben umwandelt:

class Filter_Big implements FW_Filter_Interface
{
  public function execute(FW_Http_Request $request, FW_Http_Response $response)
  {
    $txt = $response->getContent();
    $txt = strtoupper($txt);
    $response->replaceContent($txt);
  }
}

(Die Datei sollte im Ordner projektname/classes/filter liegen und big.class.php heißen)

In der index.php müssen wir den Filter dann noch registrieren:

$myChain = new FW_Filter_Chain();
$myChain->addFilter(new Filter_Big());
$frontController->addPostFilter($myChain);

oder direkt so:

$frontController->addPostFilter(new Filter_Big());

Man sieht, die Sache ist sehr einfach!

Jetzt beschäftigen wir uns mit einer neuen Art der Controller: SubController

(Wurde noch nicht bewertet)

Loading...