Ano ang pattern ng disenyo ng MVC sa Java? MVC: ano ito at ano ang kinalaman nito sa user interface

Pattern ng Disenyo Model-View-Controller (MVC) ay isang template arkitektura ng software, binuo sa paligid ng pagpapanatiling hiwalay ang representasyon ng data mula sa mga pamamaraan na nakikipag-ugnayan sa data.

Kahit na ang MVC ay orihinal na idinisenyo para sa mga personal na computer, ito ay pinagtibay at malawakang ginagamit ng mga web developer dahil sa tumpak nitong paghihiwalay ng mga gawain at muling paggamit ng code. Hinihikayat ng scheme ang pagbuo ng mga modular system, na nagbibigay-daan sa mga developer na mabilis na mag-update, magdagdag o mag-alis ng functionality.

Sa artikulong ito ay ilalarawan ko ang mga pangunahing prinsipyo, pati na rin tingnan ang kahulugan ng isang scheme ng konstruksiyon at isang simpleng halimbawa ng MVC PHP.

Ano ang MVC

Ang pangalan ng isang pattern ng disenyo ay tinutukoy ng tatlong pangunahing bahagi nito: Model, View at Controller. Visual na representasyon Ang template ng MVC ay mukhang ipinapakita sa ang diagram sa ibaba:

Ipinapakita ng figure ang istraktura ng isang one-way na daloy ng data at ang landas nito sa pagitan iba't ibang sangkap, pati na rin ang kanilang pakikipag-ugnayan.

Modelo

Ang isang modelo ay isang permanenteng imbakan ng data na ginagamit sa buong istraktura. Dapat itong magbigay ng access sa data para sa pagtingin, pagpili o pag-record. SA pangkalahatang istraktura Ang "Model" ay ang tulay sa pagitan ng mga bahagi ng "View" at "Controller".

Gayunpaman, ang "Modelo" ay walang koneksyon o impormasyon tungkol sa kung ano ang mangyayari sa data kapag ipinasa ito sa mga bahagi ng "View" o "Controller". Ang tanging gawain ng "Modelo" ay iproseso ang data sa patuloy na imbakan, maghanap at maghanda ng data na inilipat sa iba pang bahagi ng MVC.

Ang "modelo" ay dapat kumilos bilang isang "gatekeeper", nakatayo malapit sa data warehouse at hindi nagtatanong, ngunit tinatanggap ang lahat ng mga papasok na kahilingan. Ito ang madalas na pinakamasalimuot na bahagi ng isang MVC system. Ang bahagi ng "Modelo" ay ang tuktok ng buong istraktura, dahil kung wala ito ang koneksyon sa pagitan ng "Controller" at ang "View" ay imposible.

Pagganap

Ang View ay ang bahagi ng system kung saan ang data na hiniling mula sa Modelo ay binibigyan ng panghuling anyo ng output nito. Sa mga web application na binuo sa MVC, ang "View" ay ang bahagi kung saan nabuo at ipinapakita ang HTML code.

Hinaharang din ng View ang pagkilos ng user, na pagkatapos ay ipapasa sa "Controller". Ang karaniwang halimbawa nito ay ang button na nabuo ng "View". Kapag na-click ito ng user, ma-trigger ang isang aksyon sa "Controller."

Mayroong ilang mga karaniwang maling kuru-kuro tungkol sa bahagi ng View. Halimbawa, maraming tao ang nagkakamali na naniniwala na ang "View" ay walang koneksyon sa "Modelo", at lahat ng ipinapakitang data ay inililipat mula sa "Controller". Sa katotohanan, ang diagram ng daloy ng data na ito ay hindi isinasaalang-alang ang teorya sa likod ng arkitektura ng MVC. Sa kanyang artikulo, inilalarawan ni Fabio Cevasco ang maling diskarte na ito gamit ang halimbawa ng isa sa mga hindi tradisyonal na MVC PHP frameworks:

"Upang maayos na mailapat ang arkitektura ng MVC, dapat na walang pakikipag-ugnayan sa pagitan ng Modelo at ng View: ang lahat ng lohika ay pinangangasiwaan ng Controller."

Bilang karagdagan, ang kahulugan ng "View" bilang isang template file ay hindi rin tumpak. Ngunit hindi ito kasalanan ng isang tao, ngunit resulta ng maraming pagkakamali iba't ibang mga developer na humahantong sa pangkalahatang maling kuru-kuro. Pagkatapos ay mali nilang ipinaliwanag ito sa iba. Sa katunayan, ang "View" ay higit pa sa isang template. Ngunit ang mga modernong MVC-oriented na frameworks ay nakuha ang diskarte na ito sa isang lawak na walang nagmamalasakit kung ang tamang istraktura ng MVC ay suportado o hindi.

