ตอนที่ 7 แนะนำรูปแบบ MVC (Model-View-Controller)

เนื้อหานี้เป็นส่วนหนึ่งของชุด "ความรู้เบื้องต้นเกี่ยวกับการพัฒนาองค์กร" บทความก่อนหน้านี้:

• เกี่ยวกับเครือข่าย
• เกี่ยวกับสถาปัตยกรรมซอฟต์แวร์
• เกี่ยวกับ HTTP/HTTPS
• เกี่ยวกับพื้นฐานของ Maven
• เกี่ยวกับเซิร์ฟเล็ต (การเขียนเว็บแอปพลิเคชันอย่างง่าย)
• เกี่ยวกับคอนเทนเนอร์เซิร์ฟเล็ต

ในบทความนี้ เราจะมาทำความรู้จักกับบางสิ่งที่เรียกว่า MVC เราจะพูดถึงว่า MVC คืออะไร สัมผัสประวัติ สำรวจแนวคิดพื้นฐานและแนวคิดที่รวมอยู่ใน MVC ดูทีละขั้นตอนเกี่ยวกับวิธีแยกแอปพลิเคชันออกเป็นโมดูล Model, View และ Controller เขียน เว็บแอปพลิเคชันขนาดเล็กโดยใช้ Spring Boot และใช้ Spring MVC เป็นตัวอย่าง ดูว่าข้อมูลถูกส่งจากโค้ด Java ไปยังเพจ HTML อย่างไร เพื่อให้เข้าใจเนื้อหานี้ คุณต้องคุ้นเคยกับรูปแบบการออกแบบ โดยเฉพาะผู้สังเกตการณ์และด้านหน้าอาคาร และทำความคุ้นเคยกับคำขอและการตอบกลับ HTTP เข้าใจพื้นฐานของ HTML และรู้ว่าคำอธิบายประกอบของ Java คืออะไร หยิบกาแฟและของว่างสักแก้วแล้วสบายใจ เอาล่ะ.

ประวัติของ MVC

