Pattern Model-View-Controller (MVC), na natuklasan noong huling bahagi ng 1970s, ay isang pattern ng disenyo ng arkitektura software, ang pangunahing gawain kung saan ay upang paghiwalayin ang mga function ng pagtatrabaho sa data mula sa kanilang presentasyon. Sa teoryang, ang isang mahusay na idinisenyong MVC na application ay magbibigay-daan sa mga front-end at back-end na mga developer na hindi makagambala sa mga lugar ng responsibilidad ng isa't isa sa panahon ng kanilang trabaho, iyon ay, ang front-end na developer ay hindi kailangang malaman ang anumang bagay tungkol sa "kusina" ng kanyang back-end na kasamahan at vice versa.

Bagama't orihinal na idinisenyo ang MVC para sa pagbuo ng desktop application, inangkop ito para sa modernong mga gawain at napakapopular sa mga web developer, dahil dahil sa paghahati ng mga responsibilidad naging posible na lumikha ng isang mas malinaw, handa nang gamitin muling gamitin code. Ang pattern ng MVC ay nagreresulta sa malinis, modular na mga system na nagbibigay-daan sa mga developer na gumawa ng mga pagbabago sa umiiral nang code nang napakabilis.

Sa artikulong ito ay titingnan natin pangunahing mga prinsipyo MVC, simula sa pagtukoy ng isang pattern at patuloy na ilapat ito sa isang maliit na halimbawa. Ang artikulong ito ay pangunahing magiging kapaki-pakinabang sa mga hindi pa nakatagpo ng pattern na ito sa buhay, at gayundin, marahil, sa mga nais magsipilyo sa kanilang kaalaman sa MVC.

Pag-unawa sa MVC

Tulad ng nabanggit na, ang pangalan ng pattern ay nagmula sa isang pagdadaglat ng tatlong salita: Modelo (modelo), Tingnan At Controller. Sa madaling sabi, ang prinsipyo ng pagpapatakbo ng pattern ay maaaring ilarawan sa isang diagram (matatagpuan sa Wikipedia):

Malinaw na ipinapakita ng diagram na ito ang unidirectional na daloy ng impormasyon sa pattern at inilalarawan din ang mga tungkulin ng bawat bahagi.

Modelo

Ang modelo ay ginagamit upang i-access at manipulahin ang data. Sa karamihan ng mga kaso, ang modelo ay kung ano ang ginagamit upang ma-access ang data store (tulad ng isang database). Ang modelo ay nagbibigay ng isang interface para sa paghahanap ng data, paglikha nito, pagbabago nito, at pagtanggal nito mula sa imbakan. Sa konteksto ng pattern MVC model ay isang tagapamagitan sa pagitan ng view at ng controller.

Ang isang napakahalagang tampok ng isang modelo ay ang teknikal na walang kaalaman sa kung ano ang nangyayari sa data sa controller at view. Ang modelo ay hindi dapat gumawa o maghintay para sa anumang mga kahilingan sa/mula sa iba pang mga bahagi ng pattern.

Gayunpaman, laging tandaan na ang modelo ay hindi lamang isang gateway sa isang database o iba pang sistema na walang ginagawa kundi maglipat ng data pabalik-balik. Ang isang modelo ay parang gateway sa data. Ang modelo ay sa karamihan ng mga kaso ang pinaka-kumplikadong bahagi ng system, bahagyang dahil sa ang katunayan na ang modelo mismo ay ang link sa pagkonekta para sa lahat ng iba pang mga bahagi.

Pagganap

Ang view ay kung saan ang data na natanggap mula sa modelo ay output sa sa tamang anyo. Sa tradisyonal na mga web application na binuo gamit ang MVC pattern, ang view ay bahagi ng system kung saan nabuo ang HTML code. Responsable din ang view para sa pagtanggap ng mga aksyon mula sa user upang maipadala ang mga ito sa controller. Halimbawa, ang isang view ay nagpapakita ng isang button sa user interface, at pagkatapos ng pagpindot dito ay nagiging sanhi ng kaukulang aksyon ng controller.

Mayroong ilang mga maling kuru-kuro tungkol sa layunin ng isang view, lalo na sa mga web developer na nagsisimula pa lang bumuo ng kanilang mga application gamit ang MVC. Isa sa mga madalas na nasisira na panuntunan ay iyon ang view ay hindi dapat makipag-ugnayan sa modelo sa anumang paraan, at iyon lang ang data na natanggap ng view ay dapat lamang magmula sa controller. Sa pagsasagawa, madalas na binabalewala ng mga developer ang konseptong ito, na nasa core ng pattern ng MVC. Ang artikulo ni Fabio Cevasco ay naglalarawan ng nakakalito na diskarte na ito sa MVC gamit ang CakePHP, isa sa maraming hindi karaniwang mga framework ng MVC:

Napakahalagang maunawaan na upang makakuha ng wastong arkitektura ng MVC, hindi dapat magkaroon ng anumang direktang pakikipag-ugnayan sa pagitan ng mga view at modelo. Ang lahat ng lohika para sa pagpapalitan ng data sa pagitan ng mga ito ay dapat ipatupad sa mga controllers.

Bilang karagdagan, mayroong isang karaniwang maling kuru-kuro na ang isang view ay isang template file lamang. Tulad ng nabanggit ni Tom Butler, ang maling kuru-kuro na ito ay napakalaki dahil sa katotohanan na maraming mga developer ang hindi nauunawaan ang istraktura ng MVC mula pa sa simula, pagkatapos nito ay sinimulan nilang ibuhos ang "kaalaman" na ito nang higit pa sa masa ng mga baguhan na developer. Sa totoo lang, ang isang view ay higit pa sa isang template, ngunit maraming mga framework na binuo sa ibabaw ng MVC pattern ang nagdistort sa konsepto ng isang view kaya walang nagmamalasakit kung ang kanilang mga application ay tama sa mga tuntunin ng MVC pattern.