Ang bahagi ng View ay hindi kailanman direktang ipinapasa ng data ng Controller. Walang direktang koneksyon sa pagitan ng "View" at "Controller" - sila ay konektado gamit ang "Modelo".

Controller

Ang gawain nito ay iproseso ang data na ipinasok ng user at i-update ang "Modelo". Ito ang tanging bahagi ng diagram na nangangailangan ng pakikipag-ugnayan ng user.

Ang "Controller" ay maaaring tukuyin bilang isang kolektor ng impormasyon, na pagkatapos ay ililipat sa "Modelo" at pagkatapos ay inayos para sa imbakan. Wala itong ibang lohika maliban sa pangangailangang mangolekta ng papasok na data. Ang "Controller" ay kumokonekta din sa isang "View" at isang "Model". Lumilikha ito ng one-way na data flow system na may isang input at isang output sa mga punto ng komunikasyon.

Ang Controller ay tumatanggap ng mga gawain na isasagawa lamang kapag ang user ay nakipag-ugnayan sa View, at ang bawat function ay nakadepende sa pakikipag-ugnayan ng user sa View. Ang pinakakaraniwang pagkakamali na ginagawa ng mga developer ay nalilito nila ang Controller sa Gateway, kaya itinalaga nila ito ng mga function at gawain na kabilang sa View.

Ang isa pang karaniwang pagkakamali ay ang pagbibigay sa "Controller" ng mga function na responsable lamang sa pagproseso at paglilipat ng data mula sa "Model" patungo sa "View". Ngunit ayon sa istraktura ng pattern ng MVC, ang pakikipag-ugnayan na ito ay dapat isagawa sa pagitan ng "Model" at ng "View".

MVC sa PHP

Sumulat tayo ng isang web application sa PHP, ang arkitektura nito ay batay sa MVC. Magsimula tayo sa isang halimbawa ng wireframe:

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

controller = $controller;

"; } } $this->model = $model;

) pampublikong function na output() ( ibalik "

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

modelo = $modelo;

) )

Mayroon kaming proyekto na may ilang pangunahing klase para sa bawat bahagi ng template. Ngayon ay kailangan mong i-configure ang relasyon sa pagitan nila:output();

Sa halimbawa ng PHP MVC sa itaas, walang partikular na functionality para sa controller dahil hindi tinutukoy ng application ang mga pakikipag-ugnayan ng user. Ang view ay naglalaman ng lahat ng pag-andar, dahil ang aming halimbawa ay inilaan para sa mga layunin ng pagpapakita lamang.

"; } } Palawakin natin ang halimbawa upang ipakita kung paano tayo magdaragdag ng functionality ng controller, sa gayon ay nagdaragdag ng pakikipag-ugnayan sa application:

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

) )

controller = $controller;

