ในสถาปัตยกรรม MVC มีความสัมพันธ์กับ Model and View to Controller อย่างไร

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

เช่นเดียวกับการแก้ไข; นี่เป็นแอปที่กำหนดเองที่ไม่ได้เขียนในกรอบงานเว็บใด ๆ ดังนั้นฉันไม่ได้มองหารายละเอียดเฉพาะของกรอบงานที่นี่และมีอิสระในการเลือกของฉันเอง

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

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

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

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

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

ในโลก. NET เรามีแนวโน้มที่จะลดความเสี่ยงโดยไม่ยอมให้สิ่งที่ไม่ควรเกิดขึ้นและด้วยเหตุผลนั้นผมคิดว่ารูปแบบมุมมองแบบแยกส่วนได้รับความนิยมมากขึ้น

หมายเหตุ: โรเบิร์ตซีมาร์ติน (aka ลุงบ๊อบ) อธิบายเรื่องนี้ในทางที่ดีขึ้นและมีอารมณ์ขันในประเด็นสำคัญของเขา, สถาปัตยกรรมที่หายไปปี ค่อนข้างยาว แต่สอนแนวคิดที่ดีมากมาย

tl; dr: อย่าคิดและวางแผนแอปของคุณในแง่ของ MVC กรอบ MVC เป็นเพียงรายละเอียดการใช้งาน

สิ่งที่สับสนมากที่สุดเกี่ยวกับ MVC คือนักพัฒนาพยายามที่จะใช้ส่วนประกอบทั้งหมดที่ติดกัน

ลองคิดในแง่ของโปรแกรมไม่ใช่ในแง่ของกรอบ

โปรแกรมของคุณมีจุดประสงค์ ต้องใช้ข้อมูลบางอย่างทำสิ่งต่าง ๆ ด้วยข้อมูลและส่งคืนข้อมูลบางส่วน

วิธีcontrollerนี้เป็นกลไกการส่งมอบโปรแกรมของคุณ