แนวคิดเบื้องหลัง MVC คิดค้นโดย Trygve Reenskaug ขณะที่ทำงานที่ Xerox PARC ในช่วงปลายทศวรรษ 1970 ในสมัยนั้น การทำงานกับคอมพิวเตอร์จำเป็นต้องมีปริญญาและการศึกษาเอกสารจำนวนมากอย่างต่อเนื่อง งานที่แก้ไขโดย Reenskaug ร่วมกับกลุ่มนักพัฒนาที่แข็งแกร่งมากคือการทำให้การโต้ตอบของผู้ใช้ทั่วไปกับคอมพิวเตอร์ง่ายขึ้น จำเป็นต้องสร้างเครื่องมือที่ในแง่หนึ่งจะเรียบง่ายและเข้าใจได้ง่ายมาก และในทางกลับกัน จะทำให้สามารถควบคุมคอมพิวเตอร์และแอปพลิเคชันที่ซับซ้อนได้ Reenskaug ทำงานในทีมที่พัฒนาคอมพิวเตอร์แล็ปท็อป "สำหรับเด็กทุกวัย" นั่นคือ Dynabook รวมถึงภาษา SmallTalk ภายใต้การนำของ Alan Kay นั่นคือเมื่อแนวคิดของอินเทอร์เฟซที่เป็นมิตรถูกวางลง ในหลายประการ งานที่ทำโดย Reenskaug และทีมของเขามีอิทธิพลต่อวิวัฒนาการของแวดวงไอที นี่คือข้อเท็จจริงที่น่าสนใจซึ่งใช้ไม่ได้กับ MVC โดยตรง แต่แสดงให้เห็นถึงความสำคัญของการพัฒนาเหล่านี้ อลัน เคย์พูดว่า, "ตอนที่ฉันมาที่ Apple ครั้งแรกในปี 84 Mac ก็เลิกผลิตไปแล้ว และ Newsweek ก็ติดต่อฉันและถามฉันว่าฉันคิดอย่างไรกับ Mac ฉันตอบว่า 'เอาล่ะ Mac เป็นคอมพิวเตอร์ส่วนบุคคลเครื่องแรกที่ดีพอที่จะ ถูกวิพากษ์วิจารณ์' ดังนั้น หลังจากประกาศ iPhone ในปี 2550 เขาก็หยิบมันมาให้ฉันและยื่นให้ฉัน เขาพูดว่า 'อลัน นี่ดีพอที่จะถูกวิจารณ์ไหม' และฉันก็พูดว่า 'สตีฟ ทำให้มันใหญ่เท่าแท็บเล็ตแล้วคุณจะครองโลก'" หลังจากผ่านไป 3 ปี ในวันที่ 27 มกราคม 2010 Apple ก็เปิดตัว iPad ที่มีขนาดเส้นทแยงมุม 9.7 นิ้ว กล่าวอีกนัยหนึ่ง Steve Jobs ทำตามคำแนะนำของ Alan Kay เกือบทุกประการ โครงการของ Reenskaug ใช้เวลา 10 ปี แต่การตีพิมพ์ครั้งแรกเกี่ยวกับ MVC ปรากฏขึ้นหลังจากนั้นอีก 10 ปี Martin Fowler ผู้เขียนหนังสือและบทความเกี่ยวกับสถาปัตยกรรมซอฟต์แวร์หลายเล่ม กล่าวว่าเขาศึกษา MVC โดยใช้ Smalltalk เวอร์ชันที่ใช้งานได้ เนื่องจากไม่มีข้อมูลเกี่ยวกับ MVC จากแหล่งต้นฉบับมาเป็นเวลานาน และด้วยเหตุผลอื่นๆ หลายประการ จึงมีการตีความแนวคิดนี้แตกต่างกันจำนวนมาก เป็นผลให้หลายคนคิดว่า MVC เป็นรูปแบบการออกแบบ โดยทั่วไปแล้ว MVC เรียกว่ารูปแบบคอมโพสิตหรือการรวมกันของรูปแบบต่างๆ ที่ทำงานร่วมกันเพื่อสร้างแอปพลิเคชันที่ซับซ้อน แต่ดังที่ได้กล่าวไว้ก่อนหน้านี้ MVC เป็นชุดของแนวคิด/หลักการ/แนวทางทางสถาปัตยกรรมเป็นหลัก ซึ่งสามารถนำไปใช้ได้หลายวิธีโดยใช้รูปแบบที่แตกต่างกัน... ต่อไป เราจะพิจารณาแนวคิดหลักที่ฝังอยู่ในแนวคิด MVC และด้วยเหตุผลอื่น ๆ การตีความแนวคิดนี้แตกต่างกันจำนวนมากปรากฏขึ้น เป็นผลให้หลายคนคิดว่า MVC เป็นรูปแบบการออกแบบ โดยทั่วไปแล้ว MVC เรียกว่ารูปแบบคอมโพสิตหรือการรวมกันของรูปแบบต่างๆ ที่ทำงานร่วมกันเพื่อสร้างแอปพลิเคชันที่ซับซ้อน แต่ดังที่ได้กล่าวไว้ก่อนหน้านี้ MVC เป็นชุดของแนวคิด/หลักการ/แนวทางทางสถาปัตยกรรมเป็นหลัก ซึ่งสามารถนำไปใช้ได้หลายวิธีโดยใช้รูปแบบที่แตกต่างกัน... ต่อไป เราจะพิจารณาแนวคิดหลักที่ฝังอยู่ในแนวคิด MVC และด้วยเหตุผลอื่น ๆ การตีความแนวคิดนี้แตกต่างกันจำนวนมากปรากฏขึ้น เป็นผลให้หลายคนคิดว่า MVC เป็นรูปแบบการออกแบบ โดยทั่วไปแล้ว MVC เรียกว่ารูปแบบคอมโพสิตหรือการรวมกันของรูปแบบต่างๆ ที่ทำงานร่วมกันเพื่อสร้างแอปพลิเคชันที่ซับซ้อน แต่ดังที่ได้กล่าวไว้ก่อนหน้านี้ MVC เป็นชุดของแนวคิด/หลักการ/แนวทางทางสถาปัตยกรรมเป็นหลัก ซึ่งสามารถนำไปใช้ได้หลายวิธีโดยใช้รูปแบบที่แตกต่างกัน... ต่อไป เราจะพิจารณาแนวคิดหลักที่ฝังอยู่ในแนวคิด MVC

MVC: แนวคิดและหลักการพื้นฐาน

• VC เป็นชุดของแนวคิดและหลักการทางสถาปัตยกรรมสำหรับการสร้างระบบข้อมูลที่ซับซ้อนด้วยอินเทอร์เฟซผู้ใช้
• MVC เป็นตัวย่อที่ย่อมาจาก: Model-View-Controller