$this->model = $model; ) pampublikong function na output() ( ibalik " modelo->string . "

Ang konsepto ng MVC (Model-View-Controller) ay madalas na binanggit sa mundo ng web programming nitong mga nakaraang taon. Ang bawat isa na sa anumang paraan ay konektado sa pagbuo ng web application ay nakatagpo ng acronym na ito sa isang paraan o iba pa. Ngayon ay mauunawaan natin kung ano ang konsepto ng MVC at kung bakit ito naging tanyag.

Sinaunang kasaysayan

Ang MVC ay hindi isang pattern ng proyekto, ito ay isang pattern ng disenyo na naglalarawan kung paano bumuo ng istraktura ng aming aplikasyon, ang mga responsibilidad at pakikipag-ugnayan ng bawat isa sa mga bahagi sa istrukturang ito.

Una itong inilarawan noong 1979, siyempre, para sa ibang kapaligiran. Walang konsepto ng web application noon. Inihasik ni Tim Berners Lee ang mga buto ng World Wide Web (WWW) noong unang bahagi ng nineties at binago ang mundo magpakailanman. Ang template na ginagamit namin ngayon ay isang adaptasyon ng orihinal na template para sa web development.

Ang pagiging popular ng istrukturang ito sa mga web application ay dahil sa pagsasama nito sa dalawang development environment na naging napakasikat: Struts at Ruby on Rails. Ang dalawang development environment na ito ay nagtatakda ng landas para sa daan-daang development environment na ginawa mamaya.

MVC para sa mga web application

Ang ideya sa likod ng pattern ng disenyo ng MVC ay napaka-simple: kailangan naming malinaw na paghiwalayin ang mga responsibilidad para sa iba't ibang paggana sa aming mga application:

Ang application ay nahahati sa tatlong pangunahing bahagi, ang bawat isa ay may pananagutan para sa iba't ibang mga gawain. Tingnan natin ang mga bahagi nang detalyado gamit ang isang halimbawa.

Controller

Pinamamahalaan ng controller ang mga kahilingan ng user (natatanggap bilang HTTP GET o POST na mga kahilingan kapag nag-click ang user sa mga elemento ng interface upang magsagawa ng iba't ibang aksyon). Ang pangunahing pag-andar nito ay ang tumawag at mag-coordinate ng aksyon ng mga kinakailangang mapagkukunan at mga bagay na kailangan upang maisagawa ang mga aksyon na tinukoy ng user. Kadalasan, tinatawag ng controller ang naaangkop na modelo para sa gawain at pinipili ang naaangkop na view.

Modelo

Ang isang modelo ay ang data at mga panuntunan na ginagamit upang gumana sa data na kumakatawan sa konsepto para sa pagkontrol ng isang application. Sa anumang aplikasyon, ang buong istraktura ay na-modelo bilang data na pinoproseso sa isang tiyak na paraan. Ano ang user para sa isang application - mensahe o libro? Ang data lang na dapat iproseso ayon sa mga panuntunan (ang petsa ay hindi maaaring tumuro sa hinaharap, ang email ay dapat nasa isang partikular na format, ang pangalan ay hindi maaaring mas mahaba kaysa sa X na mga character, at iba pa).

Ang modelo ay nagbibigay sa controller ng representasyon ng data na hiniling ng user (mensahe, pahina ng libro, photo album, atbp.). Magiging pareho ang modelo ng data kahit paano natin ito gustong ipakita sa user. Samakatuwid, pipili kami ng anumang available na view upang ipakita ang data.

Ang modelo ay naglalaman ng pinakamahalagang bahagi ng lohika ng aming aplikasyon, ang lohika na lumulutas sa problemang kinakaharap namin (forum, tindahan, bangko, atbp.). Ang controller ay karaniwang naglalaman ng lohika ng organisasyon para sa application mismo (katulad ng housekeeping).

Tingnan

Ang isang view ay nagbibigay ng iba't ibang paraan ng pagkatawan sa data na nakuha mula sa modelo. Maaari itong maging isang template na puno ng data. Maaaring may ilang iba't ibang uri, at pinipili ng controller kung alin ang pinakaangkop para sa kasalukuyang sitwasyon.

Ang isang web application ay karaniwang binubuo ng isang hanay ng mga controller, modelo, at view. Ang isang controller ay maaaring idisenyo bilang isang pangunahing controller na tumatanggap ng lahat ng mga kahilingan at tumatawag sa iba pang mga controller upang magsagawa ng mga aksyon depende sa sitwasyon.

Tingnan natin ang isang halimbawa

Sabihin nating kailangan nating bumuo ng online bookstore. Maaaring gawin ng user ang mga sumusunod na aksyon: tingnan ang mga aklat, magparehistro, bumili, magdagdag ng mga item sa kasalukuyang order, lumikha o magtanggal ng mga aklat (kung siya ay isang administrator). Tingnan natin kung ano ang mangyayari kapag nag-click ang isang user sa isang kategorya pantasya upang tingnan ang mga pamagat ng mga aklat na magagamit sa aming tindahan.

Mayroon kaming partikular na controller para pangasiwaan ang lahat ng pagkilos na nauugnay sa mga aklat (tingnan, i-edit, gumawa, atbp.). Tawagan natin books_controller.php sa ating halimbawa. Gayundin kailangan namin ng isang modelo tulad ng book_model.php, na nagpoproseso ng data at lohika na nauugnay sa isang item sa tindahan. Sa konklusyon, kailangan namin ng ilang view upang kumatawan sa data, tulad ng isang listahan ng libro, isang pahina sa pag-edit, at iba pa.

Ipinapakita ng sumusunod na figure kung paano pinoproseso ang kahilingan ng isang user na tingnan ang isang listahan ng mga aklat sa isang paksa pantasya:

Ang controller (books_controller.php) ay tumatanggap ng kahilingan ng user (HTTP GET o POST request). Maaari tayong lumikha ng isang sentral na controller, halimbawa index.php, na tumatanggap ng kahilingan at tumatawag sa books_controller.php.

Sinusuri ng controller ang kahilingan at mga parameter at pagkatapos ay tinatawagan ang modelo(book_model.php), nagtatanong mayroon siyang listahan ng mga available na libro sa paksa pantasya.

Ang modelo ay tumatanggap ng data mula sa database (o isa pang mapagkukunan na nag-iimbak ng impormasyon), naglalapat ng mga filter at ang kinakailangang lohika, at pagkatapos ay nagbabalik ng data na kumakatawan sa isang listahan ng mga aklat.

Ginagamit ng controller ang naaangkop na view upang ipakita ang data sa user. Kung ang kahilingan ay mula sa isang mobile phone, ang mobile phone view ay ginagamit; kung ang gumagamit ay gumagamit ng isang tiyak na disenyo ng interface, pagkatapos ay ang kaukulang view ay pinili, at iba pa.

Ano ang mga pakinabang?

Ang pinaka-halatang benepisyo na makukuha natin sa paggamit ng konsepto ng MVC ay ang malinaw na paghihiwalay ng lohika ng presentasyon (user interface) at lohika ng aplikasyon.

Ang pagsuporta sa iba't ibang uri ng mga user na gumagamit ng iba't ibang uri ng mga device ay isang pangkaraniwang hamon sa mga araw na ito. Ang interface na ibinigay ay dapat na iba kung ang kahilingan ay mula sa isang personal na computer o mula sa isang mobile phone. Ang modelo ay nagbabalik ng parehong data, ang pagkakaiba lamang ay ang controller ay pumipili ng iba't ibang mga view upang i-output ang data.

Bilang karagdagan sa paghihiwalay ng mga view mula sa lohika ng aplikasyon, ang konsepto ng MVC ay makabuluhang binabawasan ang pagiging kumplikado ng malalaking aplikasyon. Ang code ay mas nakabalangkas, na ginagawang mas madali ang pagpapanatili, pagsubok, at muling paggamit ng mga solusyon.

Bakit gamitin ang kapaligiran sa trabaho?

Kapag ginamit mo ang workbench, ang pangunahing istraktura ng MVC ay handa na at ang kailangan mo lang gawin ay palawakin ang istraktura sa pamamagitan ng paglalagay ng iyong mga file sa naaangkop na mga direktoryo upang tumugma sa pattern ng MVC. Dagdag pa, magkakaroon ka ng isang hanay ng mga tampok na nakasulat na at mahusay na nasubok.

Kunin natin ang cakePHP bilang isang halimbawa kapaligiran sa pagtatrabaho MVC. Pagkatapos ng pag-install magkakaroon ka ng tatlong pangunahing direktoryo:

cake/
mga nagtitinda/

Folder app ay kung saan matatagpuan ang iyong mga file. Ito ang lugar para bumuo ng iyong bahagi ng application.

Sa isang folder Nagho-host ang cake ng mga file ng cakePHP (function ng workbench).

Folder ang mga vendor ay ginagamit upang mag-imbak ng mga third-party na PHP library.

Ang iyong workspace (direktoryo ng app) ay may sumusunod na istraktura:

app/
- config/
- controllers/
- lokal/
- mga modelo/
- mga plugin/
- pagsubok/
- mga nagtitinda/
- view/
- webroot/

Kailangan mong ilagay ang iyong mga controller sa direktoryo ng mga controller, ang iyong mga modelo sa direktoryo ng mga modelo, at ang iyong mga view sa direktoryo ng mga view!

Sa sandaling simulan mo nang gamitin ang workbench, agad itong magiging malinaw kung saan naninirahan ang halos bawat bahagi ng iyong application na kailangang gawin o baguhin. Ang organisasyong ito mismo ay lubos na nagpapasimple sa proseso ng pagbuo at pagpapanatili ng isang aplikasyon.

Gamit ang workbench para sa aming halimbawa

Dahil hindi nilayon ang tutorial na ito na ipakita ang proseso ng paglikha ng application gamit ang cakePHP, ipapakita lang namin ang code para sa modelo, controller at view na may mga komento sa mga benepisyo ng paggamit ng MVC workbench. Ang code ay sadyang pinasimple at hindi angkop para sa paggamit sa isang tunay na aplikasyon.

Tandaan, tumitingin kami sa isang bookstore at isang curious na user na gustong makakita ng kumpletong listahan ng mga libro sa paksa pantasya. Natanggap ng controller ang kahilingan ng user at inayos ang mga kinakailangang aksyon.

Kaya, sa sandaling na-click ng user ang button, hinihiling ng browser ang ibinigay na url:

1	www.ourstore.com/books/list/fantasy

Ang CakePHP ay nag-format ng URL gamit ang isang pattern /controller/action/param1/param2, Saan aksyon ay isang function na tinatawag ng controller. Sa lumang klasikong anyo, magiging ganito ang hitsura ng url:

1	www.ourstore.com/books_controller.php?action=list&category=fantasy

Controller

Sa kapaligiran ng pagtatrabaho ng cakePHP, magiging ganito ang hitsura ng aming controller:

1	pinapalawak ng klase BooksController ang AppController ( listahan ng function($category) ( $this ->set("books" , $this ->Book->findAllByCategory($category)); } function add() ( ... ... ) function na tanggalin () ( ... ... ) ... ... } ?>

Simple, hindi ba? Ang controller na ito ay maliligtas bilang books_controller.php at nai-post sa /app/controllers. Naglalaman ito ng listahan ng mga function na nagsasagawa ng mga aksyon para sa aming halimbawa, pati na rin ang iba pang mga function para sa pagsasagawa ng mga operasyong nauugnay sa libro (idagdag bagong libro, magtanggal ng aklat, at iba pa).

Ang kapaligiran sa trabaho ay nagbibigay sa atin ng marami handa na mga solusyon at kailangan mo lang gumawa ng listahan ng mga libro. Mayroong isang batayang klase na tumutukoy na sa pangunahing pag-andar ng controller, kaya kailangan mong magmana ng mga katangian at pag-andar ng klase na ito ( AppController ay ang tagapagmana Controller).

Ang kailangan mo lang gawin sa listahan ng aksyon ay tawagan ang modelo para makuha ang data at pagkatapos ay pumili ng view para ipakita ito sa user. Narito kung paano ito ginawa.

ito->Aklat- ito ang aming modelo, at bahagi ng code:

1	$this ->Book->findAllByCategory($category)

nagsasabi sa modelo na magbalik ng listahan ng mga aklat sa napiling paksa (titingnan natin ang modelo sa ibang pagkakataon).

Pamamaraan itakda sa linya:

1	$this ->set("books" , $this ->Book->findAllByCategory($category));

Ang controller ay nagpapasa ng data sa view. Variable mga libro tinatanggap ang data na ibinalik ng modelo at ginagawa itong available sa view.

Ngayon ang lahat na natitira ay upang ipakita ang view, ngunit ang function na ito ay awtomatikong ginagawa sa cakePHP kung gagamitin namin ang default na view. Kung gusto nating gumamit ng ibang uri, dapat nating tahasang tawagan ang pamamaraan render.

Modelo

Ang modelo ay mas simple:

1	pinalawak ng class Book ang AppModel ( } ?>

Bakit walang laman? Dahil siya ang tagapagmana batayang klase, na nagbibigay ng kinakailangang functionality at kailangan naming gamitin ang convention ng pagpapangalan ng CakePHP upang matiyak na awtomatikong pinangangasiwaan ng workbench ang lahat ng iba pang gawain. Halimbawa, alam ng cakePHP batay sa pangalan na modelong ito ginamit sa BooksController, at mayroon itong access sa isang database table na pinangalanang mga libro.

Sa kahulugang ito, magkakaroon tayo ng isang modelo na maaari lamang magbasa, magtanggal, o mag-imbak ng data sa database.

I-save ang code bilang libro.php sa isang folder /app/models.

Tingnan

Ang kailangan lang nating gawin ngayon ay lumikha ng view (ni kahit man lang, isa) para sa isang listahan ng mga aksyon. Ang view ay magkakaroon ng HTML code at ilang (kaunti hangga't maaari) na mga linya ng PHP code upang i-loop sa hanay ng mga aklat na ibinibigay ng modelo.

Pangalan	May-akda	Presyo

Tulad ng nakikita mo, ang view ay hindi lumilikha ng isang buong pahina, ngunit isang fragment lamang ng HTML (isang talahanayan sa sa kasong ito). Dahil ang CakePHP ay nagbibigay ng isa pang paraan upang tukuyin ang isang template ng pahina, at ang view ay ipinasok sa template na iyon. Ang workbench ay nagbibigay din sa amin ng ilang mga bagay na katulong upang maisagawa karaniwang gawain sa panahon ng paglikha ng mga bahagi Mga pahina ng HTML(paglalagay ng mga form, link, Ajax o JavaScript).

I-save ang view bilang listahan.ctp(listahan ang pangalan ng aksyon at ang ibig sabihin ng ctp ay CakePHP template) sa folder /app/views/books(dahil ito ay isang view para sa isang controller action).

Ito ay kung paano isinasagawa ang lahat ng tatlong bahagi gamit ang workbench ng CakePHP!

Pattern Model-View-Controller (MVC), na natuklasan noong huling bahagi ng 1970s, ay isang pattern ng disenyo ng arkitektura ng software na ang pangunahing layunin ay paghiwalayin ang mga function ng data mula sa presentasyon ng data. 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;

"; } } controller = $controller;

$ito->

modelo = $modelo;

) )

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

output();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!";

) )