Gayundin mahalagang punto ay ang view ay hindi kailanman gumagana sa "purong" data mula sa controller, iyon ay, ang controller ay hindi kailanman gumagana sa view nang hindi nilalampasan ang modelo. Sa panahon ng pakikipag-ugnayan sa pagitan ng controller at ng view, ang modelo ay dapat palaging nasa pagitan nila.

Controller

Ang controller ay ang huling bahagi ng MVC bundle. Ang trabaho ng controller ay tumanggap ng data mula sa user at manipulahin ang modelo. Ito ang controller, at ito lamang, ang bahagi ng system na nakikipag-ugnayan sa user.

Sa madaling sabi, ang isang controller ay maaaring ilarawan bilang isang kolektor ng impormasyon na ipinapasa ito sa modelo para sa pagproseso at pag-iimbak. Hindi ito dapat gumawa ng anuman sa data, ngunit matanggap lamang ito mula sa gumagamit. Ang controller ay nauugnay sa isang view at isang modelo, kaya nag-aayos ng isang unidirectional na daloy ng data, na kinokontrol ito sa bawat yugto.

Napakahalagang tandaan na ang controller ay nagsisimula lamang sa trabaho nito bilang resulta ng pakikipag-ugnayan ng user sa view, na tumatawag sa kaukulang function ng controller. Ang pinakakaraniwang pagkakamali sa mga developer ay ang tingnan ang controller bilang isang gateway sa pagitan ng view at ng modelo. Bilang isang resulta, ang controller ay pinagkalooban ng mga function na dapat gawin ng view (nga pala, dito nagmula ang ideya na ang isang view ay isang template file lamang). Higit pa rito, maraming tao ang ganap na nagtatapon ng lahat ng lohika ng pagproseso ng data, na nakakalimutan kung bakit MVC pattern modelo ay inilaan.

MVC sa PHP

Iminumungkahi kong subukang ipatupad ang nasa itaas sa isang maliit na aplikasyon. Magsimula tayo sa pamamagitan ng paglikha ng mga klase ng modelo, view at controller:

string = "MVC + PHP = Galing!";) )

controller = $controller;

"; } } $ito->

" . $this->model->string ."

modelo = $modelo;

) )

Ang mga pangunahing klase ay handa na. Ngayon, iugnay natin ang mga ito nang sama-sama at patakbuhin ang aming aplikasyon:

output();Tulad ng nakikita mo, ang controller ay walang functionality dahil ang user ay hindi nakikipag-ugnayan sa application sa anumang paraan. Ang lahat ng pag-andar ay inilalagay sa view, dahil ang aming application ay inilaan lamang para sa pagpapakita ng data.

Palawakin natin ang application nang kaunti sa pamamagitan ng pagdaragdag ng ilang interaktibidad upang makita kung paano gumagana ang controller:

"; } } string = "MVC + PHP = Kahanga-hanga, mag-click dito!";

At sa wakas, bahagyang i-modernize natin ang connecting code:

($_GET["action"])(); ) echo $view->output();

Mga resulta

Sa maikling artikulong ito, tiningnan namin ang mga pangunahing konsepto ng pattern ng disenyo ng MVC at nakabuo kami ng isang simpleng aplikasyon batay dito, bagaman siyempre malayo pa ang paggamit namin nito sa totoong buhay. Sa susunod na artikulo, titingnan namin ang mga pangunahing paghihirap na makakaharap mo kung mas makikibahagi ka sa pagbuo ng isang arkitektura ng aplikasyon batay sa pattern ng MVC. Manatiling nakatutok!

Sa artikulong ito mauunawaan natin ang konsepto ng MVC, at kung paano, gamit ang isang halimbawa, mailalapat natin ito sa PHP.

Konsepto ng MVC

MVC(Model-view-controller, " Model-View-Gawi», « Model-View-Controller") ay isang pattern ng disenyo ng application kung saan ang control logic ay nahahati sa tatlong magkakahiwalay na bahagi kung kaya't ang pagbabago ng isa sa mga ito ay may kaunting epekto sa iba.

Ang template ng MVC ay magandang gamitin kapag gumagawa ng mga kumplikadong proyekto kung saan kinakailangang paghiwalayin ang gawain ng isang PHP programmer (o hatiin ang isang grupo ng mga programmer sa mga departamento), designer, layout designer, atbp.

Ang MVC pattern ay naghihiwalay sa pagtatanghal, data, at pagpoproseso ng pakikipag-ugnayan ng user sa tatlong magkakahiwalay na bahagi:

Modelo ng MVC(Modelo). Ang Modelo ay nagbibigay ng data (karaniwan ay sa View) at tumutugon din sa mga kahilingan (karaniwan ay mula sa Controller) sa pamamagitan ng pagbabago ng estado nito.

View ng MVC(Tingnan). Responsable para sa pagpapakita ng impormasyon (user interface).

Gawi ng MVC(Controller). Binibigyang-kahulugan ang input ng user at ipinaalam ang modelo at view upang tumugon nang naaayon.

Upang linawin ang action diagram ng MVC template, isang ilustrasyon ang ibinigay sa ibaba.

Ang mga bahagi tulad ng presentasyon at pag-uugali ay nakasalalay sa modelo, ngunit hindi ito nakakaapekto sa anumang paraan. Maaaring magkaroon ng maraming view ang isang modelo. Ang konsepto ng MVC ay maaaring mahirap unawain, ngunit kapag naunawaan mo na ito, ito ay magiging kailangang-kailangan sa pagbuo ng mga aplikasyon sa PHP.

