Hej!
W celu lepszego zrozumienia idei MVC postanowiłem troszkę się pobawić i korzystając z wielu dostępnych mi źródeł napisać coś na wzór pseudo-MVC-frameworka. Mam jednak parę pytań, z czego najważniejsze to czy to się w ogóle trzyma kupy?

Autoloader wygląda następująco:

[PHP] pobierz, plaintext 
<?php		
	function __autoload($className) {
		if(file_exists(ROOT.DIRECTORY_SEPARATOR.'library'.DIRECTORY_SEPARATOR.strtolower($className).'.class.php')) {
			require_once ROOT.DIRECTORY_SEPARATOR.'library'.DIRECTORY_SEPARATOR.strtolower($className).'.class.php';
		} elseif(file_exists(ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'controllers'.DIRECTORY_SEPARATOR.strtolower($className).'.php')) {
			require_once ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'controllers'.DIRECTORY_SEPARATOR.strtolower($className).'.php';
		} elseif(file_exists(ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'models'.DIRECTORY_SEPARATOR.strtolower($className).'.php')) {
			require_once ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'models'.DIRECTORY_SEPARATOR.strtolower($className).'.php';
		} elseif(file_exists(ROOT.DIRECTORY_SEPARATOR.'library'.DIRECTORY_SEPARATOR.'helpers'.DIRECTORY_SEPARATOR.strtolower($className).'.class.php')) {
			require_once ROOT.DIRECTORY_SEPARATOR.'library'.DIRECTORY_SEPARATOR.'helpers'.DIRECTORY_SEPARATOR.strtolower($className).'.class.php';
		} else {
			// nie ma takiego pliku, jakis error handler?
		}
	}
[PHP] pobierz, plaintext 

Mam taki pseudo "front Controller", który ma za zadanie odpalenie odpowiedniego kontrolera na podstawie $_SERVER['request'] i wygląda on tak:

[PHP] pobierz, plaintext 
<?php
	class FrontController {
		private $_queryString;
		private $_controller;
		private $_action;
		private $_dispatch;
		public function callHook($url) {
			$urlArray = explode('/', $url);
 
			$controller = $urlArray[0]?$urlArray[0]:'main';
			array_shift($urlArray);
			$action = $urlArray[0]?$urlArray[0]:'index';
			array_shift($urlArray);
			$queryString = $urlArray;
 
			$controllerName = $controller;
			$controller = ucfirst($controller);
			$model = $controller;
			$controller .= 'Controller';
 
			$this->_queryString = $queryString;
			$this->_controller = $controller;
			$this->_action = $action;
			if(class_exists($controller)) {
				$this->_dispatch = new $controller($model, $controllerName, $action);
			} else {
				$this->_action = 'error404';
				$this->_controller = 'error';
				$this->_queryString = $_SERVER;
				$this->_dispatch = new ErrorController('error', 'error', 'error404');
			}
		}
 
		public function addHelper($class) {
			if($class instanceof TemplateHelper) {
				$this->_dispatch->addTemplateHelper($class);
			} else {
				$this->_dispatch->addModule($class);
			}
		}
 
		public function run() {
			if((int)method_exists($this->_controller, 'init')) {
				$this->_dispatch->init();
			}
			$this->_dispatch->{$this->_action}($this->_queryString);
			$this->_dispatch->render();
		}
	}
[PHP] pobierz, plaintext 

Klasa Controller, po której dziedziczy każdy kontroler wygląda natomiast tak

[PHP] pobierz, plaintext 
	class Controller {
		protected $_model;
		protected $_controller;
		protected $_action;
		protected $_template;
		protected $_modules;
 
		public function __construct($model, $controller, $action) {
			$this->_controller = $controller;
			$this->_model = $model;
			$this->_action = $action;
			$this->_template = new Template($this->_controller, $this->_action);
		}
 
		public function addModule($module) {
			$this->_modules[get_class($module)] = $module;
		}
 
		public function addTemplateHelper($helper) {
			$this->_template->addTemplateHelper($helper);
		}
 
		public function set($name, $value) {
			$this->_template->set($name, $value);
		}
 
		public function render() {
			$this->_template->render();
		}
	}
[PHP] pobierz, plaintext 

A klasa Template, która odpowiada za wczytanie i wyrenderowanie odpowiedniej templatki (jest dość primitywna)