modelo = $modelo;

Magandang hapon, mahal na mga kasamahan. Sa artikulong ito gusto kong pag-usapan ang tungkol sa aking analytical na pag-unawa sa mga pagkakaiba sa pagitan ng mga pattern ng MVC, MVP at MVVM. Na-prompt akong isulat ang artikulong ito sa pamamagitan ng pagnanais na maunawaan ang mga modernong diskarte sa pagbuo ng malaking software at ang kaukulang mga tampok ng arkitektura. Sa kasalukuyang yugto ng aking career ladder, hindi ako direktang developer, kaya maaaring naglalaman ang artikulo ng mga error, kamalian at hindi pagkakaunawaan. Naiintriga sa kung paano nakikita ng mga analyst kung ano ang ginagawa ng mga programmer at arkitekto? Pagkatapos ay maligayang pagdating sa pusa.

Mga link

Ang unang bagay na gusto kong simulan ay ang mga link sa mga panlabas na materyales na gumabay sa akin sa proseso ng pagsulat ng artikulong ito:

Panimula

Sa panahong mas maliwanag ang araw at mas luntian ang damo, ang isang pangkat ng mga mag-aaral na tulad ng may-akda ng artikulong ito ay bumuo ng software sa pamamagitan ng pagsulat ng daan-daang linya ng code nang direkta sa interface ng produkto. Minsan ginagamit ang mga serbisyo at tagapamahala upang gumana sa data, at pagkatapos ay nakuha ang solusyon gamit ang pattern ng Document-View. Ang pagsuporta sa naturang code ay nangangailangan ng napakalaking gastos, dahil ang isang bagong developer ay kailangang sanayin (sabihin) kung anong code ang may pananagutan para sa kung ano ang nasa produkto, at walang usapan tungkol sa anumang pagsubok sa yunit. Ang development team ay 4 na tao na nakaupo sa isang silid.
Lumipas ang oras, nagbago ang trabaho. Ang mga application na binuo ay naging mas malaki at mas kumplikado, at mula sa isang cohesive team ng mga developer nagkaroon ng maraming iba't ibang mga team ng mga developer, arkitekto, usability specialist, designer at PM. Ngayon lahat ay responsable para sa kanilang sariling lugar: GUI, lohika ng negosyo, mga bahagi. Lumitaw ang isang departamento ng pagsusuri, pagsubok, at arkitektura. Ang halaga ng software development ay tumaas ng daan-daan at kahit libu-libong beses. Ang diskarte na ito sa pag-unlad ay nangangailangan ng isang matatag na arkitektura na mag-synchronize ng iba't ibang functional na bahagi ng produkto sa bawat isa.