MVC sa PHP

Ang isang espesyal na tampok kapag gumagamit ng MVC sa PHP ay mayroong isang entry point sa PHP application, na, halimbawa, ay nakakamit bilang mga sumusunod. Ang isang index.php ay nilikha kung saan ang lahat ng mga kahilingan ay ipoproseso Upang gawin ito, lumikha ng isang .htaccess file sa folder na may index at ilagay ang sumusunod na code dito.

RewriteEngine sa RewriteCond %(REQUEST_FILENAME) !-f RewriteCond %(REQUEST_FILENAME) !-d RewriteRule ^(.*)$ index.php?route=$1

Sa ibinigay na code, sinusuri ng unang linya ang pagkakaroon ng hiniling na file, at kung wala ito, ire-redirect ito sa index.php, kung hindi, kahit na ang mga kahilingan para sa mga imahe ng site ay ire-redirect sa index. Ang huling linya ng code ay nagko-convert ng mga kahilingan tulad ng index.php?route=chat/index sa index.php/chat/index. Kung wala kang kakayahang gumamit ng ModRewrite sa iyong aplikasyon, kakailanganin mong gawin ang pag-redirect nang manu-mano.

Modelo ng PHP

Ang data tungkol sa modelo ng PHP ay nakapaloob sa mga katangian nito at maaari lamang baguhin sa pamamagitan ng mga espesyal na function. Ang isang modelo ay maaaring maglaman ng ilang view. Bilang isang patakaran, ang isang phpmodel ay isang klase na gumagana sa isang database, mas partikular: pagsulat, pagbabasa, pagtanggal. Naturally, ang pagbabasa ng impormasyon mula sa database ay maaaring ipatupad ng ilang mga view (function). Bilang halimbawa, isang modelo ng mga artikulo sa isang website: maaari kang makakuha ng isang partikular na artikulo mula sa database, isang listahan ng pinakabago, sikat, ilang kategorya... lahat ito ay mga representasyon ng modelo. Para sa kalinawan, isang halimbawa ng isang modelo ng php ay ibinigay sa ibaba.

PHP controller (Gawi)

Ang mga controller ng PHP ay tumatanggap ng mga kahilingan ng user na ipinadala namin sa pamamagitan ng index.php, at alinsunod sa mga ito, ayusin ang pagpapatakbo ng modelo. Mas tamang sabihin na kinokontrol nila ang pagpapatakbo ng PHP application.

Kinatawan ng PHP

Sinusubaybayan ng view ang mga pagbabago sa modelo at lumilikha o nagbabago sa interface ng php application.

Listahan ng Data

unang pangalan ?>

apelyido?>

Paano ito gumagana?PHPMVC template?

Kapag na-access ng user ang kinakailangang url, pipiliin ang kaukulang controller, na nag-a-access sa view at modelo, at ipinapakita ang impormasyon. Sa madaling salita, ang controller sa mvc ay ang connecting link sa pagitan ng modelo at ng view.

Mga kalamangan ng isang MVC template kapag lumilikha ng isang PHP application

Tulad ng nabanggit sa itaas, ito ay, una sa lahat, ang pagkakaiba-iba ng mga developer ng PHP site sa mga departamento. Ang bilis ng PHP application ay tumataas din kung ang isang malaking proyekto ay nilikha. Well, ang direktang may kinalaman sa PHP developer mismo ay ang tamang structuring ng PHP code (lahat ay nasa lugar nito, kaya mas madaling maunawaan).

Halimbawa ng MVC

Hindi kami masyadong magtutuon ng pansin sa halimbawa kung paano gumagana ang MVC, dahil mayroon na kami ng isa pang diagram para sa mas malalim na pag-unawa.

Ang isa pang pamamaraan para sa kung paano gumagana ang isang MVC template sa PHP, ito ay higit pa sa madaling maunawaan.

Sa artikulong ito isusulat namin ang "balangkas" ng aming proyekto. Sa pamamagitan ng "framework" ang ibig kong sabihin ay gumaganang code na ibabatay sa diskarte ng MVC, iyon ay, magkakaroon ito ng malinaw na dibisyon ng lohika sa mga controller, aksyon, template (view) at mga modelo.

At kaya magsimula tayo, tulad ng isinulat ko na sa nakaraang artikulo, ang pattern ng MVC ay nagpapahiwatig ng isang entry point - index.php, lahat ng mga kahilingan ay dadaan sa script na ito, lahat ng lohika ng proyekto ay gagana sa pamamagitan nito. Upang maipatupad ang diskarteng ito, kinakailangan upang i-configure ang server, ipinapalagay na ang site ay tumatakbo sa Apache server, kaya kailangan lang naming lumikha ng isang .htaccess file kung saan tutukuyin namin ang mga panuntunan sa pagruruta ng URL. Bilang karagdagan sa pagtukoy sa entry point, binibigyang-daan ka ng pagruruta na lumikha ng mga CNC (mga URL na nababasa ng tao). Iyon ay, pagkatapos ng wastong pagsasaayos, ang mga address ng pahina ay magiging ganito: site.ru/article/new.
Una, gumawa tayo ng .htaccess, na magre-redirect sa pagpoproseso ng lahat ng page sa index.php script. Ang code ay ganito ang hitsura:

RewriteEngine sa RewriteCond %(REQUEST_FILENAME) !-f RewriteCond %(REQUEST_FILENAME) !-d RewriteRule ^(.*)$ index.php?route=$1

Ang .htaccess na file ay dapat na matatagpuan sa root folder ng site, at dapat kang gumawa kaagad ng index.php script, na siyang entry point. Sumulat tayo ng isang linya sa index.php upang subukan ang pag-redirect:

Echo "pagsubok";

Maaari mo na ngayong suriin ang pag-redirect, ilagay ang anumang address at tingnan kung ano ang mangyayari: test-mvc.web/sdf/sdf/ or test-mvc.web/sdf/sdf/2342/it doesn’t matter, in any case, “ Test ". Kung nakita mo ang inskripsyon na ito, nangangahulugan ito na nagtagumpay kami.
Magpatuloy tayo, para sa kaginhawahan, gumawa tayo ng config.php file sa ugat ng site, kung saan magtatakda tayo ng iba't ibang mga constant na magpapadali sa pag-configure ng site. Ang mga ito ay maaaring iba't ibang mga landas sa mga script, mga diskarte sa database, at iba pa. Ngayon sa config, itakda natin ang sumusunod:

// Itakda ang mga constants: define ("DS", DIRECTORY_SEPARATOR); // separator para sa mga path ng file $sitePath = realpath(dirname(__FILE__) . DS); define("SITE_PATH", $sitePath); // path sa root folder ng site // para kumonekta sa database define("DB_USER", "root"); define("DB_PASS", ""); define("DB_HOST", "localhost"); define("DB_NAME", "blog_mvc");

Upang magamit natin ang mga constant at iba pang data ng config sa buong proyekto, kailangan nating isama ang script ng config.php sa index.php file.
Bilang karagdagan sa pagkonekta sa file ng mga setting, sa index.php kailangan mong lumikha ng isang koneksyon sa database, ikonekta ang script sa core ng site at ilunsad ang router kung saan magaganap ang pagruruta.
Ngayon, sa pagkakasunud-sunod, ang paglikha ng koneksyon sa database ay nasa index.php upang ang koneksyon ay mabuksan nang isang beses lamang. Kapag nabuksan na namin ang koneksyon, magagamit namin ito sa lahat ng controller at modelo, ngunit higit pa doon sa ibang pagkakataon. Ngayon gumawa na lang tayo ng koneksyon sa database. Upang magtrabaho kasama ang database, nagpasya akong gumamit ng PDO. Maaari kang magbasa nang higit pa tungkol sa PDO.
Ilalagay namin ang core ng site sa core folder at tatawagin ang script core.php, dito magsusulat kami ng function na magkokonekta mismo, kailangan ng mga klase para gumana ito. Ang function na ito ay lubos na magpapadali at magpapasimple sa aming trabaho sa mga controller, modelo, atbp. Sapagkat, sa hinaharap, sasabihin ko na ang bawat controller at bawat modelo ay kumakatawan sa isang hiwalay na klase.
Bilang karagdagan sa awtomatikong pagkonekta ng mga klase, idaragdag namin sa core ang paglikha ng isang imbakan (registry), kung saan iimbak namin ang lahat ng kinakailangang bagay at variable na maaaring maging kapaki-pakinabang saanman sa proyekto.
Ikokonekta rin namin ang router sa index file, susuriin nito ang URL at ikonekta ang kinakailangang controller at aksyon. Sumulat ako tungkol sa kung ano ang isang controller sa isang nakaraang artikulo, at sinasadya kong tinanggal ang impormasyon tungkol sa aksyon, nang hindi naglo-load ito ng hindi kinakailangang impormasyon. Kaya ano ang aksyon?
Ang controller ay isang klase na naglalaman ng iba't ibang pamamaraan na may diskarte sa MVC, ang bawat pamamaraan ay magiging isang aksyon. Iyon ay, ang isang aksyon ay isang paraan ng klase na magpoproseso ng data at ililipat ito sa view (template). Maaaring hindi pa ito ganap na malinaw, ngunit pagkatapos ng halimbawa ang lahat ay mahuhulog sa lugar.
Sa yugtong ito, sapat na ang teorya, magpatuloy tayo sa pagsasanay. Ibibigay ko ang code ng mga file na ang operasyon ay inilarawan ko sa itaas.
Index.php script code:

// paganahin ang pagpapakita ng lahat ng error error_reporting (E_ALL); // ikonekta ang config kasama ("/config.php"); // Kumonekta sa database $dbObject = new PDO("mysql:host=" . DB_HOST . ";dbname=" . DB_NAME, DB_USER, DB_PASS); // ikonekta ang core ng site kasama ang (SITE_PATH . DS . "core" . DS . "core.php"); // I-load ang router $router = bagong Router ($registry); // magsulat ng data sa registry $registry->set ("router", $router); // itakda ang landas sa folder ng controllers. $router->setPath(SITE_PATH . "mga controllers"); //simulan ang router $router->start();

Core.php script:

// Naglo-load ng mga klase sa fly function __autoload($className) ($filename = strtolower($className) . ".php"; // tukuyin ang klase at hanapin ang path para dito $expArr = explode("_", $className ); if(empty($expArr) O $expArr == "Base")( $folder = "classes"; )else( switch(strtolower($expArr))( case "controller": $folder = "controllers"; break ; case "model": $folder = "models"; false; ) // isama ang file kasama ang klase ($ file ) // ilunsad ang registry (storage) $registry = new Registry;

Ang Registry.php storage class ay matatagpuan sa /classes/ folder

// Storage class Class Registry ( private $vars = array(); // data recording function set ($key, $var) ( if (isset ($this->vars[$key]) == true) ( ​​​​throw new Exception("Hindi maitakda ang var `" . $key . "`. Nakatakda na." ) $this->vars[$key] = $var return true; if (isset($this->vars[$key]) == false) ( return null; ) return $this->vars[$key] ) // alisin ang data function remove($var) ( unset($ this ->vars[$key]);