[PHP] pobierz, plaintext 
<?php
	class Template {
		protected $_variables = array();
		protected $_controller;
		protected $_action;
		protected $_helpers;
 
		public function __construct($controller, $action) {
			$this->_controller = $controller;
			$this->_action = $action;
		}
 
		public function __set($name, $value) {
			$this->set($name, $value);
		}
 
		public function set($name, $value) {
			$this->_variables[$name] = $value;
		}
 
		public function addTemplateHelper($helper) {
			$this->_helpers[get_class($helper)] = $helper;
		}
 
		public function getHelper($helper) {
			return $this->_helpers[$helper];
		}
 
		public function load($helper) {
			$template = new Template('helpers', $helper);
			$template->render();
		}
 
		public function render($doNotRenderHeader = false) {
			extract($this->_variables);
 
			if($doNotRenderHeader == false) {
				if(file_exists(ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'views'.DIRECTORY_SEPARATOR.$this->_controller.DIRECTORY_SEPARATOR.'header.phtml')) {
					require_once ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'views'.DIRECTORY_SEPARATOR.$this->_controller.DIRECTORY_SEPARATOR.'header.phtml';
				} elseif(file_exists(ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'views'.DIRECTORY_SEPARATOR.'header.phtml')) {
					require_once ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'views'.DIRECTORY_SEPARATOR.'header.phtml';
				}
			}
			require_once ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'views'.DIRECTORY_SEPARATOR.$this->_controller.DIRECTORY_SEPARATOR.$this->_action.'.phtml';
 
			if($doNotRenderHeader) {
				if(file_exists(ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'views'.DIRECTORY_SEPARATOR.$this->_controller.DIRECTORY_SEPARATOR.'footer.phtml')) {
					require_once ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'views'.DIRECTORY_SEPARATOR.$this->_controller.DIRECTORY_SEPARATOR.'footer.phtml';
				} elseif(file_exists(ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'views'.DIRECTORY_SEPARATOR.'footer.phtml')) {
					require_once ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'views'.DIRECTORY_SEPARATOR.'footer.phtml';
				}
			}
		}
	}
[PHP] pobierz, plaintext 

Jeśli komukolwiek udało się przebrnąć przez te linijki kodu mam 3 pytania:
a) Czy udało mi się uchwycić ideę OOP
Czy udało mi się uchwycić ideę MVC
c) Co mogę poprawić, żeby kod był bardziej OOP/MVC.

Przepraszam za chaotyczność (?) tego postu ale mam grypę i logiczne myślenie jest ciężkawe :<.

Pozdrawiam i z góry dzięki,
Vielta

O kur... co to za autoloader.
Poczytaj o include_path

Dlaczego pytacie się "czy robię zgodnie z OOP, co mogę zrobić by było bardziej OOP"? W pani domu wyczytaliście, że jest moda na skrót OOP?
Główną zasadą projektowania klas w OOP jest odpowiedzenie sobie na pytanie
"Co mi da wprowadzenie obiektu? Czy łatwo mogę rozszerzyć możliwości klasy? Jakie ograniczenia sobie stwarzam?" i w myśl tego projektować.
Mniej więcej załapałeś o co chodzi, brakuje mi silnego typu argumentów http://pl2.php.net/manual/pl/language.oop5.typehinting.php
Brakuje również phpdoca o którym mam nadzieję będziesz pamiętać.

Nie wiem jak ty ale ja pani domu nie czytam ;P (wolę sekrety serca!)

O Phpdoc z reguły pamiętam, teraz nie używałem bo pisałem to tylko i wyłącznie w celach edukacyjnych. W sumie fakt, powinienem dodać jak wrzucałem na forum, mea culpa.

Odpowiedziałem sobie na te pytania, co mi to daje? Brak konieczności powtarzania niektórych bloków kodu, oddzielone od siebie wszystko co związane z bazą/widok/logika. W sumie mogę łatwo rozszerzyć ale nie jestem pewien do jednego, [u]nie przemawia do mnie motyw tego, że żeby odwołać się do Template muszę to robić przez Controller.

Średnio widzę miejsce gdzie Type Hinting mógł bym użyć

Piszesz o MVC, a tymczasem w kodzie jest jedynie podstawa kontrolera (który nie wiadomo czemu ma mieć jeden model, referencję do innego kontrolera (wtf?) i narzucony jakiś szablon). Gdzie jest reszta (tj. Widok/Model), gdzie jakiś przykład finalnego zastosowania?

To z modelem zmieniłem chwilę po wrzuceniu posta na forum, faktycznie było to dość głupie.