Mga pattern

Dahil sa layunin na bawasan ang mga gastos sa paggawa para sa pagbuo ng kumplikadong software, ipinapalagay namin na kinakailangan na gumamit ng mga handa na pinag-isang solusyon. Pagkatapos ng lahat, pinapadali ng mga template na aksyon ang komunikasyon sa pagitan ng mga developer, nagbibigay-daan sa iyong sumangguni sa mga kilalang disenyo, at bawasan ang bilang ng mga error.
Ayon sa Wikipedia, ang isang pattern ng disenyo ay isang paulit-ulit na disenyo ng arkitektura na kumakatawan sa isang solusyon sa isang problema sa disenyo sa loob ng ilang madalas na nangyayaring konteksto.

Magsimula tayo sa unang pangunahing bagay - Model-View-Controller. Ang MVC ay isang pangunahing pattern na nakahanap ng paraan sa maraming teknolohiya, na nagbunga ng mga bagong teknolohiya, at ginagawang mas madali ang buhay para sa mga developer araw-araw.

Ang pattern ng MVC ay unang lumitaw sa wikang SmallTalk. Kinailangan ng mga developer na makabuo ng solusyon sa arkitektura na maghihiwalay sa graphical na interface mula sa lohika ng negosyo, at sa lohika ng negosyo mula sa data. Kaya, sa klasikong bersyon nito, ang MVC ay binubuo ng tatlong bahagi, na nagbibigay ng pangalan nito. Tingnan natin sila:

Modelo

Ang isang Modelo ay karaniwang nauunawaan bilang isang bahagi na naglalaman ng functional na lohika ng negosyo ng isang application. Ang modelo ay dapat na ganap na independyente mula sa natitirang bahagi ng produkto. Ang layer ng modelo ay hindi kailangang malaman ang anumang bagay tungkol sa mga elemento ng disenyo o kung paano ito ire-render. Nakamit ang isang resulta na nagbibigay-daan sa iyong baguhin ang presentasyon ng data, kung paano ipinapakita ang mga ito, nang hindi hinahawakan ang mismong Modelo.

Ang modelo ay may mga sumusunod na tampok:

Ang modelo ay ang lohika ng negosyo ng aplikasyon;
Ang modelo ay may kaalaman tungkol sa sarili nito at hindi alam ang tungkol sa mga controller at view;
Para sa ilang mga proyekto, ang modelo ay simpleng layer ng data (DAO, database, XML file);
Para sa iba pang mga proyekto, ang modelo ay isang database manager, isang set ng mga bagay, o simpleng application logic;

Tingnan

Kasama sa mga responsibilidad ng View ang pagpapakita ng data na natanggap mula sa Modelo. Gayunpaman, hindi direktang makakaimpluwensya ang view sa modelo. Masasabi nating ang isang view ay may read-only na access sa data.

