Routing we wlasnym MVC Opcje

[brzoza91]

Witam
Chciałbym stworzyć routing, do własnej implementacji MVC. Na początku przedstawię strukturę katalogów mojego projektu.
(IMG:http://img855.imageshack.us/img855/6812/struktura.gif)
W folderze app, będą pliki danego projektu. Każdy contoller będzie miał swój plik .yml w którym będą zapisane zasady routingu.

przykładowy plik index.yml
prefiks oznacza wpisany adres url, contoller i action wiadomo.

[PHP] pobierz, plaintext 
index: 
  prefix: /index/index/
  controller: Index
  action: index
 
show: 
  prefix: /index/show/
  controller: Index
  action: show
 
add: 
  prefix: /index/add/
  controller: Index
  action: add
[PHP] pobierz, plaintext 

i tak działa mój routing:
1. ktoś wpisuje adres na mojej stronie np. index/show/40
2. sprawdzane jest czy istnieje dany controller o nazwie index, akcja show i parametr 40
3. jesli tak to uruchamiany jest odpowiednia akcja z contollera

Routing.php

[PHP] pobierz, plaintext 
class Routing
{
    private $action;
    private $controller;
    private $parameter;
    private $routingFile;
    private $path=array();
 
    function __construct()
    {
        $this->createPath();
        $this->loadRoutingFile($this->path['contoller']);
        $path = $this->searchRouting($this->path['contoller'] . '/' . $this->path['action'], $this->
            routingFile);
 
        $this->setAction($path);
        $this->setContoller($path);
    }
 
    private function searchRouting($search, $array)
    {
        $array = (object)($array);
        $search = trim($search, '/');
 
        foreach ($array as $routing) {
            $r = trim($routing['prefix'], '/');
            if ($r == $search) {
                return $routing;
            }
        }
        header('Location: index.php');
        return false;
    }
 
    private function loadRoutingFile($name)
    {
        require_once ('/libs/yaml/Yaml.php');
        if (isset($name)) {
            $this->routingFile = Yaml::parse('c:/wamp/www/framework/app/routing/' . $name .
                '.yml');
        } else {
            $this->routingFile = Yaml::parse('c:/wamp/www/framework/app/routing/index.yml');
        }
    }
 
    private function createPath()
    {
        $url = explode('/', trim($_GET['url'], '/'));
 
        if (!isset($url[0])) {
            $url[0] = 'index';
        }
        if ($url[0] == "") {
            $url[0] = 'index';
        }
 
        if (!isset($url[1])) {
            $url[1] = 'index';
        }
        if ($url[1] == "") {
            $url[1] = 'index';
        }
 
        if(isset($url[2]) && filter_var($url[2],FILTER_SANITIZE_NUMBER_INT,FILTER_VALIDATE_INT)){
            $this->parameter=$url[2];
        }
        $this->path['contoller'] = $url[0];
        $this->path['action']= $url[1];
    }
 
    public function getAction()
    {
        return $this->action;
    }
 
    public function getContoller()
    {
        return $this->controller;
    }
 
    public function getParameter()
    {
        return $this->parameter;
    }
 
    public function setAction($path)
    {
        $this->action = $path['action'];
    }
 
    public function setContoller($path)
    {
        $this->controller = $path['controller'];
    }
 
 
}
[PHP] pobierz, plaintext 

Bootstrap.php

[PHP] pobierz, plaintext 
require_once 'core/Routing.php';
class Bootstrap
{
    public function __construct(){
        $routing=new Routing();
 
        require_once('/app/controllers/'.$routing->getContoller().'Controller.php');
        $contoller=$routing->getContoller().'Controller';
        $action=$routing->getAction().'Action';
 
        $page=new $contoller();
        $page->$action($routing->getParameter());
    }
 
}
[PHP] pobierz, plaintext 

Chciałbym aby mój kod był uniwersalny i był elastyczny dla wielu różnych projektów. Chciałbym też aby został napisany o dobre praktyki OOP. Głównie to właśnie zależy mi na wysokiej jakości kodu. Co myślicie o takim rozwiązaniu tego zagadnienia? Wszystko działa w tym routingu. Jednak bardzo mi zależy aby pisać przemyślany kod. Gdzie popełniłem jakiś błąd projektując ten routing ?

[sazian]

wiem że pewnie teraz zostanę zbesztany ale co tam (IMG:style_emoticons/default/tongue.gif)

W większości przypadków nie widzę potrzeby używania modelu(no może poza tym że wzorzec tak nakazuje) ponieważ w znacznej większości metody modelu to po prostu SELECT * FROM tabela i zapisanie tego do tablicy.
W ten sposób powstaje cała masa metod z których w wiekowości korzystam tylko raz, oczywiście można by je odpowiednio parametryzować ale w końcu dojdzie do takiej sytuacji że prawie całe zapytanie będę zapisywał w parametrach funkcji. Ja wolę napisać dokładnie takie zapylanie jakiego potrzebuję bezpośrednio w kontrolerze i nie muszę się przejmować jak chcę dodać kolejnego jojn'a że coś innego przestanie działać prawidłowo czy tak wydajnie jak by mogło. Poza tym dla mnie taki zapis w brew pozorom jest bardziej czytelny.
Znając życie pojawi się argument że modele łatwiej poddaje się testom. On ok ale co można testować jeśli w metodzie modelu mamy tylko zapytanie do SQL i nic więcej ?

Oczywiście stosuję modele ale tylko wtedy gdy wiem że kod w dokładnie takiej postaci będę potrzebował w kilku akcjach i nie jest pojedyncze zapytanie ale coś co wymaga dodatkowej obróbki po stronie php. Moim zdaniem to właśnie powinien robić model - obrabiać złożone dane, a nie robić każdego select'a do bazy



Inną rzeczą którą często robię(a co zapewne wiele osób uzna za bardzo błędne) jest przekazywanie uchwytu do wyniku zapytania do widoku - oczywiście zakładając że wynik zapytania ma być tylko wyświetlony, a nie poddawany dalszej obróbce.
Czyli np. $vies->dane=$this->db->query('SELECT ....');
i dopiero w widoku robię pętlę while do listowania wyniku.
Dlaczego tak ?
Dla mnie odpowiedź jest prosta, jeśli chciałbym zrobić pętlę while w modelu czy w kontrolerze musiałbym zapisać te wszystkie dane do tablicy, tablicę przekazać do widoku i na koniec w widoku stworzyć drugą pętlę która te dane wyświetli. Czyli muszę zadeklarować dodatkową tablicę i użyć dwóch pętli, a przy moim rozwiązaniu używam tylko jednej pętli