Code ng router.php file, na matatagpuan sa /classes/ folder

// klase ng router Class Router ( pribadong $registry; pribadong $path; pribadong $args = array(); // kunin ang storage function na __construct($registry) ($this->registry = $registry; ) // itakda ang landas sa folder na may controllers function setPath($path) ($path = trim($path, "/\\"); $path .= DS; // kung wala ang path, isenyas ito kung (is_dir($path ) == false ) ( throw new Exception ( "Invalid controller path: `" . $path . "`"); ) $this->path = $path ) // pagtukoy sa controller at aksyon mula sa URL private function getController( &$file, & $controller, &$action, &$args) ($route = (empty($_GET["ruta"])) ? "" : $_GET["ruta"]; unset($_GET[" ruta"]); if (empty($route)) ($route = "index"; ) // Kumuha ng mga bahagi ng URL $route = trim($route, "/\\"); $parts = explode(" /", $route); // Hanapin ang controller $cmd_path = $this->path; foreach ($parts as $part) ($fullpath = $cmd_path . $part; // Suriin kung umiiral ang folder kung (is_dir( $fullpath)) ($cmd_path .= $part . DS; array_shift($parts);

magpatuloy;
) // Hanapin ang file kung (is_file ($fullpath . ".php")) ( $controller = $part; array_shift($parts); break; ) ) // kung ang URL ay hindi tumutukoy ng controller, pagkatapos ay gamitin ang default na index kung (walang laman ($controller)) ( $controller = "index"; ) // Kunin ang aksyon $action = array_shift($parts);

// Controller Class Controller_Index Extends Controller_Base ( // template public $layouts = "first_layouts"; // action function index() ($model = bagong Model_Users(); $userInfo = $model->getUser(); $this-> template->vars("userInfo", $userInfo); $this->template->view("index") )

Para sa display(/views/index/index.php)

Pansubok na view
id:
pangalan:

At ang modelo:

// model Class Model_Users( public function getUser())( return array("id" =>1, "name" =>"test_name"); ) )

Tulad ng maaaring napansin mo, nagmamana ang controller class mula sa parent class na Controller_Base. Ginagawa ito upang gawing simple ang klase ng controller. Dahil kailangan pa nating ikonekta ang klase upang gumana sa mga template, inilalagay ang koneksyon nito sa Controller_Base.
Ibibigay ko ang code nito, ito ay matatagpuan sa /classes/ folder at tinatawag na controller_base.php:

// abstract controller class Abstract Class Controller_Base ( protected $registry; protected $template; protected $layouts; // template public $vars = array(); // ikonekta ang mga template sa constructor function __construct($registry) ($this-> registry = $registry; // templates $this->template = new Template($this->layouts, get_class($this));

Ngayon ang natitira na lang ay upang malaman ang mga template. Sa abstract na klase na Controller_Base, tinatawagan namin ang klase ng Template at ipinapasa dito ang pangalan ng template at ang pangalan ng controller.
Ang code para sa klase ng Template, na matatagpuan dito /classes/ at tinatawag na template.php

// class para sa pagkonekta ng mga template at pagpasa ng data sa display Class Template ( private $template; private $controller; private $layouts; private $vars = array(); function __construct($layouts, $controllerName) ($this->layouts = $layouts; $arr = explode("_", $controllerName); $this->controller = strtolower($arr); ( $this->vars[$varname]) == true) ( ​​​​trigger_error ("Hindi maitakda ang var `" . $varname . "`. Nakatakda na, at hindi pinapayagan ang pag-overwrite.", E_USER_NOTICE); return false; ) $this ->vars[$varname] = $value; return true; ) // display function view($name) ( $pathLayout = SITE_PATH . "views" . DS . "layouts" . DS . $this->layouts . ". php"; $contentPage = SITE_PATH . " . $ this->layouts . "` does not exist.", E_USER_NOTICE); return false; if (file_exists($contentPage) == false) ( trigger_error ("Template `" . $pangalan . "` ay wala.", E_USER_NOTICE);

ibalik ang mali;
) foreach ($this->vars as $key => $value) ($$key = $value; ) isama ($pathLayout);

) )

Kung maingat mong basahin ang code, malamang na napagtanto mo na para sa pagpapakita sa mga pahina ay ginagamit namin ang first_layouts na template at ang view (display) index.php - Ibinigay ko ang code nito nang medyo mas mataas. Ang natitira na lang namin ay lumikha ng first_layouts template file. Ilagay natin ito sa /views/layouts/first_layouts.php folder

Maglalaman ang template ng sumusunod na code:
header

footer Iyon lang, nakumpleto nito ang paglikha ng "balangkas". Ngayon ay mayroon na tayong pinakasimpleng istraktura batay sa pattern ng MVC. Sa artikulong ito ay hindi ko hinawakan ang pagtatrabaho sa database, binanggit ko lang ito sa pagpasa, dahil ang artikulo ay mahaba na. Ilalarawan ko ang pagtatrabaho sa database nang direkta sa susunod na artikulo. Tapos na ang artikulong ito, maaari mong i-download ang mga source file sa archive. Sa pattern" Modelo - View - Controller

Ang view ay isang visual na representasyon ng data na nasa isang modelo Ang isang subset ng modelo ay nasa isang hiwalay na view, kaya ang view ay nagsisilbing filter para sa data ng modelo. Nakikipag-ugnayan ang user sa data ng modelo gamit ang visual na display na inaalok ng view at ina-access ang logic ng negosyo, na, sa turn, ay nakakaapekto sa data ng modelo.