Ang representasyon ay may mga sumusunod na katangian:

Ang view ay nagpapatupad ng pagpapakita ng data na nakuha mula sa modelo sa anumang paraan;
Sa ilang mga kaso, ang view ay maaaring may code na nagpapatupad ng ilang lohika ng negosyo.

Mga halimbawa ng pagtatanghal: HTML page, WPF form, Windows Form.

Mga pagkakaiba sa pagitan ng MVP at MVVM at MVP

Ang pinakakaraniwang uri ng MVC pattern ay:

Model-View-Controller
Model-View-Presenter
Model-View-View na Modelo

Isaalang-alang at ihambing natin ang bawat isa sa kanila.

Model-View-Presenter

Binibigyang-daan ka ng diskarteng ito na lumikha ng abstraction ng representasyon. Upang gawin ito, kailangan mong pumili ng isang view interface na may isang tiyak na hanay ng mga katangian at pamamaraan. Ang nagtatanghal, sa turn, ay tumatanggap ng isang reference sa pagpapatupad ng interface, nag-subscribe sa mga kaganapan sa pagtatanghal, at binabago ang modelo kapag hiniling.

Mga palatandaan ng isang nagtatanghal:

Direktang nakikipag-ugnayan ang view sa nagtatanghal sa pamamagitan ng pagtawag ng mga naaangkop na function o kaganapan sa halimbawa ng nagtatanghal;
Nakikipag-ugnayan ang Presenter sa View sa pamamagitan ng paggamit ng isang espesyal na interface na ipinatupad ng View;
Ang isang instance ng presenter ay nauugnay sa isang display.

Pagpapatupad:
Dapat ipatupad ng bawat view ang kaukulang interface. Tinutukoy ng interface ng pagtatanghal ang hanay ng mga function at kaganapan na kailangan upang makipag-ugnayan sa user (halimbawa, IView.ShowErrorMessage(string msg)). Ang nagtatanghal ay dapat magkaroon ng isang sanggunian sa pagpapatupad ng kaukulang interface, na karaniwang ipinapasa sa constructor.
Ang lohika ng pagtatanghal ay dapat na may sanggunian sa halimbawa ng nagtatanghal. Ang lahat ng mga kaganapan sa view ay ipinapasa sa nagtatanghal para sa pagproseso at halos hindi naproseso ng lohika ng pagtatanghal (kabilang ang paglikha ng iba pang mga view).

Halimbawa ng paggamit: Mga Windows Form.

Model-View-View na Modelo

Binibigyang-daan ka ng diskarteng ito na iugnay ang mga elemento ng view sa mga katangian at kaganapan ng modelo ng View. Ito ay maaaring argued na ang bawat layer ng pattern na ito ay hindi alam tungkol sa pagkakaroon ng isa pang layer.

Mga tampok ng modelo ng View:

Dalawang-daan na komunikasyon sa pagtatanghal;
Ang modelo ng view ay isang abstraction ng isang view. Karaniwang nangangahulugan na ang mga katangian ng view ay kapareho ng mga katangian ng View/Model
Ang modelo ng View ay walang reference sa view interface (IView). Awtomatikong binabago ng pagbabago sa estado ng modelo ng View ang view at kabaliktaran, dahil ginagamit ang mekanismo ng pagbubuklod ng data (Bindings)
Ang isang instance ng isang View na modelo ay nauugnay sa isang view.

Pagpapatupad:
Kapag ginagamit ang pattern na ito, ang view ay hindi nagpapatupad ng kaukulang interface (IView).
Ang view ay dapat may link sa data source (DataContex), na sa kasong ito ay ang View model. Ang mga elemento ng view ay nakatali sa mga kaukulang katangian at kaganapan ng modelo ng View.
Sa turn, ang modelo ng View ay nagpapatupad ng isang espesyal na interface na ginagamit upang awtomatikong i-update ang mga elemento ng view. Ang isang halimbawa ng naturang interface sa WPF ay INotifyPropertyChanged.

Halimbawa ng paggamit: WPF

Model-View-Controller

Ang pangunahing ideya ng pattern na ito ay ang parehong controller at ang view ay nakasalalay sa modelo, ngunit ang modelo ay hindi nakasalalay sa dalawang sangkap na ito.

Mga katangian ng controller

Tinutukoy ng controller kung aling view ang dapat ipakita sa sandaling ito;
Ang mga kaganapan sa view ay maaari lamang makaapekto sa controller Ang controller ay maaaring makaapekto sa modelo at tumukoy ng isa pang view.
Maramihang mga view ay posible para sa isang controller lamang;

Pagpapatupad:
Ang controller ay humarang sa kaganapan mula sa labas at, alinsunod sa logic na naka-embed dito, ay tumutugon sa kaganapang ito sa pamamagitan ng pagpapalit ng Modelo sa pamamagitan ng pagtawag sa naaangkop na pamamaraan. Pagkatapos ng pagbabago, ginagamit ng Modelo ang kaganapang binago nito, at lahat ng mga kaganapan sa View na naka-subscribe dito, pagkatanggap nito, bumaling sa Modelo para sa na-update na data, pagkatapos nito ay ipapakita ang mga ito.

Halimbawa ng paggamit: MVC ASP.NET

Ipagpatuloy

Ang pagpapatupad ng mga pattern ng MVVM at MVP, sa unang tingin, ay mukhang medyo simple at katulad. Gayunpaman, para sa MVVM ang pagbubuklod ng view sa View-modelo ay awtomatikong ginagawa, ngunit para sa MVP kinakailangan na mag-program
Mukhang may higit na kontrol ang MVC sa view.

Pangkalahatang mga patakaran para sa pagpili ng isang pattern

MVVM

Ginamit sa isang sitwasyon kung saan ang data binding ay posible nang hindi na kailangang magpakilala ng mga espesyal na interface ng view (ibig sabihin, hindi na kailangang ipatupad ang IView);
Ang isang karaniwang halimbawa ay ang teknolohiya ng WPF.

MVP

Ginagamit sa isang sitwasyon kung saan ang data binding ay hindi posible (Binding ay hindi maaaring gamitin);
Ang isang karaniwang halimbawa ay ang paggamit ng Windows Forms.

MVC

Ginagamit sa isang sitwasyon kung saan hindi posible ang komunikasyon sa pagitan ng view at iba pang bahagi ng application (at hindi mo magagamit ang MVVM o MVP);
Ang isang karaniwang kaso ng paggamit ay ASP.NET MVC.

Konklusyon

Sa konklusyon, nais ipahiwatig ng may-akda ng artikulong ito na ang mahigpit na pagsunod sa isang pattern ay hindi palaging ang pinakamahusay na pagpipilian. Halimbawa, isipin na gusto mong gamitin ang MVVM upang bumuo ng mga application gamit ang Windows Forms sa pamamagitan ng Bindings property ng mga kontrol. Ang iyong layunin ay paghiwalayin ang presentasyon mula sa lohika ng negosyo at ang lohika na nag-uugnay sa kanila. Ang application ay dapat na madaling subukan at suportahan, at nauunawaan para sa mga analyst (pagkatapos ng lahat, sa tanong na "paano nasusukat ang pagganap ng isang hard drive" mayroon lamang isang tamang sagot - sa Joules (abstract na halimbawa Model -> Views)) .

Maraming salamat sa iyong oras, enjoy reading!

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.