1. ผู้ใช้ส่งคำขอไปยังโปรแกรมของคุณ (สมมติว่าเพิ่มผลิตภัณฑ์ในตะกร้าสินค้า)
2. คอนโทรลเลอร์จะรับคำขอนั้น (ข้อมูลผลิตภัณฑ์และข้อมูลผู้ใช้) ซึ่งจะเรียกส่วนที่จำเป็นของโปรแกรมของคุณที่จะจัดการกับคำขอนี้ $user->addToCart($product)
3. โปรแกรมของคุณ ( addToCartฟังก์ชั่นของuserวัตถุในกรณีนี้) ทำงานตามที่ตั้งใจไว้และส่งคืนการตอบกลับ (สมมติว่าsuccess)
4. คอนโทรลเลอร์เตรียมการตอบสนองโดยใช้สิ่งที่เกี่ยวข้องview: เช่น ในวัตถุตัวควบคุม$this->render($cartView('success')

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

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

หรือหากคุณต้องการสร้างเวอร์ชันเดสก์ท็อปแอปของคุณจะยังคงเหมือนเดิมคุณเพียงแค่ต้องเตรียมกลไกการจัดส่ง

และที่Modelสำคัญ คิดว่ามันเป็นกลไกการติดตา

ในวิธี OO มีวัตถุในโปรแกรมของคุณที่เก็บข้อมูล

class User {
    //...
    private $id;
    private $shoppingCart;
    //...
}

class Product {
    //...
    private $id;
    //...
}

เมื่อคุณเพิ่มสินค้าลงในตะกร้าช้อปปิ้งที่คุณสามารถเพิ่มที่ไปproduct::iduser::shoppingCart

และเมื่อคุณต้องการยืนยันข้อมูลคุณสามารถใช้modelส่วนของกรอบงานซึ่งโดยทั่วไปประกอบด้วยการใช้ ORM เพื่อแมปคลาสกับตารางฐานข้อมูล

หากคุณต้องการเปลี่ยน ORM ที่คุณใช้โปรแกรมของคุณจะยังคงเหมือนเดิมเฉพาะข้อมูลการแมปเท่านั้นที่จะเปลี่ยน หรือถ้าคุณต้องการหลีกเลี่ยงฐานข้อมูลทั้งหมดเข้าด้วยกันคุณสามารถเขียนข้อมูลลงในไฟล์ข้อความล้วนและแอพของคุณจะยังคงเหมือนเดิม

ดังนั้นเขียนโปรแกรมของคุณก่อน หากคุณเขียนโปรแกรมด้วยวิธี 'OO' ให้ใช้วัตถุเก่าแบบธรรมดาของภาษา อย่าคิดในแง่ของ MVC ในตอนแรก

มาร์ตินฟาวเลอร์ทำงานได้ดีในการอธิบายกระบวนทัศน์ของ MVC นี่คือลิงค์ไปยังบทความของเขาที่http://martinfowler.com/eaaDev/uiArchs.html

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

นี่คือตัวอย่างง่ายๆของวิธีการใช้ MVC ในแอปพลิเคชัน Java Swing ทั่วไป ...

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

นี่จะเป็นวิธีการทั่วไปที่ดำเนินการโดยแอปพลิเคชัน MVC แบบง่าย ...

ตัวควบคุมจะลงทะเบียนตัวเองในฐานะผู้ฟังเหตุการณ์ของมุมมอง เมื่อคลิกที่ปุ่มมุมมองจะไม่จัดการกับเหตุการณ์ ผู้ควบคุมทำ คอนโทรลเลอร์นั้นมีลักษณะเฉพาะเนื่องจากต้องจัดการกับเหตุการณ์ที่เกี่ยวข้องกับการสวิง

คอนโทรลเลอร์ได้รับการแจ้งเตือนนี้และต้องตัดสินใจว่าใครต้องจัดการ (The View หรือ Model) เนื่องจากเหตุการณ์นี้จะเปลี่ยนสถานะของแอปพลิเคชันจึงตัดสินใจที่จะส่งต่อข้อมูลไปยังรุ่นที่รับผิดชอบข้อมูลและตรรกะของโปรแกรม บางคนทำผิดพลาดในการวางตรรกะของโปรแกรมในคอนโทรลเลอร์ แต่ใน OOP รุ่นต่างๆจะเป็นตัวแทนของข้อมูลและพฤติกรรม อ่าน Martin Fowler เกี่ยวกับเรื่องนี้

โมเดลได้รับข้อความในบริบทที่เหมาะสม นั่นคือมันเป็นโมฆะอย่างสมบูรณ์ของการอ้างอิงใด ๆ ที่จะแกว่งหรือการอ้างอิง GUI อื่น ๆ ที่เฉพาะเจาะจง ข้อความนี้พูดกับโมเดลและเป็นโมเดลเท่านั้น หากคุณพบว่าคุณกำลังนำเข้าคำสั่ง javax.swing ในรุ่นคุณจะไม่ได้เข้ารหัสรุ่นอย่างถูกต้อง

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

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

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

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

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

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

จากประสบการณ์ของผมโดยทั่วไปรูปแบบเท่านั้นขึ้นอยู่กับมุมมองไม่ได้เป็นหนึ่งโดยเฉพาะมักจะในฐานะผู้สังเกตการณ์ ... ถ้ามีเพศสัมพันธ์เช่นใด ๆ เลย

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

ตัวควบคุมมักจะคู่กับทั้งสอง นอกจากนี้ยังมีเหตุผลบางอย่างเนื่องจากหน้าที่ของมันคือการเปลี่ยนมุมมองเหตุการณ์เป็นการเปลี่ยนแปลงแบบ

แน่นอนว่านี่เป็นเพียงแนวโน้มที่ฉันได้สังเกตและไม่ได้พูดอะไรเกี่ยวกับตัวอย่างเฉพาะใด ๆ

เพื่อให้เข้าใจว่า MVC คืออะไรและความสัมพันธ์ของการมีเพศสัมพันธ์มีแนวโน้มที่จะเป็นคุณควรพิจารณาว่า MVC มาเป็นอย่างไร สภาพแวดล้อมที่ MVC ถูกสร้างขึ้นนั้นเป็นหนึ่งใน "วิดเจ็ต" เป็นองค์ประกอบของรูปแบบที่คุณสามารถสร้างกล่องโต้ตอบด้วยไม่ได้อยู่ "มุมมอง" เป็นกล่องและดึงสิ่งต่างๆ มุมมองข้อความจะเป็นกล่องที่จะวาดข้อความ มุมมองรายการเป็นกล่องที่จะวาดรายการ "คอนโทรลเลอร์" ได้รับเหตุการณ์เมาส์และคีย์บอร์ดทั้งหมดจากระบบ UI ที่เกิดขึ้นในมุมมองนั้น ไม่มีเหตุการณ์ "textChanged" หรือ "selectionChanged" ตัวควบคุมจะใช้เหตุการณ์ระดับต่ำเหล่านี้ทั้งหมดและสร้างการโต้ตอบกับแบบจำลอง โมเดลเมื่อมีการเปลี่ยนแปลงจะแจ้งให้ทราบมุมมอง เรามาดูความสัมพันธ์นี้ในฐานะ "ผู้สังเกตการณ์" และมัน '

นั่นคือสาระสำคัญของรูปแบบ MVC เนื่องจากการเขียนโปรแกรม UI ระดับต่ำแบบนี้โดยทั่วไปจะไม่ทำอีกต่อไป MVC จึงมีวิวัฒนาการในหลาย ๆ ทิศทาง บางสิ่งที่ใช้ชื่อนี้ในทุกวันนี้แทบจะไม่มีอะไรเหมือน MVC และควรเรียกชื่ออย่างอื่น มันยังคงสามารถใช้งานได้แม้ในแง่ของการโต้ตอบโดยรวมที่โต้ตอบกับวัตถุขนาดใหญ่ มีหลายทางเลือกที่ดีกว่าว่า

โดยพื้นฐานแล้วทุกอย่างที่ MVC ใช้เพื่อแก้ไขเกิดขึ้นภายในวิดเจ็ตตอนนี้และเป็นสิ่งที่เราไม่ต้องใช้อีกต่อไป

สำหรับผู้ที่คิดว่าพวกเขารู้ดีกว่า:

http://www.codeproject.com/Articles/42830/Model-View-Controller-Model-View-Presenter-and-Mod

http://msdn.microsoft.com/en-us/library/ff649643.aspx

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

แต่ทำไมปล่อยให้ข้อเท็จจริงเข้ามาขวางทาง ...

บทความที่โพสต์แล้วในคำตอบอื่นยังสนับสนุนงบของฉัน:

http://martinfowler.com/eaaDev/uiArchs.html

หากผู้คนต้องการพูดต่อไปว่าทุกคนในอุตสาหกรรมการออกแบบนั้นผิดปกติ

• คอนโทรลเลอร์กระจายโมเดลไปยังมุมมองและประมวลผลโมเดลที่ส่งจากมุมมองอย่างไรก็ตามมันไม่ได้เชื่อมโยงกับมุมมองหรือโมเดลอย่างแน่นหนา

หากคอนโทรลเลอร์ถูกผนวกเข้ากับมุมมองอย่างแน่นหนาเราจะอยู่ในโลกของเว็บฟอร์ม คุณมีรหัสที่อยู่ด้านหลังซึ่งจะผูกกับไฟล์เทมเพลต (ใช้ได้กับเว็บฟอร์ม ASP.NET)

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

• มุมมองเป็นแบบคู่กับโมเดลอย่างแน่นหนา ทำการเปลี่ยนแปลงโมเดลของคุณ (เช่นเปลี่ยนคุณสมบัติ) และคุณจะต้องทำการเปลี่ยนแปลงในมุมมองของคุณ

• นางแบบไม่แน่นคู่กับมุมมอง เปลี่ยนแปลงมุมมองและจะไม่มีผลกับโมเดล

• รุ่นไม่รู้อะไรเกี่ยวกับคอนโทรลเลอร์หรือมุมมองที่อาจใช้ ดังนั้นโมเดลจะไม่เชื่อมโยงอย่างแน่นหนากับมุมมองหรือตัวควบคุม

อีกวิธีในการคิดเกี่ยวกับสิ่งนี้:

• ทำการเปลี่ยนแปลงตัวควบคุม - มุมมองและรุ่นจะไม่ได้รับผลกระทบ

• ทำการเปลี่ยนแปลงโมเดล - มุมมองจะแตกเมื่อใช้โมเดล

• ทำการเปลี่ยนแปลงมุมมอง - โมเดลและคอนโทรลเลอร์จะไม่ได้รับผลกระทบ

การมีเพศสัมพันธ์แบบหลวมในโครงการ MVC เป็นสิ่งที่ทำให้ง่ายต่อการทดสอบหน่วย