ข้อจำกัดความรับผิดชอบ: MVC ไม่ใช่รูปแบบการออกแบบ MVC เป็นชุดแนวคิดและหลักการทางสถาปัตยกรรมสำหรับการสร้างระบบที่ซับซ้อนด้วยอินเทอร์เฟซผู้ใช้ แต่เพื่อความสะดวก เพื่อไม่ให้พูดว่า "ชุดความคิดทางสถาปัตยกรรม..." ซ้ำๆ เราจะอ้างถึงรูปแบบ MVC เริ่มจากเรื่องง่ายๆ กันก่อน อะไรซ่อนอยู่หลังคำว่า Model-View-Controller? เมื่อใช้รูปแบบ MVC เพื่อพัฒนาระบบด้วยอินเทอร์เฟซผู้ใช้ คุณต้องแบ่งระบบออกเป็นสามส่วน นอกจากนี้ยังสามารถเรียกว่าโมดูลหรือส่วนประกอบ เรียกพวกเขาตามที่คุณต้องการ แต่แบ่งระบบออกเป็นสามส่วน แต่ละองค์ประกอบมีจุดประสงค์ของตัวเอง แบบอย่าง. ส่วนประกอบ/โมดูลแรกเรียกว่าโมเดล ประกอบด้วยตรรกะทางธุรกิจของแอปพลิเคชันทั้งหมด ดู.ส่วนที่สองของระบบคือมุมมอง โมดูลนี้มีหน้าที่ในการแสดงข้อมูลให้กับผู้ใช้ ทุกสิ่งที่ผู้ใช้เห็นนั้นเกิดจากการดู ผู้ควบคุม.ลิงค์ที่สามในห่วงโซ่นี้คือตัวควบคุม ประกอบด้วยรหัสที่รับผิดชอบในการจัดการการกระทำของผู้ใช้ (การกระทำของผู้ใช้ทั้งหมดได้รับการจัดการในตัวควบคุม) โมเดลเป็นส่วนที่เป็นอิสระที่สุดของระบบ เป็นอิสระมากจนไม่ต้องรู้อะไรเลยเกี่ยวกับมุมมองและโมดูลตัวควบคุม แบบจำลองมีความเป็นอิสระมากจนผู้พัฒนาอาจไม่รู้อะไรเลยเกี่ยวกับมุมมองและตัวควบคุม วัตถุประสงค์หลักของมุมมองคือการให้ข้อมูลจากแบบจำลองในรูปแบบที่ผู้ใช้สามารถใช้ ข้อจำกัดหลักของมุมมองคือต้องไม่เปลี่ยนรุ่นแต่อย่างใด วัตถุประสงค์หลักของคอนโทรลเลอร์คือเพื่อจัดการกับการกระทำของผู้ใช้ ผู้ใช้ทำการเปลี่ยนแปลงโมเดลผ่านคอนโทรลเลอร์ หรืออย่างแม่นยำยิ่งขึ้นสำหรับข้อมูลที่จัดเก็บไว้ในโมเดล นี่คือไดอะแกรมที่คุณเห็นก่อนหน้านี้ในบทเรียน: จากทั้งหมดนี้เราสามารถสรุปผลเชิงตรรกะได้ ระบบที่ซับซ้อนจำเป็นต้องแบ่งออกเป็นโมดูล เรามาอธิบายขั้นตอนโดยสังเขปเพื่อให้บรรลุการแยกส่วนนี้

ขั้นตอนที่ 1 แยกตรรกะทางธุรกิจของแอปพลิเคชันออกจากอินเทอร์เฟซผู้ใช้