Ikinokonekta ng controller ang view sa modelo at pinamamahalaan ang daloy ng data ng application. Pinipili nito kung aling view ang ire-render sa user bilang tugon sa input ng user at ayon sa business logic na isinasagawa. Natatanggap ng controller ang mensahe mula sa view at ipinapasa ito sa modelo. Ang modelo, sa turn, ay naghahanda ng tugon at nagpapadala ng ero pabalik sa controller, kung saan ang view ay pinili at ang ero ay ipinadala sa user.

MVC pattern lohikal na sumasaklaw sa kliyente at gitnang layer ng isang multi-tier na arkitektura. Sa kapaligiran ng Java, ang modelo ng EE ay matatagpuan sa layer ng negosyo, kadalasan sa anyo ng isang EJB module.

Ang controller at view ay matatagpuan sa web layer. Ang view ay malamang na malilikha mula sa Mga Mukha ng JavaServer(JSF) o Mga Pahina ng JavaServer(JSP) gamit ang Expression Language (EL). Ang controller ay karaniwang isang servlet na tumatanggap ng mga kahilingan sa HTTP mula sa user.

Ang MVC ay madalas na pinagsama sa iba pang mga pattern gaya ng Command (o Action), Strategy, Composer, at " ".

Ang pattern na ito ay unang binanggit bago ang paglikha ng Internet sa modernong anyo nito, sa isang artikulong inilathala noong Disyembre 1979 ni Trygve Reenskaug, isang programmer noon ay nagtatrabaho sa Xeror SmallTalk.

At kahit na ang mga elemento ng MVC ng pattern na ito ay inilarawan higit sa 35 taon na ang nakakaraan, nakakagulat na malapit silang tumutugma sa kanilang modernong paggamit sa mga web application.

Ang sumusunod na figure ay nagpapakita ng isang user na humihiling sa isang controller. Pinoproseso ng controller ang kahilingan sa pamamagitan ng pag-update ng modelo at pag-render ng bagong view, na pagkatapos ay ipapadala sa user.

Diagram ng Pattern ng MVC

MVC pattern umiiral sa maraming iba't ibang anyo. Ang dalawang pinakasikat ay karaniwang tinatawag uri I At uri II.

Mga uri ng pattern ng MVC:

• Uri ng MVC I. Ang uri na ito ay isang page-centric na diskarte kung saan umiiral ang view at controller bilang isang entity na tinatawag na view-controller. Sa ganitong diskarte, ang controller logic ay ipinatupad sa isang view tulad ng JSF. Ang lahat ng gawaing ginagawa ng controller, kabilang ang pagkuha ng HTTP request attributes at parameters, pagtawag sa business logic, at pamamahala sa HTTP session, ay binuo sa view gamit ang mga scriptlet at tag library. Mahigpit na pinagsama ng Type I ang pagbuo ng view sa pagkakasunud-sunod ng mga aksyon na isinagawa ng application, sa gayon ay nagiging mahirap ang pagpapanatili.
• Uri ng MVC II. Ang mga isyu sa maintainability ng Type I ay nagtagumpay sa Type II sa pamamagitan ng paglipat ng controller logic sa labas ng view at sa servlet, na iniiwan ang data visualization sa view.

Ang pangunahing pagkakaiba sa pagitan ng Type I at Type II ay ang lokasyon ng controller logic: sa Type I ito ay nasa view, at sa Type II ito ay nasa servlet.

Maraming mga balangkas tulad ng Spring MVC, Struts, Grails At Wicket, ipatupad ang kanilang sariling bersyon ng pattern ng MVC Type II. Halimbawa, Spring MVC kasama ang konsepto ng isang dispatcher servlet na nakikipag-ugnayan sa mga kahilingan sa HTTP at nagsasagawa ng delegasyon sa controller, at naglalaman din ng view (at view resolver) at mga handler.

Ang sumusunod na figure ay nagpapakita ng isang diagram ng pagpapatupad ng pattern ng MVC sa Spring.

Diagram ng pagpapatupad ng pattern ng MVC sa Spring

Bagama't ang kahulugan ng pariralang "site architecture" ay maaaring maging intuitive para sa iyo, subukan nating mag-aral isang bilang ng mga kahulugan mula sa mga makapangyarihang mapagkukunan.

Arkitektura- ito ang pangunahing organisasyon ng system, na nakapaloob sa mga bahagi nito, ang kanilang mga relasyon sa isa't isa at sa kapaligiran, pati na rin ang mga prinsipyo na tumutukoy sa disenyo at pag-unlad ng system.

Arkitektura ang programa o sistema ng kompyuter ay ang istruktura o istruktura ng isang sistema na kinabibilangan ng mga elemento ng programa, ang mga panlabas na nakikitang katangian ng mga elementong ito, at ang mga ugnayan sa pagitan ng mga ito [Bass].

Arkitektura ay ang istraktura ng organisasyon at ang pag-uugali ng sistemang nauugnay dito. Ang isang arkitektura ay maaaring recursively decomposed sa mga bahagi na nakikipag-ugnayan sa pamamagitan ng mga interface, mga koneksyon na nagkokonekta sa mga bahagi, at mga kondisyon para sa pag-assemble ng mga bahagi. Ang mga bahagi na nakikipag-ugnayan sa pamamagitan ng mga interface ay kinabibilangan ng mga klase, bahagi, at subsystem.

Arkitektura Ang isang software system o hanay ng mga system ay binubuo ng lahat ng mahahalagang desisyon sa disenyo tungkol sa mga istruktura ng programa at ang mga pakikipag-ugnayan sa pagitan ng mga istrukturang iyon na bumubuo sa mga system. Ang mga desisyon sa disenyo ay nagbibigay ng gustong hanay ng mga katangian na dapat suportahan ng isang system upang maging matagumpay. Ang mga solusyon sa disenyo ay nagbibigay ng konseptong batayan para sa pagbuo, suporta, at pagpapanatili ng system.