To frontcontroller to po prostu taka nazwa, w sumie dispatcher pasowało by lepiej, z założenia była to po prostu klasa, która zajmuje się requestem i uruchamia odpowiedni controller. A jak wg. Ciebie powinno to wyglądać? Szablon powinienem sam ustalać osobno dla każdego kontrolera? Nie lepiej dać tak jak tutaj szablon zależny od kontrolera z nazwą z góry ustaloną?

Klasę widoku podałem przecież w 1. poście a klasa model jest póki co na tyle mało rozwinięta, że pewnie wrócę z nią tutaj za parę dni gdy skończę pisać.


@wookieb
Ten autoloader powinien tak wyglądać mniej więcej?

[PHP] pobierz, plaintext 
	add_include_path(ROOT.DIRECTORY_SEPARATOR.'library'.DIRECTORY_SEPARATOR);
	add_include_path(ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'controllers'.DIRECTORY_SEPARATOR);
	add_include_path(ROOT.DIRECTORY_SEPARATOR.'application'.DIRECTORY_SEPARATOR.'models'.DIRECTORY_SEPARATOR);
	add_include_path(ROOT.DIRECTORY_SEPARATOR.'library'.DIRECTORY_SEPARATOR.'helpers'.DIRECTORY_SEPARATOR);
 
	function __autoload($className) {
		require_once $className.'.php';
	}
[PHP] pobierz, plaintext 

Nie wiem po co Ci funkcja add_include_path. Ogólnie dobrze ale wystarczy, że użyjesz http://pl2.php.net/manual/pl/function.set-include-path.php
TYPE HINT zdecydowanie możesz użyć w metodach gdzie wymogiem jest przekazanie obiektu. Np w twoim addTemplateHelper.

add_include_path to funkcja z tego linku, który podałeś co bym się nie pogubił dodając te ~5 ścieżek

Co jeszcze powinienem poprawić/nad czym pomyśleć?

Wybacz, nie chce mi się n-ty raz pisać o MVC.W takim razie wróć do teorii tego wzorca - widok nie ma nic wspólnego z szablonem - może go co najwyżej na samym końcu odpalić, jeżeli zajdzie taka potrzeba.

Przecież w PHP nie da się go nigdzie indziej użyć (no... tam jeszcze tablice, ale to śmiechu warte jest :])

Trochę dziwnie na moje oko rozwiązałeś sprawę front controllera, ja u siebie mam zadania routingu/walidacji rozbite na dwie klasy - router oraz dispatcher. Dla tej pierwszej przekazuje w argumencie query string i po wykonaniu dostaje od niej ostateczne dane. Tworzenie obiektu i wywoływanie akcji zrzucam właśnie na klasę front controller. W nim tworzę obiekt dispatcher-a i on sprawdza czy żądany kontroler/akcja istnieje (oraz czy jest poprawny - przydaje się tutaj ReflectionClass) jeżeli tak załącza odpowiedni plik i po utworzeniu obiektu kontrolera odpalamy akcję. Co do autoloader-a to ja to rozwiązałem w ten sposób, że nazwy klas zapisywane są w stylu "underscore", bardziej po zendowsku Przykładowo z ciągu af_Database_Interface_QueryBuilder usuwam prefix "af" i podkreślniki zamieniam na ukośniki, konwertuje na małe znaki i dostaję ścieżkę "/database/interface/querybuilder". W taki sposób autoloader elegancko odnajduje sobie poprawną ścieżkę. Oczywiście nie musisz robić tego w sposób jaki podałem. Luźne sugestie

pozdrawiam

edit:


urok tego języka nie ma to jak dodać obsługę dla obiektów/tablic i zapomnieć o reszcie

@Crozin
Nie no spoko, wiem, że ten temat jest poruszany codziennie około 10x na forum W takim razie średnio zrozumiałem co to jest widom, sądziłem, że widok = szablon.

Nie sądzisz, że jeżeli by tak było to by się to nazywało... szablonem nie widokiem? Widok to przede wszystkim logika aplikacji - a szablon - to już ostatni etap tej warstwy (nie zawsze konieczny).

Zapewne tak by się nazywało. Odpowiedz mi tylko na 1 pytanie jeśli możesz. Do modelu odwołuje się kontroler czy widok?

I jedno i drugie - jednak z dużym naciskiem na to ostatnie.

A już miałem nadzieję, że zrozumiałem o co chodzi z widokiem.

user wchodzi na stronę -> dispatcher dostaje URL i ładuje odpowiedni controller i jego odpowiednią akcję/metodę -> w metodzie uruchamiamy odpowiedni widok (i/lub model) -> widok wykorzystuje model tylko i wyłącznie w celu pobierania danych a controller dodawania/edytowania.