แนวคิดหลักของ MVC คือแอปพลิเคชันใด ๆ ที่มีส่วนต่อประสานกับผู้ใช้สามารถแบ่งออกเป็น 2 โมดูล: โมดูลที่รับผิดชอบในการนำตรรกะทางธุรกิจไปใช้ และส่วนต่อประสานผู้ใช้ โมดูลแรกจะใช้ฟังก์ชันหลักของแอปพลิเคชัน โมดูลนี้เป็นแกนหลักของระบบ ซึ่งมีการใช้โมเดลโดเมนของแอปพลิเคชัน ในกระบวนทัศน์ MVC โมดูลนี้คือตัวอักษร M ซึ่งก็คือโมเดล โมดูลที่สองใช้อินเทอร์เฟซผู้ใช้ทั้งหมด รวมถึงตรรกะในการแสดงข้อมูลแก่ผู้ใช้และจัดการการโต้ตอบของผู้ใช้กับแอปพลิเคชัน เป้าหมายหลักของการแยกนี้คือเพื่อให้แน่ใจว่าแกนหลักของระบบ ("แบบจำลอง" ในคำศัพท์ MVC) สามารถพัฒนาและทดสอบได้อย่างอิสระ หลังจากแยกส่วนนี้แล้ว สถาปัตยกรรมของแอปพลิเคชันจะมีลักษณะดังนี้:

ขั้นตอนที่ 2 ใช้รูปแบบการสังเกตการณ์เพื่อทำให้โมเดลมีความเป็นอิสระมากยิ่งขึ้นและเพื่อซิงโครไนซ์ส่วนติดต่อผู้ใช้

ที่นี่เรามี 2 เป้าหมาย:

1. บรรลุความเป็นอิสระมากยิ่งขึ้นสำหรับโมเดล
2. ซิงโครไนซ์ส่วนติดต่อผู้ใช้

ตัวอย่างต่อไปนี้จะช่วยให้คุณเข้าใจความหมายของการซิงโครไนซ์อินเทอร์เฟซผู้ใช้ สมมติว่าเรากำลังซื้อตั๋วหนังออนไลน์และดูจำนวนที่นั่งว่างในโรงภาพยนตร์ ในขณะเดียวกันอาจมีคนอื่นกำลังซื้อตั๋วหนังอยู่ หากบุคคลนี้ซื้อตั๋วก่อนหน้าเรา เราต้องการให้จำนวนที่นั่งว่างสำหรับรอบการแสดงที่เรากำลังพิจารณาลดลง ตอนนี้ลองคิดดูว่าจะนำไปใช้ในโปรแกรมได้อย่างไร สมมติว่าเรามีแกนกลางของระบบ (โมเดลของเรา) และอินเทอร์เฟซ (หน้าเว็บสำหรับซื้อตั๋ว) ผู้ใช้สองคนพยายามเลือกที่นั่งในโรงละครพร้อมกัน ผู้ใช้รายแรกซื้อตั๋ว หน้าเว็บต้องแสดงให้ผู้ใช้คนที่สองทราบว่าสิ่งนี้เกิดขึ้น สิ่งนี้ควรจะเกิดขึ้นได้อย่างไร? หากเราอัปเดตอินเทอร์เฟซจากคอร์ จากนั้นแกนหลัก (รุ่นของเรา) จะขึ้นอยู่กับอินเทอร์เฟซ ขณะที่เราพัฒนาและทดสอบโมเดล เราจะต้องคำนึงถึงวิธีต่างๆ ในการอัปเดตอินเทอร์เฟซ เพื่อให้บรรลุเป้าหมายนี้ เราจำเป็นต้องนำรูปแบบการสังเกตการณ์ไปใช้ รูปแบบนี้ช่วยให้โมเดลส่งการแจ้งเตือนการเปลี่ยนแปลงไปยังผู้ฟังทั้งหมด ในฐานะผู้ฟังเหตุการณ์ (หรือผู้สังเกตการณ์) อินเทอร์เฟซผู้ใช้จะได้รับการแจ้งเตือนและอัปเดต ในแง่หนึ่ง รูปแบบของผู้สังเกตการณ์ช่วยให้แบบจำลองแจ้งอินเทอร์เฟซ (มุมมองและตัวควบคุม) ว่าการเปลี่ยนแปลงเกิดขึ้นโดยไม่ทราบอะไรเกี่ยวกับมันจริง ดังนั้นจึงยังคงเป็นอิสระต่อกัน ในทางกลับกัน มันทำให้สามารถซิงโครไนซ์ส่วนติดต่อผู้ใช้ได้ เราจำเป็นต้องใช้รูปแบบการสังเกตการณ์ รูปแบบนี้ช่วยให้โมเดลส่งการแจ้งเตือนการเปลี่ยนแปลงไปยังผู้ฟังทั้งหมด ในฐานะผู้ฟังเหตุการณ์ (หรือผู้สังเกตการณ์) อินเทอร์เฟซผู้ใช้จะได้รับการแจ้งเตือนและอัปเดต ในแง่หนึ่ง รูปแบบของผู้สังเกตการณ์ช่วยให้แบบจำลองแจ้งอินเทอร์เฟซ (มุมมองและตัวควบคุม) ว่าการเปลี่ยนแปลงเกิดขึ้นโดยไม่ทราบอะไรเกี่ยวกับมันจริง ดังนั้นจึงยังคงเป็นอิสระต่อกัน ในทางกลับกัน มันทำให้สามารถซิงโครไนซ์ส่วนติดต่อผู้ใช้ได้ เราจำเป็นต้องใช้รูปแบบการสังเกตการณ์ รูปแบบนี้ช่วยให้โมเดลส่งการแจ้งเตือนการเปลี่ยนแปลงไปยังผู้ฟังทั้งหมด ในฐานะผู้ฟังเหตุการณ์ (หรือผู้สังเกตการณ์) อินเทอร์เฟซผู้ใช้จะได้รับการแจ้งเตือนและอัปเดต ในแง่หนึ่ง รูปแบบของผู้สังเกตการณ์ช่วยให้แบบจำลองแจ้งอินเทอร์เฟซ (มุมมองและตัวควบคุม) ว่าการเปลี่ยนแปลงเกิดขึ้นโดยไม่ทราบอะไรเกี่ยวกับมันจริง ดังนั้นจึงยังคงเป็นอิสระต่อกัน ในทางกลับกัน มันทำให้สามารถซิงโครไนซ์ส่วนติดต่อผู้ใช้ได้

