คู่มือสำหรับผู้เริ่มต้นใช้งานสถาปัตยกรรม MVC ใน Java

เผยแพร่แล้ว: 2018-04-10

หากคุณเกี่ยวข้องกับฉากการพัฒนาเว็บ คุณจะเจอคำย่อ “MVC” หลายร้อยครั้ง หากไม่มากกว่านั้น MVC เป็นหนึ่งในรูปแบบการออกแบบที่ได้รับการกล่าวถึงมากที่สุดในโลกการเขียนโปรแกรมเว็บในปัจจุบัน และเป็นเช่นนั้นจริงๆ ในบทความนี้ เราจะพาคุณเข้าสู่โลกของสถาปัตยกรรม MVC เราจะพูดถึงพื้นฐานของ MVC ข้อดี และสุดท้ายคือ โค้ดง่ายๆ ที่จะช่วยให้คุณเข้าใจการใช้งาน MVC ใน Java อย่างชัดเจนยิ่งขึ้น

สารบัญ

สถาปัตยกรรม MVC คืออะไรกันแน่?

ก่อนที่เราจะพูดถึงเทคนิคของมัน เรามาทำให้ชัดเจนก่อนว่า MVC ไม่ใช่รูปแบบการออกแบบ แต่เป็นวิธีการจัดโครงสร้างแอปพลิเคชันของคุณ ในช่วงไม่กี่ปีที่ผ่านมา เว็บแอปพลิเคชันใช้สถาปัตยกรรม MVC อย่างกว้างขวาง ดังนั้นจึงเป็นเรื่องปกติที่จะสับสนกับรูปแบบการออกแบบสำหรับแอปพลิเคชันเว็บโดยเฉพาะ อย่างไรก็ตาม สมมติว่า MVC ได้รับการอธิบายครั้งแรกในปี 1979 ก่อนยุค WWW ที่ไม่มีแนวคิดเกี่ยวกับเว็บแอปพลิเคชัน สถาปัตยกรรมที่ใช้ในปัจจุบันสำหรับเว็บแอปพลิเคชันคือการปรับรูปแบบเดิม
อันที่จริง สถาปัตยกรรมนี้เริ่มแรกรวมอยู่ในเฟรมเวิร์กการพัฒนาเว็บไซต์หลักสองแบบคือ Struts และ Ruby on Rails สภาพแวดล้อมทั้งสองนี้ปูทางสำหรับเฟรมเวิร์กเว็บส่วนใหญ่ที่มาในภายหลัง และทำให้ความนิยมของสถาปัตยกรรมนี้เพิ่มขึ้นเรื่อยๆ

เรียนรู้การสร้างแอปพลิเคชัน เช่น Swiggy, Quora, IMDB และอื่นๆ

รูปแบบสถาปัตยกรรม MVC เป็นไปตามแนวคิดพื้นฐาน – เราต้องแยกความรับผิดชอบในแอปพลิเคชันใด ๆ ตามพื้นฐานต่อไปนี้:

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

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

คอนโทรลเลอร์

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

แบบอย่าง

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

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

ดู

ตามชื่อที่แนะนำ มุมมองมีหน้าที่แสดงข้อมูลที่ได้รับจากแบบจำลอง อาจมีเทมเพลตที่ออกแบบไว้ล่วงหน้าซึ่งคุณสามารถใส่ข้อมูลได้ และอาจมีมุมมองที่แตกต่างกันหลายแบบต่อรุ่นขึ้นอยู่กับข้อกำหนด

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

มาดูตัวอย่างกัน

มาดูตัวอย่างร้านเครื่องเขียนออนไลน์กัน ผู้ใช้สามารถดูรายการ ซื้อ เพิ่มรายการในรถเข็น เพิ่มรายการในคำสั่งซื้อปัจจุบัน หรือแม้แต่เพิ่ม/ลบรายการ (หากเขาเป็นผู้ดูแลระบบ)
ตอนนี้เรามาดูกันว่าจะเกิดอะไรขึ้นเมื่อผู้ใช้คลิกที่ชื่อ “ปากกา” เพื่อดูรายชื่อปากกา
แอปพลิเคชันของเราจะมีตัวควบคุมเฉพาะเพื่อจัดการกับคำถามทั้งหมดที่เกี่ยวข้องกับปากกา สมมุติว่าชื่อนี้เรียกว่า “pens_controller.php” นอกจากนี้เรายังมีแบบจำลองที่จะเก็บข้อมูลเกี่ยวกับปากกาที่เรามี – เรียกว่า “pens_model.php” สุดท้าย เราจะมีมุมมองหลายมุมมองในการนำเสนอข้อมูล เช่น รายการปากกา ตารางแสดงปากกา หน้าสำหรับแก้ไขรายการ ฯลฯ
รูปต่อไปนี้แสดงการควบคุมที่สมบูรณ์ตั้งแต่วินาทีที่ผู้ใช้คลิกที่ "ปากกา" จนถึงเมื่อผลลัพธ์ปรากฏต่อหน้าเขา:

ขั้นแรก “pens_controller.php” จะจัดการคำขอของผู้ใช้ (1) เป็นคำขอ GET หรือ POST นอกจากนี้เรายังสามารถมี “index.php” ซึ่งเป็นตัวควบคุมส่วนกลางซึ่งจะเรียก “pens_controller” เมื่อใดก็ตามที่จำเป็น
จากนั้นผู้ควบคุมจะตรวจสอบคำขอและพารามิเตอร์และเรียกใช้แบบจำลองที่ต้องการ ในกรณีนี้คือ “pens_model.php” ผู้ควบคุมขอให้นางแบบส่งคืนรายการปากกาที่ใช้ได้ (2)
ตอนนี้ แบบจำลองจะค้นหาฐานข้อมูลสำหรับข้อมูลที่จำเป็น (3) ใช้ตรรกะหากจำเป็น และส่งกลับข้อมูลไปยังตัวควบคุม (4)
จากนั้นผู้ควบคุมจะเลือกมุมมองที่เหมาะสม (5) และนำเสนอข้อมูล (6 และ 7) หากคำขอมาจากอุปกรณ์พกพา มุมมองที่เหมาะสมจะถูกใช้ หรือหากผู้ใช้เลือกธีมเฉพาะ มุมมองนั้นจะถูกเลือก และอื่นๆ
วิธีการเป็นนักพัฒนาเต็มกอง

ข้อดีของสถาปัตยกรรม MVC

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

การใช้งาน MVC อย่างง่ายโดยใช้ Java

เราจะมีสามสิ่งต่อไปนี้:

    1. StudentObject : โมเดล

    1. StudentView: ดูชั้นเรียนเพื่อพิมพ์รายละเอียดบนคอนโซล

  1. StudentController: ตัวควบคุมที่เก็บข้อมูลใน studentObject และอัปเดต StudentView ตามลำดับ

ขั้นตอนที่ 1: สร้างแบบจำลอง

 นักเรียน ชั้น สาธารณะ {
   ม้วน สตริง ส่วนตัว ไม่มี ;
   ชื่อ สตริง ส่วนตัว ;
   
   สตริง สาธารณะ getRollNo () {
      ม้วน กลับ ไม่มี ;
   }
   
   โมฆะ สาธารณะ setRollNo ( String rollNo ) {
      นี้ . rollNo = ม้วนไม่มี ;
   }
   
   สตริง สาธารณะ getName () {
      กลับ ชื่อ ;
   }
   
   โมฆะ สาธารณะ setName ( ชื่อ สตริง ) {
      นี้ . ชื่อ = ชื่อ ;
   }
}

รหัสเป็นตัวอธิบาย ประกอบด้วยฟังก์ชันรับ/กำหนดหมายเลขม้วนและชื่อนักเรียน เรียกมันว่า “student.java”
ขั้นตอนที่ 2: สร้างมุมมอง

 StudentView คลาส สาธารณะ {
   โมฆะ สาธารณะ printStudentDetails ( String studentName , String studentRollNo ){
      ระบบ . ออก _ println ( "นักเรียน: " );
      ระบบ . ออก _ println ( "ชื่อ:" + studentName );
      ระบบ . ออก _ println ( "หมายเลขม้วน:" + studentRollNo );
   }
}

นี่เป็นเพียงการพิมพ์ค่าไปยังคอนโซล เรียกสิ่งนี้ว่า “studentView.java”
ขั้นตอนที่ 3: สร้างตัวควบคุม

 StudentController คลาส สาธารณะ {
   โมเดล นักศึกษา เอกชน ;
   มุมมอง StudentView ส่วนตัว ;
   StudentController สาธารณะ ( Student model , StudentView view ){
      นี้ . รุ่น = รุ่น ;
      นี้ . ดู = ดู ;
   }
   โมฆะ สาธารณะ setStudentName ( ชื่อ สตริง ){
รุ่น . setName ( ชื่อ );
   }
   สตริง สาธารณะ getStudentName (){
      รูปแบบ การ ส่งคืน getName ();
   }
   โมฆะ สาธารณะ setStudentRollNo ( String rollNo ){
รุ่น . setRollNo ( ไม่มีม้วน );
   }
   สตริง สาธารณะ getStudentRollNo (){
      รูปแบบ การ ส่งคืน getRollNo ();
   }
   โมฆะ สาธารณะ updateView (){
ดู . printStudentDetails ( รุ่น . getName ( ) รุ่น . getRollNo ());
   }
}