Tak to wygląda?:<

Nie.
http://forum.php.pl/index.php?s=&showt...st&p=771967

w kontrolerze tworzysz widok i do nich przypisujesz nieograniczoną ilość modeli, dam Ci przykład z mojego frameworka (przykład pisany na szybko):

[PHP] pobierz, plaintext 
// tworzymy model
$users = new af_Users_Model;
 
// tworzymy widok
$view = new af_View('users/cp');
// dodajemy utworzony model do widoku
$view->add_model($users);
 
// jeżeli formularz został wysłany
if ( $this->request->post->is_sent() ) {
  // tworzymy obiekt walidatora
  $validator = new af_Validator;
  // dodajemy regułę
  $validator->add_rule(
    $this->request->post->password,
    $this->translate->password->not_filled_properly,
    array('require', 'min_length' => 6, 'max_length' => 20)
  );
 
  // jeżeli formularz jest poprawny
  if ( $validator->is_valid() ) {
    // uruchamiamy metodę z modelu do zmiany hasła
    $users->change_password($this->session->user->id, $this->request->post->password);
  } else {
    // pobieramy błędy walidatora i przekazujemy do widoku
    $view->assign('errors', $validator->errors);
  }
}
 
// ta część odpowiada za wyświetlenie żądanego formatu strony (to już nie jest tutaj istotne, to mój taki mały port z RoR:D)
switch ( $this->response->format ) {
  case 'html':
     $this->response->text = $view;
     break;
}
[PHP] pobierz, plaintext 

W tym przypadku można było użyć active record, ale tak było prościej wytłumaczyć jak to powinno wyglądać. W widoku możesz teraz sobie pobierać konkretne dane, które chciałbyś wyświetlić, tutaj raczej nie jest to potrzebne, ale ogólnie to tak to działa

pozdrawiam.

@Quantum: Mógłbyś pokazać jakąś przykładową implementację widoków/modeli? Bo przy takim interfejsie nie potrafię sobie wyobrazić jak chcesz zrealizować założenia tego wzorca.

hmm, a mógłbyś sprecyzować ? co mogłoby przeszkodzić w realizacji tegoż wzorca w takim interfejsie (poza logicznymi ograniczeniami protokołu) ? fw jest dość "świeży" więc możliwe, że czegoś nie przemyślałem, ale ogólnie starałem się przenieść fajne rozwiązania z innych i stworzyć wygodny przynajmniej dla mnie w użyciu

[PHP] pobierz, plaintext 
class af_Users_Model {
	public function __construct() {
		$this->database = af_Repository::request('database', 'mysql', 'test_db');
	}
 
	public function get_with_age($age) {
		return $this->database
		->from('users')
		->where('age', $age)
		->select('*');
	}
}
[PHP] pobierz, plaintext 

model jest w tym momencie bardzo prosty, ale w przyszłości myślałem nad stworzeniem klasy af_Model, po której bym dziedziczył, a jej konstruktor przypisywałby żądane w modelu abstrakcje dostępu do danych, moja koncepcja:

[PHP] pobierz, plaintext 
class af_Users_Model extends af_Model {
  protected $load = array(
    'database' => 'mysql.test_db'
  );
 
  public function get_sth() {
    return $this->database...
  }
}
[PHP] pobierz, plaintext 

[PHP] pobierz, plaintext 
użytkownicy mający 20 lat:
<br/>
<?php foreach ( $models->users->get_with_age(20) as $user ): ?>
nazwa użytkownika: <?php echo $user->username ?>, e-mail: <?php echo $user->email ?>
<br/>
<?php endforeach; ?>
[PHP] pobierz, plaintext 

Teraz to mi namieszaliście

Wg. Quantum'a do modelu odwołuję się w plikach template a wg. Crozin'a odwołuję się w osobnych klasach dla każdego widoku.

@Vielta: Quantum potraktował wartstwę widoku jako synonim szablonu, przez co utracił cały sens MVC - czyt.: to co podał nie ma zbyt wiele wspólnego w z MVC.

@Crozin jak to się ma do wytycznych tego postu Cysiaczka (patrz - Uwagi na koniec)

Pewnie tak, że powinno tam być: nie pytaj czy rozumiesz MVC - jeżeli wydaje Ci się, że tak jest, to pewnie nie masz racji (podobnie jak twórcy frameworków "mvc" dla PHP (notabede mimo iż z MVC mają tyle wspólnego co bla bla bla bla bla... i tak kilka projektów jest naprawdę dobrych).