ขั้นตอนที่ 3 แยกอินเทอร์เฟซออกเป็นมุมมองและตัวควบคุม

เราแบ่งแอปพลิเคชันออกเป็นโมดูลต่อไป แต่ตอนนี้อยู่ในระดับที่ต่ำกว่าในลำดับชั้น ในขั้นตอนนี้ อินเทอร์เฟซผู้ใช้ (ซึ่งเราแยกออกเป็นโมดูลที่แตกต่างกันในขั้นตอนที่ 1) จะถูกแยกออกเป็นมุมมองและตัวควบคุม การวาดเส้นแบ่งระหว่างมุมมองและตัวควบคุมเป็นเรื่องยาก ถ้าเราบอกว่ามุมมองคือสิ่งที่ผู้ใช้เห็น และตัวควบคุมคือกลไกที่ช่วยให้ผู้ใช้โต้ตอบกับระบบ คุณอาจชี้ให้เห็นถึงความขัดแย้ง องค์ประกอบการควบคุม เช่น ปุ่มบนหน้าเว็บหรือแป้นพิมพ์เสมือนจริงบนหน้าจอโทรศัพท์ เป็นส่วนหนึ่งของตัวควบคุม แต่ผู้ใช้จะมองเห็นได้เหมือนกับส่วนใดๆ ของมุมมอง สิ่งที่เรากำลังพูดถึงจริงๆ คือการแบ่งแยกการทำงาน ภารกิจหลักของส่วนติดต่อผู้ใช้คือการอำนวยความสะดวกในการโต้ตอบของผู้ใช้กับระบบ

• ออกและแสดงข้อมูลระบบแก่ผู้ใช้ได้อย่างสะดวก
• ป้อนข้อมูลผู้ใช้และคำสั่ง (สื่อสารกับระบบ)

ฟังก์ชันเหล่านี้กำหนดวิธีการแบ่งส่วนติดต่อผู้ใช้ออกเป็นโมดูลต่างๆ ในท้ายที่สุด สถาปัตยกรรมของระบบจะมีลักษณะดังนี้ และนี่คือวิธีที่เรามาถึงแอปพลิเคชันที่ประกอบด้วยโมดูลสามโมดูลที่เรียกว่าโมเดล มุมมอง และตัวควบคุม สรุป:

1. ตามหลักการของกระบวนทัศน์ MVC ระบบจะต้องแบ่งออกเป็นโมดูล
2. โมดูลที่สำคัญที่สุดและเป็นอิสระควรเป็นโมเดล
3. แบบจำลองเป็นแกนหลักของระบบ ควรเป็นไปได้ที่จะพัฒนาและทดสอบโดยอิสระจากอินเทอร์เฟซผู้ใช้
4. เพื่อให้บรรลุเป้าหมายนี้ ในขั้นตอนแรกของการแบ่ง เราจำเป็นต้องแยกระบบออกเป็นแบบจำลองและอินเทอร์เฟซผู้ใช้
5. จากนั้น เราใช้รูปแบบการสังเกตการณ์ เพื่อเสริมความเป็นอิสระของโมเดลและซิงโครไนซ์อินเทอร์เฟซผู้ใช้
6. ขั้นตอนที่สามคือการแบ่งส่วนติดต่อผู้ใช้ออกเป็นตัวควบคุมและมุมมอง
7. สิ่งที่จำเป็นในการรับข้อมูลผู้ใช้เข้าสู่ระบบอยู่ในตัวควบคุม
8. ทั้งหมดที่จำเป็นสำหรับการส่งข้อมูลไปยังผู้ใช้อยู่ในมุมมอง

สิ่งสำคัญอีกประการหนึ่งที่ควรพูดคุยก่อนที่คุณจะดื่มช็อกโกแลตร้อน

ข้อมูลเล็กน้อยเกี่ยวกับการที่มุมมองและคอนโทรลเลอร์โต้ตอบกับโมเดล

โดยการป้อนข้อมูลผ่านคอนโทรลเลอร์ ผู้ใช้จะเปลี่ยนโมเดล หรืออย่างน้อย ผู้ใช้เปลี่ยนข้อมูลโมเดล เมื่อผู้ใช้ได้รับข้อมูลผ่านองค์ประกอบอินเทอร์เฟซ (ผ่านมุมมอง) ผู้ใช้จะได้รับข้อมูลเกี่ยวกับโมเดล สิ่งนี้เกิดขึ้นได้อย่างไร? มุมมองและตัวควบคุมโต้ตอบกับโมเดลด้วยวิธีใด ท้ายที่สุดแล้ว คลาสของมุมมองไม่สามารถเรียกเมธอดของคลาสของโมเดลโดยตรงเพื่ออ่าน/เขียนข้อมูลได้ มิฉะนั้น เราจะไม่สามารถพูดได้ว่าแบบจำลองเป็นอิสระ โมเดลคือชุดของคลาสที่เกี่ยวข้องอย่างใกล้ชิดซึ่งทั้งมุมมองและคอนโทรลเลอร์ไม่ควรเข้าถึง ในการเชื่อมต่อโมเดลกับมุมมองและตัวควบคุม เราจำเป็นต้องใช้รูปแบบการออกแบบส่วนหน้า ส่วนหน้าของโมเดลคือเลเยอร์ระหว่างโมเดลและอินเทอร์เฟซผู้ใช้ ซึ่งมุมมองจะได้รับข้อมูลที่จัดรูปแบบอย่างสะดวก และผู้ควบคุมจะเปลี่ยนข้อมูลโดยการเรียกใช้เมธอดที่จำเป็นบนส่วนหน้า ในที่สุดทุกอย่างจะเป็นดังนี้:

MVC: เราได้อะไร?

วัตถุประสงค์หลักของกระบวนทัศน์ MVC คือการแยกการใช้ตรรกะทางธุรกิจ (แบบจำลอง) ออกจากการแสดงภาพ (มุมมอง) การแยกนี้เพิ่มความเป็นไปได้สำหรับการใช้รหัสซ้ำ ประโยชน์ของ MVC นั้นชัดเจนที่สุดเมื่อเราต้องการนำเสนอข้อมูลเดียวกันในรูปแบบต่างๆ ตัวอย่างเช่น เป็นตาราง กราฟ หรือแผนภูมิ (โดยใช้มุมมองที่แตกต่างกัน) ในขณะเดียวกัน เราสามารถเปลี่ยนแปลงวิธีการตอบสนองต่อการกระทำของผู้ใช้ (การคลิกปุ่ม การป้อนข้อมูล) โดยไม่กระทบต่อวิธีการดู หากคุณปฏิบัติตามหลักการของ MVC คุณสามารถลดความซับซ้อนของการพัฒนาซอฟต์แวร์ เพิ่มความสามารถในการอ่านโค้ด และปรับปรุงความสามารถในการขยายและการบำรุงรักษา ในบทความสุดท้ายในชุด "Introduction to Enterprise Development" เราจะพิจารณาการใช้งาน MVC ที่สร้างขึ้นโดยใช้ Spring MVC ตอนที่ 8 มาเขียน Application เล็กๆ ด้วย Spring Boot กันเถอะ