Kaya ano ang arkitektura ng programa?

Ang mga kahulugan na ibinigay sa nakaraang seksyon ay masyadong tuyo para sa hindi handang mambabasa na maunawaan. Susubukan naming ipaliwanag ang kakanyahan nang simple hangga't maaari.

Kapag ang isang programa ay naging sapat na malaki, hinati ito ng programmer sa ilang mga file. Kung hindi mo iniisip ang tungkol sa pagtukoy ng mga grupo ng mga katulad na pag-andar at paglalagay ng mga ito sa magkahiwalay na mga module, ang gayong dibisyon ay hindi gaanong magagamit. Ang code ay hindi magagamit muli at magiging mahirap i-navigate. Ang programa ay magiging mahirap palawakin at baguhin.

Kaya, ang unang tanong ay lumitaw: kung paano hatiin ang programa sa mga file. Ang arkitektura ng file ng isang programa ay isang aspeto ng istraktura nito.

Kapag tinutukoy ang mga module ng system, kinakailangan na maunawaan ang kaugnayan sa isa't isa na kanilang papasukan. Halimbawa, ang pag-access sa database at mga module sa pagpoproseso ng graphics ay malamang na hindi alam ang anumang bagay tungkol sa pagkakaroon ng isa't isa. Ngunit malalaman ng module ng UI ang tungkol sa kanilang dalawa (at hindi nila malalaman ang tungkol dito).

Ang mga ugnayan sa pagitan ng mga bahagi ng system ay tinutukoy din ng arkitektura nito.

Sa pangkalahatan, ang lahat ng makabuluhang desisyon na naglalayong ayusin ang programa, at hindi sa mga problemang nalutas sa tulong nito, ay maaaring maiugnay sa arkitektura.

Mga Antas ng Abstraction

Kapag nagdidisenyo ng mga module (pagpili ng mga pangkat ng mga function at pamamahagi ng mga ito sa mga file sa kaso ng isang pamamaraang pamamaraan), mahalagang i-highlight ang mga abstraction at subukang i-decompose ang mga ito sa ilang mga antas.

Ang mga low-level na module ay nagsasarili hangga't maaari; hindi sila umaasa sa ibang bahagi ng programa. Ibinubukod ng mahusay na disenyong mga module ang "labas na mundo" mula sa masalimuot na paglutas ng problemang itinalaga sa kanila. Alam lamang ng tumatawag na partido ang interface ng module (mga panlabas na pag-andar), ang panloob na bahagi ay sarado dito.

Kunin natin ang isang photo gallery bilang isang halimbawa. Ang impormasyon tungkol sa mga larawan at mga user ay naka-imbak sa isang database, ang user interface ay nahahati sa isang bahagi ng kliyente at isang admin panel.

Ang istraktura ng programa ay maaaring maging tulad ng figure sa ibaba:

Ang halimbawang ito ay bakas tatlong antas ng abstraction.

Sa anumang programa na nilayon para sa paggamit ng tao, mayroong hindi bababa sa dalawang antas: ang user interface at ang modelo. Ang module ng user interface ay idinisenyo upang ipakita at mailarawan ang data at iproseso ang mga reaksyon ng user. Ang modelo ay naglalaman ng lohika ng problemang nilulutas at hindi dapat umasa sa paraan kung paano ipinapakita ang data. Ang modelo ay dapat na madaling madala sa pagitan ng iba't ibang uri ng user interface.

Arkitektura ng MVC

Sikat ngayon Pattern ng disenyo ng MVC. Nagsisilbi itong paghiwalayin ang logic ng application mula sa user interface. Ngunit una, linawin natin kung ano ang isang pattern ng disenyo.

Ito ay isang hanay ng mga karaniwang solusyon sa disenyo, isang balangkas ng arkitektura o fragment nito. Kung ang isang library ay isang pakete ng reusable code, ang pattern ng disenyo ay isang pakete ng mga reusable na solusyon.

Ano ang inaalok sa amin ng MVC upang paghiwalayin ang logic ng application mula sa interface ng gumagamit?

Sample Pinapayagan ka ng MVC na maghiwalay data, presentasyon at pagproseso ng mga aksyon ng user sa tatlong magkakahiwalay na bahagi:

1. Modelo. Ang Modelo ay nagbibigay ng data (karaniwan ay sa View) at tumutugon din sa mga kahilingan (karaniwan ay mula sa Controller) sa pamamagitan ng pagbabago ng estado nito;
2. Tingnan. Responsable para sa pagpapakita ng impormasyon (user interface);
3. Controller. Nagbibigay-kahulugan sa input ng user at nagpapaalam sa modelo at view upang tumugon nang naaangkop.

Ipinapakita ng figure sa ibaba ang mga ugnayan sa pagitan ng mga bahagi ng balangkas. Ilarawan natin ang pigura sa isang maliit na halimbawa.

Isipin ang isang form kung saan maaari kang maglagay ng teksto, i-click ang pindutang I-edit at kunin ang transliterasyon nito:

Ulitin natin ang mga hakbang na ipinapakita sa diagram:

1. Pinindot ng user ang Edit button at Pagganap(View) ay nagpapadala ng mensahe Sa controller(Controller): "Utos: i-edit"
2. Tinatanggap ng controller mensahe at ina-access ang Modelo sa pamamagitan ng pagtawag sa Edit() na paraan.
3. Bilang resulta nagbabago ang modelo estado nito (naka-transliterate na text na naka-imbak dito) at inaabisuhan ang view tungkol dito: "Kaganapan: nagbago".
4. Tumatanggap ang pagsusumite signal at nakikipag-ugnayan sa modelo para sa isang bagong halaga ng resulta sa pamamagitan ng pagtawag sa pamamaraang Get() nito.