เรียกสิ่งนี้ว่า “StudentController.java” ภาพรวมคร่าวๆ จะบอกคุณว่าตัวควบคุมนี้มีหน้าที่เพียงเรียกโมเดลเพื่อรับ/ตั้งค่าข้อมูล จากนั้นจึงอัปเดตมุมมอง
ตอนนี้เรามาดูกันว่าทั้งหมดนี้เชื่อมโยงกันอย่างไร
ขั้นตอนที่ 4: สร้างไฟล์ Java หลัก

 MVCPatternDemo คลาส สาธารณะ {
   โมฆะ คงที่ สาธารณะ หลัก ( สตริง [ ] args ) {
      //ดึงข้อมูลนักเรียนตามหมายเลขม้วนของเขาจากฐานข้อมูล
      โมเดล นักศึกษา = retriveStudentFromDatabase ();
      //สร้างมุมมอง : เขียนรายละเอียดนักเรียนบนคอนโซล
      มุมมอง StudentView = StudentView ใหม่ ();
      StudentController controller = StudentController ใหม่ ( model , view );
ตัว ควบคุม updateView ();
      //อัปเดตข้อมูลโมเดล
ตัว ควบคุม setStudentName ( "จอห์น" );
ตัว ควบคุม updateView ();
   }
   นักเรียน ส่วนตัว แบบคงที่ retriveStudentFromDatabase (){
      นักเรียน นักศึกษา = นักเรียน ใหม่ ();
นักเรียน . setName ( "โรเบิร์ต" );
นักเรียน . setRollNo ( "10" );
      กลับ นักเรียน ;
   }
}

สิ่งนี้เรียกว่า “MVCPatternDemo.java” อย่างที่คุณเห็น มันดึงข้อมูลนักเรียนจากฐานข้อมูลหรือฟังก์ชัน (ในกรณีนี้ เรากำลังใช้ฟังก์ชันเพื่อตั้งค่า) และพุชไปยังโมเดล Student จากนั้นจะเริ่มต้นมุมมองที่เราสร้างไว้ก่อนหน้านี้
นอกจากนี้ยังเริ่มต้นคอนโทรลเลอร์ของเราและผูกเข้ากับโมเดลและมุมมอง เมธอด updateView() เป็นส่วนหนึ่งของคอนโทรลเลอร์ที่จะอัปเดตรายละเอียดของนักเรียนบนคอนโซล
ขั้นตอนที่ 5: ทดสอบผลลัพธ์
หากทุกอย่างถูกต้อง ผลลัพธ์ควรเป็น: 

 นักเรียน:
ชื่อ: Robert
หมายเลขม้วน: 10
นักเรียน:
ชื่อ : จอห์น
หมายเลขม้วน: 10

หากคุณได้รับสิ่งนี้เป็นผลแสดงความยินดี! คุณนำสถาปัตยกรรม MVC ไปใช้สำเร็จโดยใช้ Java แม้ว่าจะเป็นแอปพลิเคชันธรรมดาก็ตาม อย่างไรก็ตาม แอปพลิเคชันนี้เรียบง่ายเพียงใดก็เพียงพอที่จะแสดงให้เห็นถึงพลังของสถาปัตยกรรม MVC
15 คำถามสัมภาษณ์ MVC ฤดูใบไม้ผลิที่ต้องรู้

ห่อ…
หลังจากพูดและทำมามากแล้ว ก็ยากที่จะเน้นย้ำถึงพลังของสถาปัตยกรรม MVC ในแอปพลิเคชันเว็บ/เดสก์ท็อปใดๆ ในปัจจุบัน มันมอบระดับโมดูลใหม่ทั้งหมดให้กับโค้ดของคุณ ซึ่งทำให้อ่านและบำรุงรักษาได้ง่ายขึ้นมาก ดังนั้น ถ้าคุณต้องการขยายไปสู่ความสูงใหม่ในอาชีพของคุณในฐานะนักพัฒนาแอปพลิเคชัน การได้รับสถาปัตยกรรม MVC และการทำงานควรเป็นสิ่งที่คุณให้ความสำคัญเป็นลำดับต้นๆ

ลงทะเบียนเรียนหลักสูตรวิศวกรรมซอฟต์แวร์จากมหาวิทยาลัยชั้นนำของโลก รับโปรแกรม PG สำหรับผู้บริหาร โปรแกรมประกาศนียบัตรขั้นสูง หรือโปรแกรมปริญญาโท เพื่อติดตามอาชีพของคุณอย่างรวดเร็ว

แสดงความคิดเห็นและแจ้งให้เราทราบว่าคุณชอบบทความนี้อย่างไร!

มาเป็นนักพัฒนาเต็มรูปแบบ

ประกาศนียบัตร PG ของ UpGrad และ IIIT-Bangalore ด้านการพัฒนาซอฟต์แวร์
สมัครเลยตอนนี้สำหรับปริญญาโทด้านวิศวกรรมซอฟต์แวร์