ตัวควบคุม
คำขอแต่ละรายการที่เข้ามาในแอปพลิเคชันจะได้รับการประมวลผลโดยตัวควบคุม ผู้ควบคุมสามารถดำเนินการตามคำขอโดยพลการ ตราบใดที่ไม่ข้ามขอบเขตความรับผิดชอบระหว่างตัวแบบและมุมมอง ซึ่งหมายความว่าตัวควบคุมไม่ควรมีหรือเก็บข้อมูล และไม่ควรสร้างอินเทอร์เฟซผู้ใช้
ใน ASP.NET MVC Framework ตัวควบคุมคือคลาส .NET ที่มีตรรกะที่จำเป็นในการประมวลผลคำขอ บทบาทของคอนโทรลเลอร์คือการสรุปตรรกะของแอปพลิเคชัน กล่าวอีกนัยหนึ่ง ผู้ควบคุมมีหน้าที่รับผิดชอบในการประมวลผลคำขอที่เข้ามา ดำเนินการกับโมเดล สาขาวิชาและเลือกมุมมองที่จะแสดงผลต่อผู้ใช้
แอปพลิเคชันตัวอย่าง
เพื่อการนี้และ บทความต่อไปนี้เราจะสร้าง โครงการใหม่ MVC ตั้งชื่อว่า ControllersAndActions โดยใช้เทมเพลตเปล่า โดยเลือกช่องทำเครื่องหมาย MVC ในส่วนเพิ่มโฟลเดอร์และการอ้างอิงหลักสำหรับ และโครงการทดสอบหน่วยชื่อ ControllersAndActions.Tests การทดสอบหน่วยที่คุณจะสร้างขึ้นไม่จำเป็นต้องใช้การจำลอง ดังนั้นคุณจึงไม่ต้องติดตั้งแพ็คเกจ Moq แต่คุณต้องติดตั้งแพ็คเกจ MVC เพื่อให้การทดสอบสามารถเข้าถึงคลาสคอนโทรลเลอร์พื้นฐานได้
ในหน้าต่าง Visual Studio NuGet Package Manager Console ให้ป้อนคำสั่งต่อไปนี้:
ติดตั้งแพ็คเกจ Microsoft.Aspnet.Mvc - รุ่น 5.0.0 - ชื่อโครงการ ControllersAndActions.Tests
หลังจากสร้างโครงการแล้วให้เลือก ControllersAndActions Properties (Properties ControllersAndActions) ในเมนู Project (Project) ของสภาพแวดล้อม Visual Studio ในกล่องโต้ตอบที่เปิดขึ้นให้ไปที่แท็บ Web (เว็บ) และทำเครื่องหมายที่ปุ่มตัวเลือก หน้าเฉพาะ ( หน้าเฉพาะ) ในหมวดเริ่มการดำเนินการ คุณไม่จำเป็นต้องป้อนค่าใดๆ เพียงแค่เลือกปุ่มตัวเลือก
แนวคิดของตัวควบคุม
คุณเคยเห็นกรณีการใช้งานคอนโทรลเลอร์ในบทความ ASP.NET MVC ก่อนหน้านี้เกือบทุกบทความ ได้เวลาดูเบื้องหลังแล้ว
การสร้างคอนโทรลเลอร์โดยใช้อินเตอร์เฟส IController
ใน MVC Framework ต้องใช้คลาสคอนโทรลเลอร์ อินเตอร์เฟส IControllerจากเนมสเปซ System.Web.Mvcแสดงในตัวอย่างด้านล่าง:
การใช้ System.Web.Routing; เนมสเปซ System.Web.Mvc ( IController อินเตอร์เฟสสาธารณะ ( void Execute (RequestContext requestContext); ) )
เพื่อให้ได้คำจำกัดความของอินเทอร์เฟซนี้ คุณต้องดาวน์โหลดซอร์สโค้ด MVC Framework ซึ่งมีประโยชน์อย่างยิ่งสำหรับการทำความเข้าใจการทำงานภายในของเครื่องมือเฟรมเวิร์ก
อย่างที่คุณเห็น อินเทอร์เฟซ IController นั้นเรียบง่ายมาก ของเขาเท่านั้น ดำเนินการ () วิธีการเรียกเมื่อมีการร้องขอไปยังคลาสคอนโทรลเลอร์นี้ MVC Framework ค้นหาคลาสที่คำขอกำหนดเป้าหมายโดยการอ่านค่าของคุณสมบัติคอนโทรลเลอร์ที่สร้างโดยข้อมูลการกำหนดเส้นทาง หรือโดยการใช้คลาสการกำหนดเส้นทางพิเศษ
คุณสามารถสร้างคลาสคอนโทรลเลอร์ได้โดยใช้อินเทอร์เฟซ IController แต่เนื่องจากอินเทอร์เฟซนี้เป็นระดับต่ำ คุณจะต้องทำงานหลายอย่างเพื่อให้ได้สิ่งที่มีประโยชน์ อย่างไรก็ตาม อินเทอร์เฟซ IController มีประโยชน์สำหรับการสาธิตการทำงานของตัวควบคุม และเพื่อจุดประสงค์นี้ ไฟล์คลาสใหม่ที่ชื่อว่า BasicController.cs จะถูกสร้างขึ้นในโฟลเดอร์ Controllers ซึ่งเนื้อหาจะแสดงในตัวอย่างด้านล่าง:
ใช้ System.Web.Mvc; ใช้ System.Web.Routing; Namespace ControllersAndActions.Controllers ( คลาสสาธารณะ BasicController: IController ( โมฆะสาธารณะ Execute (RequestContext requestContext) ( string controller = (string) requestContext.RouteData.Values ["controller"]; string action = (string)requestContext.RouteData.Values ["action "]; requestContext.HttpContext.Response.Write(string.Format("Controller: (0), Action method: (1)", controller, action)); ) ) )
ผ่านเมธอด Execute() ของอินเตอร์เฟส IController วัตถุ RequestContext A ที่ให้ข้อมูลเกี่ยวกับคำขอปัจจุบันและเส้นทางที่ตรงกัน (และทำให้คอนโทรลเลอร์ที่กำหนดถูกเรียกให้จัดการคำขอนั้น) คลาส RequestContext กำหนดคุณสมบัติสองอย่าง ซึ่งอธิบายไว้ในตารางด้านล่าง:
วัตถุ HttpContextBaseให้การเข้าถึงชุดของวัตถุที่อธิบายคำขอปัจจุบัน ซึ่งเรียกว่าวัตถุบริบท เราจะกลับมาหาพวกเขาในภายหลัง วัตถุ RouteDataอธิบายเส้นทาง คุณสมบัติที่สำคัญของคลาส RouteData แสดงอยู่ในตารางด้านล่าง:
บทความ การกำหนดค่าระบบกำหนดเส้นทาง แสดงวิธีใช้ประเภท RouteBase และ IRouteHandler เพื่อกำหนดค่าระบบกำหนดเส้นทาง ในตัวอย่างนี้ เมื่อใช้คุณสมบัติ Values จะได้รับค่าของตัวแปรของตัวควบคุมและส่วนการดำเนินการ ซึ่งจะถูกเขียนลงในการตอบสนอง
ส่วนหนึ่งของปัญหาในการสร้างตัวควบคุมแบบกำหนดเองคือการไม่สามารถเข้าถึงคุณสมบัติต่างๆ เช่น มุมมอง ซึ่งหมายความว่าคุณต้องทำงานในระดับที่ต่ำกว่า ซึ่งเป็นสาเหตุที่เขียนเนื้อหาโดยตรงเพื่อตอบสนองลูกค้า คุณสมบัติ HttpContextBase.Responseผลตอบแทน วัตถุ HttpResponseBaseซึ่งอนุญาตให้คุณกำหนดค่าและเพิ่มเนื้อหาในการตอบกลับที่จะส่งไปยังไคลเอ็นต์ นี่เป็นจุดติดต่ออื่นระหว่าง ASP.NET และ MVC Framework
หากคุณเรียกใช้แอปพลิเคชันและไปที่ URL เช่น /Basic/Index ตัวควบคุมพิเศษจะสร้างผลลัพธ์ที่แสดงในรูปด้านล่าง:
การใช้อินเทอร์เฟซ IController ช่วยให้คุณสร้างคลาสที่ MVC Framework รู้จักว่าเป็นตัวควบคุมและส่งคำขอไปยังมัน โดยไม่มีข้อจำกัดใดๆ เกี่ยวกับวิธีการประมวลผลคำขอและการตอบสนองใดที่สร้างขึ้นสำหรับมัน นี้ ตัวอย่างที่ดีเนื่องจากเป็นการแสดงให้เห็นว่า MVC Framework สามารถขยายได้เพียงใดแม้สำหรับบล็อกการสร้างหลัก เช่น ตัวควบคุม แต่การเขียน แอปพลิเคชันที่ซับซ้อนด้วยวิธีนี้อาจเต็มไปด้วยความยากลำบากอย่างมาก
คลาสที่มีชื่อลงท้ายด้วย Base
MVC Framework อาศัย ASP.NET ในการประมวลผลคำขอ ซึ่งสมเหตุสมผลมากเพราะ แพลตฟอร์มนี้ได้รับการพิสูจน์แล้วและมีการใช้งานที่หลากหลายซึ่งรวมเข้ากับ IIS Application Server อย่างแน่นหนา ปัญหาคือคลาสที่ใช้โดย ASP.NET เพื่อให้ข้อมูลเกี่ยวกับคำขอนั้นไม่เหมาะสำหรับการทดสอบหน่วย ซึ่งเป็นประโยชน์หลักของการใช้ MVC Framework
Microsoft ตัดสินใจที่จะแนะนำความสามารถในการทดสอบในขณะที่รักษาความเข้ากันได้กับ แอปพลิเคชันที่มีอยู่ ASP.NET Web Forms ดังนั้นผลลัพธ์คือ คลาสพื้นฐาน. คลาสเหล่านี้ได้รับการตั้งชื่อเพราะมีชื่อเดียวกันกับคลาสแพลตฟอร์ม ASP.NET หลักตามด้วยคำว่า Base
ตัวอย่างเช่น ASP.NET ให้ข้อมูลเชิงบริบทเกี่ยวกับคำขอปัจจุบันและบริการแอปพลิเคชันหลักจำนวนหนึ่งผ่านวัตถุ HttpContext คลาสฐานที่สอดคล้องกันคือ HttpContextBase ซึ่งเป็นอินสแตนซ์ที่ส่งผ่านไปยังเมธอด Execute() ที่กำหนดไว้ในอินเทอร์เฟซ IController (คลาสฐานอื่นๆ จะแสดงให้เห็นในตัวอย่างถัดไป) คลาสดั้งเดิมและคลาสพื้นฐานกำหนดคุณสมบัติและเมธอดเดียวกัน แต่เป็นคลาสพื้นฐาน เป็นนามธรรมเสมอซึ่งหมายความว่าใช้งานง่ายสำหรับการทดสอบหน่วย
บางครั้งคุณอาจลงเอยด้วยอินสแตนซ์ของคลาส ASP.NET ดั้งเดิม เช่น HttpContext ในกรณีเช่นนี้ จำเป็นต้องสร้างคลาสฐานที่เป็นมิตรกับ MVC ซึ่งคล้ายกับ HttpContextBase สิ่งนี้ทำได้โดยใช้หนึ่งใน คลาสห่อซึ่งมีชื่อเหมือนกับคลาสเดิม พร้อมเติมคำว่า Wrapper เช่น HttpContextWrapper. คลาส Wrapper ได้รับมาจากคลาสพื้นฐานและมีตัวสร้างที่ใช้อินสแตนซ์ของคลาสดั้งเดิม:
คลาสเริ่มต้น คลาสฐาน และคลาส Wrapper ถูกกำหนดไว้ในเนมสเปซ System.Web ดังนั้น ASP.NET จึงสามารถรองรับ MVC Framework และแอปพลิเคชันรุ่นเก่าได้อย่างราบรื่น เว็บแอปพลิเคชันแบบฟอร์ม
การสร้างคอนโทรลเลอร์โดยสืบทอดจากคลาสคอนโทรลเลอร์
ตามที่แสดงในตัวอย่างก่อนหน้านี้ MVC Framework ช่วยให้สามารถปรับแต่งและขยายได้เกือบไม่จำกัด คุณสามารถใช้อินเทอร์เฟซ IController เพื่อให้การประมวลผลคำขอและการสร้างผลลัพธ์ประเภทใดก็ได้ที่คุณต้องการ คุณไม่ชอบวิธีการดำเนินการ? คุณไม่ต้องการกังวลเกี่ยวกับการแสดงผลการแสดงผล? ในกรณีนั้น คุณสามารถจัดการเรื่องต่าง ๆ ด้วยตนเองและใช้วิธีที่ดีกว่า เร็วกว่า และสวยงามกว่าในการดำเนินการตามคำขอ หรือคุณสามารถใช้ประโยชน์จากเครื่องมือที่มีให้โดยทีม Microsoft MVC Framework และสืบทอดคอนโทรลเลอร์ของคุณจากคลาส System.Web.Mvc.Controller.
คลาสคอนโทรลเลอร์ให้การสนับสนุนการจัดการคำขอที่นักพัฒนาแอปพลิเคชัน MVC ส่วนใหญ่คุ้นเคย มันถูกใช้ในตัวอย่างทั้งหมดที่กล่าวถึงในบทความก่อนหน้านี้ คลาสคอนโทรลเลอร์มีสามอย่าง กองทุนหลักซึ่งอธิบายไว้ด้านล่าง:
วิธีการดำเนินการพฤติกรรมของคอนโทรลเลอร์นั้นกระจายไปหลายวิธี (แทนที่จะดำเนินการในรูปแบบ วิธีเดียวดำเนินการ ()) วิธีการดำเนินการแต่ละรายการจะแมปกับ URL ที่สอดคล้องกัน และเรียกด้วยพารามิเตอร์ที่ดึงมาจากคำขอที่เข้ามา
ผลของการกระทำคุณสามารถส่งคืนออบเจกต์ที่อธิบายผลลัพธ์ของการกระทำ (เช่น การแสดงมุมมองหรือเปลี่ยนเส้นทางไปยัง URL หรือวิธีการดำเนินการอื่น) แล้วประมวลผลด้วยวิธีใดก็ได้ที่คุณต้องการ การแยกระหว่างการระบุผลลัพธ์และการดำเนินการทำให้การทดสอบหน่วยง่ายขึ้น
ตัวกรองพฤติกรรมที่ใช้ซ้ำได้ (เช่น การพิสูจน์ตัวตน) สามารถสรุปเป็นตัวกรอง จากนั้นทำเครื่องหมายแต่ละลักษณะการทำงานของตัวควบคุมและวิธีการดำเนินการด้วยแอตทริบิวต์ในซอร์สโค้ด
เว้นแต่ว่าคุณกำลังจัดการกับความต้องการเฉพาะ วิธีที่ดีที่สุดในการสร้างคอนโทรลเลอร์คือการสืบทอดคอนโทรลเลอร์จากคลาสคอนโทรลเลอร์ ซึ่งตามที่คุณคาดหวัง Visual Studio จะทำเมื่อสร้าง คลาสใหม่เพื่อตอบสนองต่อการเลือกรายการเมนู เพิ่ม --> นั่งร้าน (เพิ่ม --> แม่แบบ)
ตัวอย่างด้านล่างคือรหัส ตัวควบคุมอย่างง่ายเรียกว่า DerivedController สร้างขึ้นในลักษณะเดียวกัน สร้างขึ้นโดยใช้ตัวควบคุม MVC 5 - ตัวแปรเปล่าที่มีหลายตัว การเปลี่ยนแปลงง่ายๆออกแบบมาเพื่อตั้งค่าคุณสมบัติ ViewBag และเลือกมุมมอง:
ใช้ระบบ; ใช้ System.Web; ใช้ System.Web.Mvc; Namespace ControllersAndActions.Controllers ( คลาสสาธารณะ DerivedController: Controller ( ดัชนี ActionResult สาธารณะ () ( ViewBag.Message = "สวัสดีจากดัชนีวิธีการดำเนินการ DerivedController ของคอนโทรลเลอร์"; return View ("MyView"); ) ) )
คลาสคอนโทรลเลอร์ยังมีลิงค์ไปยังระบบมุมมองมีดโกน ในตัวอย่างนี้ เราส่งคืนผลลัพธ์ของการเรียกใช้เมธอด View() ซึ่งใช้เป็นพารามิเตอร์ชื่อของมุมมองที่จะแสดงผลกับไคลเอ็นต์ หากต้องการสร้างมุมมองนี้ ให้สร้างโฟลเดอร์ Views/Derived คลิกที่มัน คลิกขวาเมาส์และเลือก เมนูบริบทรายการ เพิ่ม --> MVC 5 ดูหน้า (มีดโกน) (เพิ่ม --> MVC 5 ดูหน้า (มีดโกน)) ตั้งชื่อ MyView.cshtml แล้วคลิก ตกลง เพื่อสร้างไฟล์มุมมอง
เปลี่ยนเนื้อหาของไฟล์ให้ตรงกับตัวอย่าง:
@(ViewBag.Title = "ดัชนี"; } !}
มุมมองของฉัน
ข้อความจากคอนโทรลเลอร์: " @ViewBag.Message "หลังจากเริ่มต้นแอปพลิเคชันและนำทางไปยัง URL เช่น /Derived/Index วิธีการดำเนินการนี้จะถูกเรียกและ MyView จะแสดงผล:
การสืบทอดจากคลาส Controller ส่งผลให้เกิดความจำเป็นในการใช้วิธีดำเนินการ รับข้อมูลใดๆ ที่จำเป็นในการประมวลผลคำขอ และสร้างการตอบสนองที่เหมาะสม บทความต่อไปนี้จะอธิบายถึงแนวทางต่างๆ ในการดำเนินการนี้
หลายคนเริ่มเขียนโครงการเพื่อทำงานกับงานเดียว โดยไม่ได้หมายความว่ามันจะเติบโตเป็นระบบการจัดการที่มีผู้ใช้หลายคน เช่น เนื้อหา หรือพระเจ้าห้ามไม่ให้มีการผลิต และทุกอย่างดูเหมือนจะยอดเยี่ยมและเจ๋ง ทุกอย่างทำงานได้จนกว่าคุณจะเริ่มเข้าใจว่าโค้ดที่เขียนนั้นประกอบด้วยไม้ค้ำและฮาร์ดโค้ดทั้งหมด รหัสผสมกับเค้าโครง คำร้อง และไม้ค้ำ บางครั้งอ่านไม่ออกด้วยซ้ำ ปัญหาเร่งด่วนเกิดขึ้น: เมื่อเพิ่มฟีเจอร์ใหม่ คุณต้องเล่นโค้ดนี้เป็นเวลานานมาก โดยจำว่า "เขียนอะไรลงไป" และสาปแช่งตัวเองในอดีตคุณอาจเคยได้ยินเกี่ยวกับรูปแบบการออกแบบและแม้แต่อ่านหนังสือที่ยอดเยี่ยมเหล่านี้:
- E. Gamma, R. Helm, R. Johnson, J. Vlissidess "เทคนิคของวัตถุ การออกแบบที่มุ่งเน้น. รูปแบบการออกแบบ";
- เอ็ม. ฟาวเลอร์ "สถาปัตยกรรมของแอปพลิเคชันซอฟต์แวร์ระดับองค์กร".
บทความที่นำเสนอจะเป็นประโยชน์สำหรับผู้เริ่มต้นเป็นหลัก ไม่ว่าในกรณีใด ฉันหวังว่าในอีกไม่กี่ชั่วโมงข้างหน้า คุณจะสามารถเข้าใจได้ การใช้งาน MVCรูปแบบที่รองรับกรอบเว็บสมัยใหม่ทั้งหมด รวมทั้งได้รับ "อาหาร" สำหรับการไตร่ตรองเพิ่มเติมเกี่ยวกับ "วิธีการทำ" ในตอนท้ายของบทความคือการเลือก ลิงค์ที่มีประโยชน์ซึ่งจะช่วยให้คุณเข้าใจว่าเว็บเฟรมเวิร์ก (นอกเหนือจาก MVC) ประกอบด้วยอะไรบ้างและทำงานอย่างไร
โปรแกรมเมอร์ PHP ที่แข็งกระด้างไม่น่าจะพบสิ่งใหม่สำหรับตัวเองในบทความนี้ แต่ความคิดเห็นและความคิดเห็นของพวกเขาในข้อความหลักจะมีประโยชน์มาก! เพราะ หากไม่มีทฤษฎี การปฏิบัติก็เป็นไปไม่ได้ และหากไม่มีการปฏิบัติ ทฤษฎีก็ไร้ประโยชน์ ในตอนแรกจะมีทฤษฎีเล็กน้อย จากนั้นเราจะไปสู่การปฏิบัติ หากคุณคุ้นเคยกับแนวคิดของ MVC แล้ว คุณสามารถข้ามส่วนทฤษฎีและเข้าสู่การปฏิบัติได้ทันที
1. ทฤษฎี
รูปแบบ MVC อธิบายถึงวิธีง่ายๆ ในการสร้างโครงสร้างแอปพลิเคชันที่มีจุดประสงค์เพื่อแยกตรรกะทางธุรกิจออกจากอินเทอร์เฟซผู้ใช้ ส่งผลให้แอปพลิเคชันปรับขนาด ทดสอบ บำรุงรักษา และนำไปใช้งานได้ง่ายขึ้นพิจารณาโครงร่างแนวคิดของเทมเพลต MVC (ในความคิดของฉัน นี่เป็นโครงร่างที่ประสบความสำเร็จมากที่สุดในบรรดาที่ฉันเคยเห็น):
ในงานสถาปัตยกรรม รุ่น MVCจัดเตรียมข้อมูลและกฎตรรกะทางธุรกิจ มุมมองรับผิดชอบส่วนติดต่อผู้ใช้ และตัวควบคุมให้การโต้ตอบระหว่างแบบจำลองและมุมมอง
เวิร์กโฟลว์แอปพลิเคชัน MVC ทั่วไปสามารถอธิบายได้ดังต่อไปนี้:
- เมื่อผู้ใช้ป้อนทรัพยากรบนเว็บ สคริปต์การเริ่มต้นจะสร้างอินสแตนซ์ของแอปพลิเคชันและเรียกใช้งานเพื่อดำเนินการ
นี่แสดงมุมมองพูด หน้าแรกเว็บไซต์. - แอปพลิเคชันได้รับคำขอจากผู้ใช้และกำหนดตัวควบคุมและการดำเนินการที่ร้องขอ ในกรณีของหน้าหลัก การดำเนินการเริ่มต้นจะดำเนินการ ( ดัชนี).
- แอปพลิเคชันสร้างอินสแตนซ์ของคอนโทรลเลอร์และเรียกใช้วิธีการดำเนินการ
ซึ่ง ตัวอย่างเช่น มีการเรียกไปยังโมเดลที่อ่านข้อมูลจากฐานข้อมูล - หลังจากนั้น การดำเนินการจะสร้างมุมมองพร้อมข้อมูลที่ได้รับจากโมเดลและแสดงผลลัพธ์แก่ผู้ใช้
โมเดลไม่ควรโต้ตอบโดยตรงกับผู้ใช้ ตัวแปรทั้งหมดที่เกี่ยวข้องกับคำขอของผู้ใช้จะต้องดำเนินการในคอนโทรลเลอร์
โมเดลไม่ควรสร้าง HTML หรือโค้ดการแสดงผลอื่นๆ ซึ่งอาจเปลี่ยนแปลงได้ขึ้นอยู่กับความต้องการของผู้ใช้ ควรจัดการรหัสดังกล่าวในมุมมอง
โมเดลเดียวกัน ตัวอย่างเช่น โมเดลการตรวจสอบผู้ใช้สามารถใช้ได้ทั้งในผู้ใช้และในส่วนการดูแลระบบของแอ็พพลิเคชัน ในกรณีเช่นนี้คุณสามารถทำได้ รหัสทั่วไปลงในคลาสที่แยกจากกันและสืบทอดจากคลาสนั้น โดยกำหนดวิธีการเฉพาะสำหรับการสมัครย่อยในทายาท
ดู- ใช้เพื่อตั้งค่าการแสดงผลภายนอกของข้อมูลที่ได้รับจากคอนโทรลเลอร์และโมเดล
มุมมองมีมาร์กอัป HTML และการแทรกโค้ด PHP ขนาดเล็กสำหรับการรวบรวมข้อมูล จัดรูปแบบ และแสดงข้อมูล
ไม่ควรเข้าถึงฐานข้อมูลโดยตรง โมเดลควรทำเช่นนี้
ไม่ควรทำงานกับข้อมูลที่ได้รับจากคำขอของผู้ใช้ งานนี้ต้องดำเนินการโดยผู้ควบคุม
สามารถเข้าถึงคุณสมบัติและวิธีการของคอนโทรลเลอร์หรือโมเดลได้โดยตรงเพื่อรับข้อมูลที่พร้อมเอาต์พุต
มุมมองมักจะแบ่งออกเป็นเทมเพลตทั่วไปที่มีมาร์กอัปทั่วไปสำหรับทุกหน้า (เช่น ส่วนหัวและส่วนท้าย) และส่วนเทมเพลตที่ใช้เพื่อแสดงเอาต์พุตข้อมูลจากโมเดลหรือแสดงฟอร์มการป้อนข้อมูล
ผู้ควบคุม- ลิงก์ที่เชื่อมต่อโมเดล มุมมอง และส่วนประกอบอื่นๆ ใน แอปพลิเคชั่นทำงาน. คอนโทรลเลอร์มีหน้าที่จัดการคำขอของผู้ใช้ คอนโทรลเลอร์ต้องไม่มีคำสั่ง SQL เก็บไว้ในแบบจำลองจะดีกว่า ตัวควบคุมต้องไม่มี HTML หรือมาร์กอัปอื่นๆ มันสมควรที่จะถูกนำออกไปในที่โล่ง
ในแอปพลิเคชัน MVC ที่ออกแบบมาอย่างดี ตัวควบคุมมักจะบางมากและมีโค้ดเพียงไม่กี่สิบบรรทัด สิ่งที่ไม่สามารถพูดเกี่ยวกับ Stupid Fat Controllers (SFC) ใน CMS Joomla ตรรกะของคอนโทรลเลอร์นั้นค่อนข้างทั่วไปและส่วนใหญ่จะถูกนำออกไป คลาสพื้นฐาน.
ในทางกลับกัน โมเดลมีความหนามากและมีโค้ดส่วนใหญ่ที่เกี่ยวข้องกับการประมวลผลข้อมูล โครงสร้างของข้อมูลและตรรกะทางธุรกิจที่มีอยู่มักจะค่อนข้างเฉพาะเจาะจงกับแอปพลิเคชันเฉพาะ
1.1. ตัวควบคุมด้านหน้าและตัวควบคุมหน้า
ในกรณีส่วนใหญ่ การโต้ตอบของผู้ใช้กับเว็บแอปพลิเคชันจะเกิดขึ้นผ่านลิงก์ ดูที่แถบที่อยู่ของเบราว์เซอร์ - คุณได้รับข้อความนี้จากลิงค์นี้ ลิงก์อื่นๆ เช่นลิงก์ที่อยู่ด้านขวาของหน้านี้ จะนำคุณไปยังเนื้อหาอื่นๆ ดังนั้น ลิงก์จะแสดงคำสั่งเฉพาะไปยังเว็บแอปพลิเคชันฉันหวังว่าคุณจะสังเกตเห็นแล้วว่าไซต์ต่างๆ สามารถมีได้อย่างสมบูรณ์แบบ รูปแบบที่แตกต่างกันอาคาร แถบที่อยู่. แต่ละรูปแบบสามารถแสดงถึงสถาปัตยกรรมของเว็บแอปพลิเคชัน แม้ว่าจะไม่เป็นเช่นนั้นเสมอไป แต่ในกรณีส่วนใหญ่ก็เป็นข้อเท็จจริงที่ชัดเจน
พิจารณาสองตัวเลือกสำหรับแถบที่อยู่ซึ่งแสดงข้อความบางส่วนและโปรไฟล์ผู้ใช้
รหัสการประมวลผลโดยประมาณในกรณีนี้:
switch($_GET["action"]) ( case "about" : required_once("about.php"); // ตัวแบ่งหน้า "เกี่ยวกับเรา"; case "contacts" : required_once("contacts.php"); // หน้า "ผู้ติดต่อ" แตก; กรณี "ข้อเสนอแนะ" : required_once("feedback.php"); // หน้า "ข้อเสนอแนะ" แตก; ค่าเริ่มต้น: required_once("page404.php"); // หน้า "404" แตก; )
ฉันคิดว่าเกือบทุกคนเคยทำสิ่งนี้มาก่อน
เมื่อใช้กลไกการกำหนดเส้นทาง URL คุณสามารถกำหนดค่าแอปพลิเคชันของคุณให้ยอมรับคำขอเช่นนี้เพื่อแสดงข้อมูลเดียวกัน:
http://www.example.com/contacts/feedback
ที่นี่ ผู้ติดต่อเป็นตัวควบคุมและคำติชมเป็นวิธีการของตัวควบคุมผู้ติดต่อที่แสดงผลแบบฟอร์ม ข้อเสนอแนะเป็นต้น เราจะกลับไปที่ปัญหานี้ในส่วนการปฏิบัติ
นอกจากนี้ยังควรรู้ด้วยว่าเราเตอร์ของเฟรมเวิร์กเว็บจำนวนมากอนุญาตให้คุณสร้างโดยพลการ เส้นทาง URL(ระบุว่าแต่ละส่วนของ URL หมายถึงอะไร) และกฎสำหรับการประมวลผล
ตอนนี้เรามีความรู้ทางทฤษฎีเพียงพอที่จะไปปฏิบัติ
2. ฝึกฝน
ในการเริ่มต้นเรามาสร้าง โครงสร้างต่อไปนี้ไฟล์และโฟลเดอร์:
มองไปข้างหน้า ฉันจะบอกว่าคลาสพื้นฐาน Model, View และ Controller จะถูกจัดเก็บไว้ในโฟลเดอร์หลัก
ลูกของพวกเขาจะถูกจัดเก็บไว้ในไดเร็กทอรีคอนโทรลเลอร์ โมเดล และมุมมอง ไฟล์ index.phpนี่คือจุดเริ่มต้นของแอปพลิเคชัน ไฟล์ bootstrap.phpเริ่มการดาวน์โหลดแอปพลิเคชัน รวมถึงโมดูลที่จำเป็นทั้งหมด ฯลฯ
ไปตามลำดับ เปิดไฟล์ index.php แล้วกรอกโค้ดตามนี้
ini_set("display_errors", 1); need_once "application/bootstrap.php";
ไม่ควรมีคำถามที่นี่
ต่อไปเราจะตรงไปที่ฤดูใบไม้ร่วง bootstrap.php:
need_once "core/model.php"; need_once "core/view.php"; need_once "core/controller.php"; need_once "core/route.php"; เส้นทาง::start(); // เริ่มเราเตอร์
สามบรรทัดแรกจะรวมไฟล์เคอร์เนลที่ไม่มีอยู่ในปัจจุบัน บรรทัดสุดท้ายรวมไฟล์กับคลาสเราเตอร์และเรียกใช้เพื่อดำเนินการโดยการโทร วิธีคงที่เริ่ม.
2.1. การใช้งานเราเตอร์ URL
สำหรับตอนนี้ เรามาเบี่ยงเบนจากการใช้รูปแบบ MVC และมุ่งเน้นไปที่การกำหนดเส้นทาง ขั้นตอนแรกที่เราต้องทำคือเขียนโค้ดต่อไปนี้ลงไป .htaccess:RewriteEngine บน RewriteCond %(REQUEST_FILENAME) !-f RewriteCond %(REQUEST_FILENAME) !-d RewriteRule .* index.php [L]
รหัสนี้จะเปลี่ยนเส้นทางการประมวลผลของหน้าทั้งหมดไปที่ index.phpซึ่งเป็นสิ่งที่เราต้องการ จำในส่วนแรกที่เราพูดถึง Front Controller ได้ไหม!
เราจะใส่การกำหนดเส้นทางในไฟล์แยกต่างหาก route.phpไปยังไดเร็กทอรีหลัก ในไฟล์นี้ เราจะอธิบายถึงคลาส Route ซึ่งจะรันเมธอดของคอนโทรลเลอร์ ซึ่งจะสร้างลักษณะที่ปรากฏของเพจ
เนื้อหาไฟล์ route.php
class Route ( ฟังก์ชันสแตติก start() ( // ตัวควบคุมเริ่มต้นและการกระทำ $controller_name = "หลัก"; $action_name = "ดัชนี"; $routes = ระเบิด ("/", $_SERVER["REQUEST_URI"]); // รับ ชื่อคอนโทรลเลอร์ if (!empty($routes)) ( $controller_name = $routes; ) // รับชื่อการกระทำ if (!empty($routes)) ( $action_name = $routes; ) // เพิ่มคำนำหน้า $model_name = " Model_ ".$controller_name; $controller_name = "Controller_".$controller_name; $action_name = "action_".$action_name; // ขอไฟล์ด้วยคลาสโมเดล (อาจไม่มีไฟล์โมเดล) $model_file = strtolower($model_name ). ".php"; $model_path = "application/models/".$model_file; if(file_exists($model_path)) ( include "application/models/".$model_file; ) // ขอไฟล์คลาสคอนโทรลเลอร์ $controller_file = strtolower ($controller_name).".php"; $controller_path = "application/controllers/".$controller_file; if(file_exists($controller_path)) ( รวม "application/controllers/".$controller_file; ) อื่น ( /* จะเป็นการถูกต้องที่จะโยนข้อยกเว้นที่นี่ แต่เพื่อความง่าย เราจะเปลี่ยนเส้นทางไปที่หน้า 404 ทันที */ เส้นทาง::ErrorPage404(); ) // สร้างตัวควบคุม $controller = ใหม่ $controller_name; $action = $action_name; if(method_exists($controller, $action)) ( // เรียกแอคชั่นคอนโทรลเลอร์ $controller->$action(); ) อื่น ( // มันสมเหตุสมผลกว่าที่จะโยนข้อยกเว้นที่นี่ Route::ErrorPage404(); ) ) ฟังก์ชัน ErrorPage404( ) ( $host = "http://".$_SERVER["HTTP_HOST"]."/"; header("HTTP/1.1 404 Not Found"); header("Status: 404 Not Found" ); header(" ที่ตั้ง:".$host.404"); ) )
ฉันทราบว่าคลาสใช้ตรรกะที่เรียบง่ายมาก (แม้จะมีโค้ดมากมาย) และอาจมีปัญหาด้านความปลอดภัยด้วยซ้ำ สิ่งนี้ทำโดยเจตนาเพราะ การเขียนคลาสการกำหนดเส้นทางแบบเต็มสมควรได้รับบทความแยกต่างหากเป็นอย่างน้อย มาดูประเด็นหลักๆ...
องค์ประกอบอาร์เรย์ส่วนกลาง $_SERVER["REQUEST_URI"] ประกอบด้วย ที่อยู่เต็มที่ผู้ใช้นำไปใช้
ตัวอย่างเช่น: example.ru/contacts/feedback
การใช้ฟังก์ชั่น ระเบิดที่อยู่แบ่งออกเป็นส่วนประกอบ เป็นผลให้เราได้รับชื่อของตัวควบคุม ตัวอย่างเช่น นี่คือตัวควบคุม ติดต่อและชื่อของการกระทำ ในกรณีของเรา - ข้อเสนอแนะ.
ถัดไป เชื่อมต่อไฟล์โมเดล (โมเดลอาจหายไป) และไฟล์คอนโทรลเลอร์ (ถ้ามี) และสุดท้าย อินสแตนซ์ของคอนโทรลเลอร์จะถูกสร้างขึ้นและการดำเนินการจะถูกเรียกอีกครั้ง หากมีการอธิบายไว้ในคลาสคอนโทรลเลอร์
ตัวอย่างเช่น เมื่อคุณไปที่ที่อยู่:
example.com/portfolio
หรือ
example.com/portfolio/index
เราเตอร์จะดำเนินการต่อไปนี้:
- เชื่อมต่อไฟล์ model_portfolio.php จากโฟลเดอร์รุ่นที่มีคลาส Model_Portfolio
- รวมไฟล์ controller_portfolio.php จากโฟลเดอร์ controllers ที่มีคลาส Controller_Portfolio
- จะสร้างอินสแตนซ์ของคลาส Controller_Portfolio และเรียกใช้การดำเนินการเริ่มต้น - action_index ที่อธิบายไว้
example.com/ufo
จากนั้นจะถูกเปลี่ยนเส้นทางไปยังหน้า 404:
ตัวอย่าง.com/404
สิ่งเดียวกันนี้จะเกิดขึ้นหากผู้ใช้เข้าถึงการกระทำที่ไม่ได้อธิบายไว้ในคอนโทรลเลอร์
2.2. กลับไปที่การดำเนินการ MVC
ไปที่โฟลเดอร์หลักและเพิ่มไฟล์อีกสามไฟล์ในไฟล์ route.php: model.php, view.php และ controller.php
ฉันขอเตือนคุณว่าพวกเขาจะมีคลาสพื้นฐานซึ่งตอนนี้เราจะเริ่มเขียน
เนื้อหาไฟล์ model.php
โมเดลคลาส ( ฟังก์ชันสาธารณะ get_data() ( ) )
คลาสโมเดลมีเมธอดดึงข้อมูลเปล่าเพียงวิธีเดียวที่จะถูกแทนที่ในคลาสที่สืบทอดมา เมื่อเราสร้างคลาสลูกหลาน ทุกอย่างจะชัดเจนขึ้น
เนื้อหาไฟล์ view.php
class View ( //public $ template_view; // ที่นี่คุณสามารถระบุมุมมองสาธารณะเริ่มต้นได้ ฟังก์ชั่น create($content_view, $template_view, $data = null) ( /* if(is_array($data)) ( // แปลงอาร์เรย์ องค์ประกอบลงในตัวแปร extract($data); ) */ include "application/views/".$template_view; ) )
เดาได้ไม่ยากว่าวิธีการ สร้างออกแบบมาเพื่อสร้างมุมมอง พารามิเตอร์ต่อไปนี้ถูกส่งไป:
- $content_file - มุมมองที่แสดงเนื้อหาของหน้า;
- $ template_file - เทมเพลตทั่วไปสำหรับทุกหน้า
- $data เป็นอาร์เรย์ที่มีองค์ประกอบเนื้อหาของหน้า มักจะเติมในรุ่น
เพื่อแสดงเนื้อหาของหน้าใดหน้าหนึ่ง
ในกรณีของเรา เทมเพลตทั่วไปจะมีส่วนหัว เมนู แถบด้านข้าง และส่วนท้าย และเนื้อหาของหน้าต่างๆ จะอยู่ในรูปแบบแยกต่างหาก อีกครั้งนี้ทำเพื่อความเรียบง่าย
เนื้อหาไฟล์ controller.php
คลาสคอนโทรลเลอร์ ( สาธารณะ $model; สาธารณะ $view; ฟังก์ชัน __construct() ( $this->view = new View(); ) ฟังก์ชัน action_index() ( ) )
วิธี action_indexเป็นการกระทำที่เรียกโดยค่าเริ่มต้น เราจะแทนที่การกระทำนั้นเมื่อใช้คลาสที่สืบทอดมา
2.3. การใช้คลาสลูกหลานของ Model และ Controller สร้าง View's
ตอนนี้ความสนุกเริ่มต้นขึ้นแล้ว! เว็บไซต์นามบัตรของเราจะประกอบด้วยหน้าต่างๆ ดังต่อไปนี้:- บ้าน
- บริการ
- ผลงาน
- ติดต่อ
- และ - หน้า "404"
ไฟล์ถูกเน้นในรูปก่อนหน้า template_view.phpเป็นเทมเพลตที่มีมาร์กอัปทั่วไปสำหรับทุกหน้า ในกรณีที่ง่ายที่สุด อาจมีลักษณะดังนี้:
เพื่อให้ไซต์ดูเรียบร้อย เราจะสร้างเทมเพลต CSS และรวมเข้ากับไซต์ของเราโดยเปลี่ยนโครงสร้างของมาร์กอัป HTML และ การเชื่อมต่อ CSSและไฟล์ JavaScript:
ในตอนท้ายของบทความ ในส่วน "ผลลัพธ์" มีลิงก์ไปยังที่เก็บ GitHub พร้อมโครงการที่มีการรวมเทมเพลตอย่างง่าย
2.3.1. การสร้างหน้าหลัก
เริ่มจากคอนโทรลเลอร์กันก่อน controller_main.phpนี่คือรหัสของมัน:คลาส Controller_Main ขยาย Controller ( function action_index() ( $this->view->generate("main_view.php", " template_view.php"); ) )
วิธีการ สร้างอินสแตนซ์ของคลาส View ชื่อของไฟล์ของเทมเพลตทั่วไปและมุมมองที่มีเนื้อหาของเพจจะถูกส่งผ่าน
นอกเหนือจากการดำเนินการดัชนีแล้ว คอนโทรลเลอร์สามารถมีการดำเนินการอื่น ๆ ได้
ไฟล์จาก ปริทัศน์เราได้ตรวจสอบก่อนหน้านี้ พิจารณาไฟล์เนื้อหา main_view.php:
ยินดีต้อนรับ!
OLOSHA TEAM คือทีมผู้เชี่ยวชาญด้านการพัฒนาเว็บไซต์ชั้นหนึ่งที่มีประสบการณ์หลายปีในการสะสมหน้ากากเม็กซิกัน รูปปั้นทองสัมฤทธิ์และหินจากอินเดียและซีลอน ภาพนูนต่ำนูนต่ำ และประติมากรรมที่สร้างโดยปรมาจารย์แห่งอิเควทอเรียลแอฟริกาเมื่อห้าหรือหกศตวรรษก่อน.. .
ประกอบด้วยมาร์กอัปอย่างง่ายโดยไม่ต้องเรียกใช้ PHP
ในการแสดงหน้าหลัก คุณสามารถใช้หนึ่งในที่อยู่ต่อไปนี้:
ตัวอย่างของการใช้มุมมองที่แสดงข้อมูลที่ได้รับจากแบบจำลองจะกล่าวถึงในภายหลัง
2.3.2. การสร้างหน้าผลงาน
ในกรณีของเรา หน้า Portfolio เป็นหน้าเดียวที่ใช้โมเดลแบบจำลองมักจะมีวิธีการดึงข้อมูล ตัวอย่างเช่น:
- วิธีการของไลบรารี pgsql หรือ mysql ดั้งเดิม
- วิธีการของห้องสมุดที่ใช้ข้อมูลที่เป็นนามธรรม ตัวอย่างเช่น วิธีการของไลบรารี PEAR MDB2;
- วิธี ORM;
- วิธีการทำงานกับ NoSQL
- และอื่น ๆ.
ไฟล์โมเดล model_portfolio.phpใส่ในโฟลเดอร์รุ่น นี่คือเนื้อหา:
class Model_Portfolio ขยาย Model ( ฟังก์ชันสาธารณะ get_data() ( return array(array("Year" => "2012", "Site" => "http://DunkelBeer.ru", "Description" => "Dark Dunkel beer จาก Löwenbraü ผู้ผลิตสัญชาติเยอรมัน ผลิตในรัสเซียโดยบริษัทผลิตเบียร์ "SUN InBev""), array("Year" => "2012", "Site" => "http://ZopoMobile.ru", "Description" => "แคตตาล็อกภาษารัสเซีย โทรศัพท์จีนโซโปออน ใช้ระบบแอนดรอยด์ OS และอุปกรณ์เสริม"), // todo); ) )
คลาสตัวควบคุมโมเดลมีอยู่ในไฟล์ controller_portfolio.phpนี่คือรหัสของมัน:
คลาส Controller_Portfolio ขยาย Controller ( function __construct() ( $this->model = new Model_Portfolio(); $this->view = new View(); ) ฟังก์ชัน action_index() ( $data = $this->model->get_data( ); $this->view->generate("portfolio_view.php", "template_view.php", $data); ) )
ลงในตัวแปร ข้อมูลอาร์เรย์ที่ส่งคืนโดยเมธอดถูกเขียนขึ้น get_dataซึ่งเราพิจารณาก่อนหน้านี้
ตัวแปรนี้จะถูกส่งผ่านเป็นพารามิเตอร์เมธอด สร้างซึ่งถูกส่งผ่านด้วย: ชื่อของไฟล์ที่มีเทมเพลตทั่วไปและชื่อของไฟล์ที่มีมุมมองที่มีเนื้อหาของเพจ
มุมมองที่มีเนื้อหาของเพจอยู่ในไฟล์ portfolio_view.php.
ผลงาน
| ปี | โครงการ | คำอธิบาย | ".$row["ปี"]." | ".$row["ไซต์"]." | ".$row["รายละเอียด"]." | "; } ?>
ทุกอย่างง่ายที่นี่ มุมมองแสดงข้อมูลที่ได้รับจากแบบจำลอง
2.3.3. สร้างส่วนที่เหลือของหน้า
หน้าที่เหลือถูกสร้างขึ้นในลักษณะเดียวกัน รหัสของพวกเขามีอยู่ในพื้นที่เก็บข้อมูลบน GitHub ซึ่งเป็นลิงก์ที่อยู่ท้ายบทความในส่วน "ผลลัพธ์"3. ผลลัพธ์
และนี่คือสิ่งที่เกิดขึ้นในตอนท้าย:ภาพหน้าจอของไซต์นามบัตรที่ได้
ลิงก์ไปยัง GitHub: https://github.com/vitalyswipe/tinymvc/zipball/v0.1
แต่ในเวอร์ชันนี้ ฉันได้ร่างคลาสต่อไปนี้ (และประเภทที่สอดคล้องกัน):
- Controller_Login ซึ่งมุมมองถูกสร้างขึ้นด้วยแบบฟอร์มสำหรับการเข้าสู่ระบบและรหัสผ่าน หลังจากนั้นจะดำเนินการตามขั้นตอนการตรวจสอบสิทธิ์ และหากสำเร็จ ผู้ใช้จะถูกเปลี่ยนเส้นทางไปยังแผงการดูแลระบบ
- Contorller_Admin พร้อมการดำเนินการดัชนีที่ตรวจสอบว่าผู้ใช้เคยได้รับอนุญาตบนไซต์ในฐานะผู้ดูแลระบบมาก่อนหรือไม่ (หากใช่ มุมมองผู้ดูแลระบบจะปรากฏขึ้น) และการดำเนินการออกจากระบบสำหรับการออกจากระบบ
4. บทสรุป
รูปแบบ MVC ถูกใช้เป็นพื้นฐานทางสถาปัตยกรรมในหลายเฟรมเวิร์กและ CMS ซึ่งถูกสร้างขึ้นเพื่อให้สามารถพัฒนาในเชิงคุณภาพได้ดีขึ้น การตัดสินใจที่ซับซ้อนสำหรับข้อมูลเพิ่มเติม ช่วงเวลาสั้น ๆ. สิ่งนี้เกิดขึ้นได้โดยการเพิ่มระดับของสิ่งที่เป็นนามธรรม เนื่องจากมีขีดจำกัดของความซับซ้อนของโครงสร้างที่สมองมนุษย์สามารถดำเนินการได้แต่การใช้เว็บเฟรมเวิร์กเช่น Yii หรือ Kohana ซึ่งประกอบด้วยไฟล์หลายร้อยไฟล์ เมื่อพัฒนาเว็บแอปพลิเคชันอย่างง่าย (เช่น ไซต์นามบัตร) ไม่แนะนำให้ทำเสมอไป ตอนนี้เราสามารถสร้างโมเดล MVC ที่สวยงามเพื่อไม่ให้โค้ด Php, Html, CSS และ JavaScript รวมกันในไฟล์เดียว
บทความนี้เป็นจุดเริ่มต้นสำหรับการเรียนรู้ CMF มากกว่าเป็นตัวอย่างของสิ่งที่ถูกต้องจริงๆ ซึ่งคุณสามารถใช้เป็นพื้นฐานของเว็บแอปพลิเคชันของคุณได้ บางทีมันอาจจะเป็นแรงบันดาลใจให้คุณและคุณกำลังคิดที่จะเขียนไมโครเฟรมเวิร์กหรือ CMS ของคุณเองโดยใช้ MVC แต่ก่อนที่จะประดิษฐ์วงล้อต่อไปด้วย "กระบองและโสเภณี" ให้คิดอีกครั้ง มันอาจจะเป็นการดีกว่าถ้าคุณมุ่งความสนใจไปที่การพัฒนาและช่วยเหลือชุมชนของโครงการที่มีอยู่!
ป.ล.: บทความนี้เขียนขึ้นใหม่โดยคำนึงถึงความคิดเห็นบางส่วนที่เหลืออยู่ในความคิดเห็น คำติชมมีประโยชน์มาก เมื่อพิจารณาจากคำตอบ: ความคิดเห็น การอุทธรณ์ส่วนบุคคล และจำนวนผู้ใช้ที่เพิ่มโพสต์ในรายการโปรด แนวคิดในการเขียนโพสต์นี้กลายเป็นว่าไม่เลวทีเดียว น่าเสียดายที่มันเป็นไปไม่ได้ที่จะคำนึงถึงความปรารถนาทั้งหมดและเขียนรายละเอียดมากขึ้นและมากขึ้นเนื่องจากไม่มีเวลา ... แต่บางทีบุคคลลึกลับเหล่านั้นที่ลบเวอร์ชันดั้งเดิมจะทำเช่นนี้ ขอให้โชคดีกับโครงการของคุณ!
5. การเลือกลิงค์ที่มีประโยชน์ในหัวข้อ
บทความมักจะกล่าวถึงหัวข้อของเว็บเฟรมเวิร์ก ซึ่งเป็นหัวข้อที่กว้างขวางมาก เพราะแม้แต่ไมโครเฟรมเวิร์กก็ประกอบด้วยองค์ประกอบมากมายที่เชื่อมโยงกันอย่างชาญฉลาด และอาจต้องใช้บทความมากกว่าหนึ่งบทความเพื่อพูดคุยเกี่ยวกับองค์ประกอบเหล่านี้ อย่างไรก็ตาม ฉันตัดสินใจที่จะให้ลิงก์เล็ก ๆ ที่เลือกไว้ที่นี่ (ซึ่งฉันไปในขณะที่เขียนบทความนี้) ซึ่งเกี่ยวข้องกับหัวข้อของเฟรมเวิร์กไม่ทางใดก็ทางหนึ่งแท็ก: เพิ่มแท็ก
ลวดลาย Model-View-Controller (MVC)ซึ่งค้นพบในช่วงปลายทศวรรษที่ 1970 เป็นรูปแบบการออกแบบสถาปัตยกรรม ซอฟต์แวร์ซึ่งมีหน้าที่หลักในการแยกฟังก์ชั่นการทำงานกับข้อมูลจากงานนำเสนอ ตามทฤษฎีแล้ว แอปพลิเคชัน MVC ที่ออกแบบมาอย่างดีจะช่วยให้นักพัฒนาส่วนหน้าและส่วนหลังไม่ก้าวก่ายความรับผิดชอบของกันและกันระหว่างการทำงาน กล่าวคือ ผู้พัฒนาส่วนหน้าไม่จำเป็นต้องรู้อะไรเกี่ยวกับ "ครัว" ของ เพื่อนร่วมงานส่วนหลังของเขาและในทางกลับกัน
แม้ว่าเดิมที MVC ได้รับการออกแบบมาสำหรับการพัฒนาแอปพลิเคชันบนเดสก์ท็อป แต่ก็ได้รับการปรับให้เหมาะกับ งานสมัยใหม่และเป็นที่นิยมอย่างมากในหมู่นักพัฒนาเว็บ เนื่องจากการแบ่งหน้าที่ความรับผิดชอบทำให้สามารถสร้างเว็บไซต์ที่ชัดเจนและพร้อมใช้งานได้มากขึ้น ใช้ซ้ำรหัส. รูปแบบ MVC นำไปสู่ระบบโมดูลาร์ที่ชัดเจนซึ่งช่วยให้นักพัฒนาสามารถเปลี่ยนแปลงโค้ดที่มีอยู่ได้อย่างรวดเร็ว
ในบทความนี้เราจะดูที่ หลักการพื้นฐาน MVC เริ่มต้นด้วยคำจำกัดความของรูปแบบและดำเนินการต่อด้วยการประยุกต์ใช้ในตัวอย่างเล็กๆ บทความนี้จะเป็นประโยชน์อย่างยิ่งสำหรับผู้ที่ไม่เคยพบรูปแบบนี้มาก่อนในชีวิต และบางทีอาจรวมถึงผู้ที่ต้องการฟื้นฟูความรู้เกี่ยวกับ MVC
ทำความเข้าใจกับ MVC
ดังที่ได้กล่าวแล้วว่าชื่อลายมาจากคำย่อของคำสามคำคือ รุ่น (รุ่น), ดู (ดู)และ คอนโทรลเลอร์ (คอนโทรลเลอร์). หลักการของรูปแบบโดยสังเขปสามารถแสดงด้วยแผนภาพเดียว (สามารถพบได้ใน Wikipedia):
ไดอะแกรมนี้แสดงการไหลของข้อมูลทิศทางเดียวในรูปแบบอย่างชัดเจน และยังอธิบายถึงบทบาทของแต่ละองค์ประกอบด้วย
แบบอย่าง
โมเดลนี้ใช้เพื่อเข้าถึงและจัดการข้อมูล ในกรณีส่วนใหญ่ โมเดลคือสิ่งที่ใช้ในการเข้าถึงที่เก็บข้อมูล (เช่น ฐานข้อมูล) โมเดลจัดเตรียมอินเทอร์เฟซสำหรับการดึงข้อมูล การสร้างข้อมูล การแก้ไข และการลบออกจากที่เก็บข้อมูล ในบริบทของรูปแบบ MVC โมเดลเป็นตัวกลางระหว่างมุมมองและตัวควบคุม
คุณสมบัติที่สำคัญอย่างยิ่งของโมเดลคือไม่มีความรู้ในทางเทคนิคว่าเกิดอะไรขึ้นกับข้อมูลในตัวควบคุมและมุมมอง แบบจำลองไม่ควรสร้างหรือคาดหวังคำขอใด ๆ จากส่วนประกอบอื่น ๆ ของรูปแบบ
อย่างไรก็ตาม โปรดจำไว้เสมอว่าแบบจำลองไม่ได้เป็นเพียงเกตเวย์การเข้าถึงไปยังฐานข้อมูลหรือระบบอื่นๆ ซึ่งเกี่ยวกับการส่งข้อมูลไปมา โมเดลเป็นเหมือนประตูสู่ข้อมูล โมเดลมักเป็นส่วนที่ซับซ้อนที่สุดของระบบ ส่วนหนึ่งเป็นเพราะตัวโมเดลเป็นตัวเชื่อมไปยังส่วนอื่นๆ ทั้งหมด
ผลงาน
มุมมองคือที่ซึ่งข้อมูลที่ได้รับจากโมเดลแสดงอยู่ แบบฟอร์มที่ต้องการ. ในเว็บแอปพลิเคชันแบบดั้งเดิมที่พัฒนาในรูปแบบ MVC มุมมองเป็นส่วนหนึ่งของระบบที่สร้างโค้ด HTML มุมมองยังรับผิดชอบในการรับการดำเนินการจากผู้ใช้เพื่อส่งไปยังตัวควบคุม ตัวอย่างเช่น มุมมองแสดงปุ่มใน หน้าจอผู้ใช้และหลังจากกด มันจะทำให้เกิดการทำงานของคอนโทรลเลอร์ที่สอดคล้องกัน
มีความเข้าใจผิดบางประการเกี่ยวกับวัตถุประสงค์ของการดู โดยเฉพาะอย่างยิ่งในหมู่นักพัฒนาเว็บที่เพิ่งเริ่มสร้างแอปพลิเคชันโดยใช้ MVC หนึ่งในกฎที่ถูกละเมิดบ่อยที่สุดคือ มุมมองไม่ควรสื่อสารกับตัวแบบ แต่อย่างใด, และทั้งหมด ข้อมูลที่ได้รับจากมุมมองควรมาจากตัวควบคุมเท่านั้น. ในทางปฏิบัติ นักพัฒนามักจะละเลยแนวคิดนี้ ซึ่งเป็นหัวใจของรูปแบบ MVC บทความของ Fabio Cevasco แสดงให้เห็นถึงแนวทางที่สับสนนี้สำหรับ MVC กับ CakePHP ซึ่งเป็นหนึ่งในเฟรมเวิร์ก MVC ที่ไม่ได้มาตรฐาน:
สิ่งสำคัญอย่างยิ่งที่ต้องเข้าใจว่าเพื่อให้ได้สถาปัตยกรรม MVC ที่เหมาะสม ไม่ควรมีการโต้ตอบโดยตรงระหว่างมุมมองและแบบจำลอง ตรรกะทั้งหมดของการแลกเปลี่ยนข้อมูลระหว่างกันจะต้องนำไปใช้ในคอนโทรลเลอร์
นอกจากนี้ยังมีความเข้าใจผิดทั่วไปว่ามุมมองเป็นเพียงไฟล์เทมเพลต ดังที่ Tom Butler ชี้ให้เห็น ความเข้าใจผิดนี้มีขอบเขตกว้างขวาง เนื่องจากนักพัฒนาจำนวนมากเข้าใจโครงสร้าง MVC ผิดตั้งแต่ต้น หลังจากนั้นนักพัฒนามือใหม่จำนวนมากก็เริ่มใส่ "ความรู้" นี้เพิ่มเติม ในความเป็นจริง มุมมองเป็นมากกว่าแค่เทมเพลต แต่เฟรมเวิร์กจำนวนมากที่ใช้รูปแบบ MVC ได้บิดแนวคิดของมุมมองมากจนไม่มีใครสนใจว่าแอปพลิเคชันของพวกเขาจะถูกต้องเพียงใดจากมุมมองของรูปแบบ MVC
ประเด็นสำคัญอีกประการหนึ่งคือ มุมมองไม่เคยทำงานกับข้อมูล "บริสุทธิ์" จากตัวควบคุม นั่นคือ ตัวควบคุมไม่เคยทำงานกับมุมมอง โดยผ่านโมเดล ในกระบวนการโต้ตอบระหว่างตัวควบคุมและมุมมอง โมเดลจะต้องอยู่ระหว่างพวกเขาเสมอ
ผู้ควบคุม
คอนโทรลเลอร์เป็นส่วนสุดท้ายของบันเดิล MVC งานของผู้ควบคุมคือการรับข้อมูลจากผู้ใช้และจัดการแบบจำลอง เป็นตัวควบคุมและมีเพียงเขาเท่านั้นที่เป็นส่วนหนึ่งของระบบที่โต้ตอบกับผู้ใช้
โดยสรุปแล้ว คอนโทรลเลอร์สามารถอธิบายได้ว่าเป็นตัวรวบรวมข้อมูลที่ส่งผ่านไปยังโมเดลเพื่อประมวลผลและจัดเก็บ เขาไม่ควรทำอะไรกับข้อมูล แต่สามารถรับได้จากผู้ใช้เท่านั้น คอนโทรลเลอร์เชื่อมโยงกับมุมมองเดียวและโมเดลเดียว ดังนั้นการจัดระเบียบการไหลของข้อมูลทางเดียวจึงควบคุมในแต่ละขั้นตอน
สิ่งสำคัญคือต้องจำไว้ว่าตัวควบคุมจะเริ่มทำงานเนื่องจากการโต้ตอบของผู้ใช้กับมุมมองซึ่งเรียกฟังก์ชันตัวควบคุมที่เกี่ยวข้อง ข้อผิดพลาดที่พบบ่อยที่สุดในหมู่นักพัฒนาซอฟต์แวร์คือตัวควบคุมเป็นเพียงเกตเวย์ระหว่างมุมมองและโมเดล ด้วยเหตุนี้ คอนโทรลเลอร์จึงมีฟังก์ชันที่ควรดำเนินการโดยมุมมอง (อย่างไรก็ตาม นี่คือที่มาของแนวคิดที่ว่ามุมมองเป็นเพียงไฟล์เทมเพลต) ยิ่งไปกว่านั้น หลายคนมักจะทิ้งตรรกะทั้งหมดของการประมวลผลข้อมูล โดยลืมไปว่าโมเดลมีไว้สำหรับรูปแบบ MVC อย่างไร
MVC ใน PHP
ฉันเสนอให้ลองใช้ข้างต้นในแอปพลิเคชันขนาดเล็ก เริ่มต้นด้วยการสร้างโมเดล มุมมอง และคลาสคอนโทรลเลอร์:
string = "MVC + PHP = สุดยอด!"; ) )คอนโทรลเลอร์ = $คอนโทรลเลอร์; $นี้->
" . $this->model->string "
"; } } โมเดล = $โมเดล; ) )ชั้นเรียนหลักพร้อมแล้ว ตอนนี้มาเชื่อมโยงเข้าด้วยกันและเรียกใช้แอปพลิเคชันของเรา:
เอาต์พุต ();
อย่างที่คุณเห็น คอนโทรลเลอร์ไม่มีฟังก์ชันใดๆ เนื่องจากผู้ใช้ไม่ได้โต้ตอบกับแอปพลิเคชันแต่อย่างใด ฟังก์ชันทั้งหมดอยู่ในมุมมอง เนื่องจากแอปพลิเคชันของเรามีไว้สำหรับแสดงข้อมูลเท่านั้น
มาขยายแอปเล็กน้อยด้วยการโต้ตอบเพื่อดูว่าคอนโทรลเลอร์ทำงานอย่างไร:
string = "MVC + PHP = Awesome คลิกที่นี่!"; ) )คอนโทรลเลอร์ = $คอนโทรลเลอร์; $this->model = $รุ่น; ) เอาต์พุตฟังก์ชั่นสาธารณะ () ( กลับ "
model->string . "
"; } } โมเดล = $โมเดล; ) ฟังก์ชั่นสาธารณะ clicked() ( $this->model->string = “Updated Data, ขอบคุณ MVC และ PHP!” ) )และสุดท้าย มาปรับปรุงโค้ดเชื่อมโยงให้ทันสมัยกันสักหน่อย:
($_GET["การกระทำ"])(); ) echo $view->output();
ผลลัพธ์
ในบทความสั้นๆ นี้ เราได้กล่าวถึงแนวคิดพื้นฐานของรูปแบบการออกแบบ MVC และพัฒนาแอปพลิเคชันง่ายๆ ที่อิงจากรูปแบบนั้น แม้ว่าแน่นอนว่าเรายังห่างไกลจากความสามารถในการใช้สิ่งนี้ในชีวิตจริง ในบทความถัดไป เราจะพิจารณาปัญหาหลักที่คุณจะพบหากคุณพิจารณาอย่างละเอียดเกี่ยวกับการสร้างสถาปัตยกรรมแอปพลิเคชันตามรูปแบบ MVC คอยติดตาม!
อัพเดทล่าสุด: 31.10.2015
คอนโทรลเลอร์เป็นองค์ประกอบหลักในสถาปัตยกรรม MVC ตัวควบคุมรับอินพุตของผู้ใช้ ประมวลผล และส่งกลับผลลัพธ์ของการประมวลผล เช่น เป็นมุมมอง
มีข้อกำหนดบางประการเมื่อใช้ตัวควบคุม ดังนั้น ตามหลักการตั้งชื่อ ชื่อคอนโทรลเลอร์ต้องลงท้ายด้วย "คอนโทรลเลอร์" ส่วนต่อท้าย "คอนโทรลเลอร์" ในขณะที่ส่วนที่เหลือก่อนต่อท้ายนี้จะถือเป็นชื่อของคอนโทรลเลอร์
ในการติดต่อคอนโทรลเลอร์จากเว็บเบราว์เซอร์ เราจำเป็นต้องพิมพ์แถบที่อยู่ site_url/controller_name/. ตัวอย่างเช่น สำหรับคำขอ site_address/Home/ ระบบการกำหนดเส้นทางเริ่มต้นจะเรียกเมธอด Index ของ HomeController เพื่อจัดการกับคำขอที่เข้ามา หากเราต้องการส่งคำขอไปยังวิธีการควบคุมเฉพาะ เราจำเป็นต้องระบุวิธีการนี้อย่างชัดเจน: site_url/controller_name/controller_method, ตัวอย่างเช่น, website_url/หน้าแรก/ซื้อ- เรียกเมธอด Buy ของคอนโทรลเลอร์ HomeController
คอนโทรลเลอร์คือคลาสปกติที่สืบทอดมาจากคลาสฐาน System.Web.Mvc.Controller ในทางกลับกัน คลาสคอนโทรลเลอร์จะใช้คลาสฐานนามธรรม ControllerBase และผ่านอินเตอร์เฟส IController ดังนั้น เพื่อสร้างคลาสคอนโทรลเลอร์ของคุณเองอย่างเป็นทางการ การสร้างคลาสที่ใช้อินเตอร์เฟส IController และมีส่วนต่อท้ายชื่อก็เพียงพอแล้ว ผู้ควบคุม.
อินเตอร์เฟส IController กำหนดวิธี Execute หนึ่งวิธี ซึ่งรับผิดชอบในการจัดการบริบทคำขอ:
IController อินเทอร์เฟซสาธารณะ ( void Execute (RequestContext requestContext); )
ตอนนี้เรามาสร้างคอนโทรลเลอร์อย่างง่ายที่ใช้อินเทอร์เฟซนี้ ในฐานะที่เป็นโครงการเราสามารถนำโครงการจากบทที่แล้ว ดังนั้น มาเพิ่มคลาสใหม่ในโฟลเดอร์ Controllers ของโปรเจ็กต์ (กล่าวคือ คลาส ไม่ใช่คอนโทรลเลอร์) โดยมีเนื้อหาดังต่อไปนี้:
ใช้ System.Web.Mvc; ใช้ System.Web.Routing; namespace BookStore.Controllers ( MyController คลาสสาธารณะ: IController ( โมฆะสาธารณะ Execute (RequestContext requestContext) ( string ip = requestContext.HttpContext.Request.UserHostAddress; var response = requestContext.HttpContext.Response; response.Write("
ที่อยู่ IP ของคุณ: " + ip + "
"); } } }เมื่อเข้าถึงตัวควบคุมใด ๆ ระบบจะส่งผ่านบริบทคำขอไปยังตัวควบคุมนั้น ทุกอย่างรวมอยู่ในบริบทคำขอนี้: คุกกี้ ข้อมูลแบบฟอร์มที่ส่ง สตริงข้อความค้นหา ข้อมูลประจำตัวของผู้ใช้ และอื่นๆ การใช้อินเตอร์เฟส IController ช่วยให้คุณได้รับบริบทคำขอนี้ในเมธอด Execute ผ่านพารามิเตอร์ RequestContext ในกรณีของเรา เราได้รับที่อยู่ IP ของผู้ใช้ผ่านคุณสมบัติ requestContext.HttpContext.Request.UserHostAddress
นอกจากนี้ เราสามารถส่งการตอบกลับไปยังผู้ใช้โดยใช้วัตถุตอบกลับและวิธีการเขียนของมัน
ดังนั้น ตามเส้นทาง site_address/My/ ผู้ใช้จะเห็นที่อยู่ IP ของเขา
แม้ว่าการสร้างคอนโทรลเลอร์โดยใช้อินเทอร์เฟส IController จะเป็นเรื่องง่ายมาก แต่ในความเป็นจริงแล้ว การดำเนินการกับคลาสระดับสูงกว่านั้นเป็นเรื่องปกติมากกว่า เช่น คลาสคอนโทรลเลอร์ เนื่องจากเป็นวิธีที่มีประสิทธิภาพมากกว่าสำหรับการประมวลผลคำร้องขอ และถ้าเมื่อใช้งานอินเทอร์เฟซ IController เรากำลังจัดการกับวิธี Execute หนึ่งวิธี และคำขอทั้งหมดไปยังคอนโทรลเลอร์นี้จะถูกประมวลผลด้วยวิธีเดียวเท่านั้น จากนั้นเมื่อสืบทอดคลาสคอนโทรลเลอร์ เราสามารถสร้างวิธีการดำเนินการมากมายที่จะรับผิดชอบในการประมวลผล คำขอที่เข้ามาและส่งคืนผลลัพธ์การดำเนินการที่แตกต่างกัน
ในการสร้างคอนโทรลเลอร์มาตรฐาน เรายังสามารถเพิ่มคลาสอย่างง่ายในโฟลเดอร์คอนโทรลเลอร์และสืบทอดจากคลาสคอนโทรลเลอร์ เช่น:
ใช้ System.Web.Mvc; Namespace BookStore.Controllers ( BookShopController คลาสสาธารณะ: Controller ( Public ActionResult Index() ( return View(); ) ) )
อย่างไรก็ตาม Visual Studio นำเสนอเครื่องมือที่สะดวกกว่าสำหรับการสร้างคอนโทรลเลอร์ ซึ่งช่วยให้สามารถกำหนดค่าได้อย่างยืดหยุ่น หากต้องการใช้ ให้คลิกขวาที่โฟลเดอร์ Controllers แล้วเลือก เพิ่ม -> คอนโทรลเลอร์.... หลังจากนั้นเราจะเห็นหน้าต่างสำหรับสร้างคอนโทรลเลอร์ใหม่:
ที่จริงแล้ว สามจุดแรกเกี่ยวข้องโดยตรงกับคอนโทรลเลอร์ MVC 5 ที่นี่ ส่วนที่เหลือเกี่ยวข้องกับ Web API 2 มากกว่า ในรายการนี้ เลือกรายการแรก - ตัวควบคุม MVC 5 - ว่าง ซึ่งหมายถึงการสร้างตัวควบคุมว่าง จุดที่เหลืออีกสองจุดให้คุณสร้างคลาสที่มีฟังก์ชัน CRUD ตามเทมเพลตการสร้าง ซึ่งเราจะพูดถึงในหัวข้อเกี่ยวกับโมเดล
ต่อไป เราจะได้รับแจ้งให้ป้อนชื่อ และหลังจากนั้น ตัวควบคุมใหม่ด้วยวิธี Index เดียวจะถูกเพิ่มในโครงการ ด้วยการเพิ่มนี้ ซึ่งแตกต่างจากตัวอย่างก่อนหน้านี้ ไดเร็กทอรีจะถูกสร้างขึ้นโดยอัตโนมัติสำหรับคอนโทรลเลอร์นี้ในโฟลเดอร์ Views ซึ่งจะจัดเก็บมุมมองทั้งหมดที่เกี่ยวข้องกับการดำเนินการของคอนโทรลเลอร์นี้
หลักการของ MVCในการเขียนโปรแกรมเว็บ (Model - View - Controller, Model - View (View) - Controller) - หนึ่งในแนวคิดที่ประสบความสำเร็จมากที่สุดในปัจจุบัน หลักการของ MVCใช้งานง่ายในแวบแรก แต่ไม่ง่ายที่จะเจาะลึก ก่อนอื่นมาดูกันว่ามันมีไว้เพื่ออะไร
หลักการของ MVCช่วยให้คุณสามารถแยกการใช้งานตรรกะของแอปพลิเคชัน ลักษณะที่ปรากฏ (อินเทอร์เฟซแบบกราฟิก GUI) และการโต้ตอบกับผู้ใช้
สิ่งนี้นำไปสู่โค้ดที่มีโครงสร้างมากขึ้น ช่วยให้บุคลากรที่มีความเชี่ยวชาญมากขึ้นสามารถทำงานในโครงการ ทำให้โค้ดง่ายต่อการบำรุงรักษา ทำให้มีเหตุผลและเข้าใจได้มากขึ้น การเปลี่ยนแปลงองค์ประกอบใดองค์ประกอบหนึ่งมีผลกระทบน้อยที่สุดต่อองค์ประกอบอื่นๆ คุณสามารถเชื่อมต่อประเภทต่าง ๆ ตัวควบคุมต่าง ๆ กับรุ่นเดียว
ในทางกลับกัน สิ่งนี้ต้องการประสิทธิภาพที่มากขึ้นของเครื่องดำเนินการ แต่นี่ไม่ใช่ปัญหาใหญ่เมื่อเร็ว ๆ นี้ - โซลูชันการเขียนโปรแกรมที่ซับซ้อนมากขึ้นต้องการการสนับสนุน และค่าใช้จ่ายในการสนับสนุนจะสูงกว่าต้นทุนของอุปกรณ์สมัยใหม่ที่ทรงพลังกว่ามาก
หลักการของ MVCใช้โดยกรอบที่ทันสมัยเกือบทั้งหมด
มาดูส่วนประกอบกันดีกว่า
แบบอย่าง(แบบอย่าง) - มีสิ่งที่เรียกว่า "ตรรกะทางธุรกิจ" - การประมวลผลและการตรวจสอบข้อมูล การเข้าถึงฐานข้อมูล แสดงถึงโครงสร้างภายในของระบบ โมเดลไม่ควรโต้ตอบโดยตรงกับผู้ใช้
ดู(ดู ดู)อธิบายลักษณะที่ปรากฏของแอปพลิเคชัน
ผู้ควบคุม- การเชื่อมโยงระหว่างโมเดลกับวิว รับข้อมูลจากผู้ใช้ ส่งต่อไปยังโมเดล รับผลการประมวลผลแล้วส่งต่อไปยังวิว
ความสัมพันธ์สามารถเห็นได้ในแผนภาพ:
แหล่งที่มาของรูปภาพ: http://www.wikipedia.org ข้อกำหนดส่วนประกอบ:
รุ่น:
- ต้องมีคุณสมบัติที่แสดงถึงข้อมูลเฉพาะ
- ควรรวมตรรกะทางธุรกิจ (เช่น กฎการตรวจสอบ) เพื่อให้แน่ใจว่าข้อมูลเป็นไปตามข้อกำหนด
- อาจมีรหัสสำหรับการทำงานกับข้อมูล
- ควรมีมาร์กอัปเป็นหลัก เช่น HTML และโค้ด PHP อย่างง่ายที่ใช้ในการสำรวจ จัดรูปแบบ และแสดงข้อมูล
- ไม่ควรเข้าถึงฐานข้อมูลโดยตรง นางแบบควรทำเช่นนี้
- ไม่ควรเข้าถึงโดยตรง $_GET , $_POST และตัวแปรอื่น ๆ ที่ได้รับจากคำขอของผู้ใช้ งานนี้ต้องดำเนินการโดยผู้ควบคุม ควรใช้มุมมองเพื่อจัดรูปแบบข้อมูลที่ได้รับจากคอนโทรลเลอร์และโมเดลเท่านั้น
- สามารถเข้าถึงคุณสมบัติและวิธีการของคอนโทรลเลอร์หรือโมเดลได้โดยตรง อย่างไรก็ตาม ควรทำเพื่อจุดประสงค์ในการแสดงข้อมูลเท่านั้น
- สามารถเข้าถึง $_GET , $_POST และตัวแปร PHP อื่น ๆ ที่ได้รับจากคำขอของผู้ใช้
- สามารถสร้างและจัดการอินสแตนซ์ของโมเดลได้ ตัวอย่างเช่น ในการดำเนินการอัปเดตโมเดลทั่วไป คอนโทรลเลอร์อาจสร้างอินสแตนซ์ของโมเดลก่อน จากนั้นเติมข้อมูลจาก $_POST และหากโมเดลบันทึกสำเร็จ ให้เปลี่ยนเส้นทางเบราว์เซอร์ของผู้ใช้ไปยังหน้าของโมเดลที่สร้างขึ้น เป็นที่น่าสังเกตว่าการบันทึกโมเดลจะต้องนำไปใช้ในคลาสโมเดล ไม่ใช่ในคอนโทรลเลอร์
- จะต้องไม่มีแบบสอบถาม SQL พวกมันถูกเก็บไว้ในแบบจำลองอย่างดีที่สุด
- ต้องไม่มี HTML หรือมาร์กอัปอื่นๆ ก็สมควรนำมาจัดแสดง
นอกจากแนวคิด MVC แล้ว ยังมีแนวคิดอื่นๆ อีกมากมาย เช่น เคลื่อนไหว ( มเสื้อผ้า, อการดำเนินงาน วีวิวและ อีช่องระบายอากาศ) - คล้ายกับวิวัฒนาการ เอ็มวีซี(นำมาจากที่นี่: http://habrahabr.ru/post/147038/) แต่แนวคิดเหล่านี้พบได้น้อยกว่า