Pagpapatupad ng MVC

Ipinapalagay ng pagpapatupad ng MVC ang isang object-oriented approach (OOP). Gayunpaman, ang isang pattern ng disenyo ay isang hanay lamang ng mga solusyon. Ibagay natin ang mga ito para sa PHP nang hindi gumagamit ng OOP. Ginagawa ang pagpapasimple upang makapag-concentrate sa kakanyahan ng paghihiwalay ng lohika, at upang ang materyal ay mailapat ng isang mambabasa na hindi pamilyar sa OOP.

Tingnan natin muli halimbawa sa isang photo gallery.
Mayroon itong dalawang mode ng pagtingin:

1. Mode para sa pagtingin ng mga thumbnail na larawan (sabay-sabay);
2. Mode para sa pagtingin sa isang buong laki ng larawan (isa).

Pwede rin naman mag-upload ng mga larawan sa server. Bukod pa rito, ipapatupad namin ang suporta para sa mga uri ng visualization upang suriin ang flexibility ng framework.

magkakaroon dalawang entry point:

1. index.php(gallery view);
2. photo.php (tingnan ang buong laki ng larawan).

Isasaalang-alang namin ang dalawang file na ito Mga Controller.

Bilang Mga modelo ay magiging isang module na nagbibigay ng trabaho na may imbakan ng imahe. Tawagan natin siya gallery.php at ilagay ito sa isang folder modelo.

Sa papel Mga pagsusumite Lilitaw ang mga template ng HTML, matatagpuan ang mga ito sa folder mga template. Kung ano ang mga template at kung ano ang kailangan ng mga ito ay makikita sa ibang pagkakataon.

Ang view ng gallery at mga page ng view ng larawan ay magkakaroon ng isang karaniwang header at footer lamang ang magkakaiba.

Ang view ng gallery ay magkakaroon ng dalawang uri ng visualization:

1. Bilang isang talahanayan (default);
2. Sa anyo ng isang listahan.

Kakailanganin namin ang apat na template:

1. main.php(balangkas ng pahina);
2. content_index_table.php (tabular view ng nilalaman ng gallery);
3. content_index_list.php (listahan ng view ng nilalaman ng gallery);
4. content_photo.php (nilalaman ng page ng view ng larawan).

Nagreresulta ito sa sumusunod na istraktura ng site:

Ang istraktura ng file ay nahahati sa dalawang pahalang na bar, na lumilikha ng tatlong mga seksyon. Ang mga file sa itaas na seksyon ay nabibilang sa Modelo, ang mga file sa gitnang seksyon sa View, at ang mga file sa ibabang seksyon ay nasa Controller.

Modelo

Magsimula tayo sa pagpapatupad ng Modelo. Ang code sa ibaba ay hindi ipinapakita nang buo para sa minimization at mas mahusay na kalinawan ng halimbawa.

Tinukoy lang namin ang interface ng Model, na iniiwan ang pagpapatupad na nawawala. Gayunpaman, para sa halimbawa ng pagpapatupad ng balangkas ng MVC hindi ito kailangan.

Pagganap

Ngayon tingnan natin ang mga template. Magsimula tayo sa pangkalahatang balangkas ng pahina:

Hindi ka dapat malito sa katotohanan na ang template ay gumagamit ng mga variable na $title at $content na walang pinanggalingan. Ise-set up sila ng Controller. Ngunit higit pa sa na mamaya.

- ito ay isang pinaikling bersyon ng notasyon .

Ito ay maginhawang gamitin sa mga template. Ito rin ay mas maginhawang gumamit ng mga alternatibong opsyon para sa pagsusulat ng if-else, foreach, for, at while constructs sa mga template. Ganito ang hitsura nila:

kung (<условие>): <тело>endif; foreach(<инициализация цикла>): <тело>endforeach;

Ang natitirang mga template ay ipapasok sa main.php tulad nito:

Ang mga halimbawa sa ibaba ay nagpapakita ng kanilang code:

Mga template ng code/content_index_table.php

mesa| Listahan

"> " />

Mga template ng code/content_index_list.php

Talahanayan | Listahan

"> " />

templates/content_photo.php: Bumalik

" />

Controller

At sa wakas, pagsama-samahin natin ang lahat sa pamamagitan ng paglalarawan sa ating dalawang Controller. Ang kanilang gawain ay iproseso ang kahilingan, pumili ng template at palitan ang data na kinakailangan para sa template. Karaniwang kinukuha ang data mula sa modelo.

Nilo-load ng controller ng gallery ang larawan kung nagsumite ng file ang user. Kung hindi, kinukuha nito ang isang listahan ng mga larawan mula sa modelo, pinipili ang nais na template (depende sa pagnanais ng gumagamit) at ipinapakita ang template na ito, na nagpapasa dito ng isang listahan ng mga larawan:

Code index.php

Ang photo view controller ay mas simple:

Code photo.php

Sa konklusyon

Subukang magbayad ng sapat na pansin sa pagbuo ng arkitektura ng iyong aplikasyon. Kung lumikha ka ng isang malakas at napapalawak na frame sa simula, magbubunga ang pagsisikap daan-daang beses.

Upang ipatupad ang modelo ng MVC, mas mahusay na pumili object-oriented na diskarte .

Maraming mga handa na solusyon sa framework, halimbawa sa Zend Framework. Gayunpaman, ang impormasyong ipinakita sa kasalukuyang aralin ay sapat na upang maunawaan ang mga solusyon sa arkitektura ng MVC at simulang gamitin ang mga ito ngayon.