logo

TechCodeview

MVC-Entwurfsmuster

Das MVC-Entwurfsmuster ist ein Softwarearchitekturmuster, das eine Anwendung in drei Hauptkomponenten unterteilt: Modell, Ansicht und Controller, wodurch die Verwaltung und Wartung der Codebasis einfacher wird. Es ermöglicht außerdem die Wiederverwendbarkeit von Komponenten und fördert einen modulareren Ansatz bei der Softwareentwicklung.

Wichtige Themen für das MVC-Entwurfsmuster



Was ist das MVC-Entwurfsmuster?

Der Model View Controller (MVC)-Entwurfsmuster gibt an, dass eine Anwendung aus einem Datenmodell, Präsentationsinformationen und Steuerinformationen besteht. Das Muster erfordert, dass jedes davon in verschiedene Objekte unterteilt wird.

  • Das MVC-Muster unterteilt die Belange einer Anwendung in drei verschiedene Komponenten, von denen jede für einen bestimmten Aspekt der Funktionalität der Anwendung verantwortlich ist.
  • Diese Trennung von Belangen erleichtert die Wartung und Erweiterung der Anwendung, da Änderungen an einer Komponente keine Änderungen an den anderen Komponenten erfordern.

Komponenten des MVC-Entwurfsmusters

1. Modell

Die Modellkomponente im MVC-Entwurfsmuster (Model-View-Controller) repräsentiert die Daten und Geschäftslogik einer Anwendung. Es ist für die Verwaltung der Anwendungsdaten, die Verarbeitung von Geschäftsregeln und die Beantwortung von Informationsanfragen von anderen Komponenten wie der Ansicht und dem Controller verantwortlich.

2. Anzeigen

Zeigt dem Benutzer die Daten vom Modell an und sendet Benutzereingaben an den Controller. Es ist passiv und interagiert nicht direkt mit dem Modell. Stattdessen empfängt es Daten vom Modell und sendet Benutzereingaben zur Verarbeitung an den Controller.

3. Controller

Der Controller fungiert als Vermittler zwischen dem Modell und der Ansicht. Es verarbeitet Benutzereingaben und aktualisiert das Modell entsprechend und aktualisiert die Ansicht, um Änderungen im Modell widerzuspiegeln. Es enthält Anwendungslogik, wie z. B. Eingabevalidierung und Datentransformation.

Kommunikation zwischen den Komponenten

Dieser unten stehende Kommunikationsfluss stellt sicher, dass jede Komponente für einen bestimmten Aspekt der Funktionalität der Anwendung verantwortlich ist, was zu einer besser wartbaren und skalierbaren Architektur führt

  • Benutzerinteraktion mit Ansicht:
    • Der Benutzer interagiert mit der Ansicht, indem er beispielsweise auf eine Schaltfläche klickt oder Text in ein Formular eingibt.
  • Ansicht empfängt Benutzereingaben:
    • Der View empfängt die Benutzereingaben und leitet sie an den Controller weiter.
  • Controller verarbeitet Benutzereingaben:
    • Der Controller empfängt die Benutzereingaben von der Ansicht.
    • Es interpretiert die Eingabe, führt alle erforderlichen Vorgänge aus (z. B. die Aktualisierung des Modells) und entscheidet, wie reagiert werden soll.
  • Controller-Updates-Modell:
    • Der Controller aktualisiert das Modell basierend auf der Benutzereingabe oder der Anwendungslogik.
  • Modell benachrichtigt Ansicht über Änderungen:
    • Wenn sich das Modell ändert, benachrichtigt es die Ansicht.
  • Anforderungsdaten vom Modell anzeigen:
    • Die Ansicht fordert Daten vom Modell an, um seine Anzeige zu aktualisieren.
  • Ansicht „Controller-Updates“:
    • Der Controller aktualisiert die Ansicht basierend auf den Änderungen im Modell oder als Reaktion auf Benutzereingaben.
  • Aktualisierte Benutzeroberfläche für Renderings anzeigen:
    • Die Ansicht rendert die aktualisierte Benutzeroberfläche basierend auf den vom Controller vorgenommenen Änderungen.

Beispiel für das MVC-Entwurfsmuster

Unten ist der Code der obigen Problemstellung unter Verwendung des MVC-Entwurfsmusters:

Lassen Sie uns den komponentenbezogenen Code aufschlüsseln:

1. Modell (Studentenklasse)

Stellt die Daten dar (Name des Schülers und Rollennummer) und stellt Methoden für den Zugriff auf und die Änderung dieser Daten bereit.

Java


Ausrichten eines Bildes in CSS



class> Student {> >private> String rollNo;> >private> String name;> >public> String getRollNo() {> >return> rollNo;> >}> >public> void> setRollNo(String rollNo) {> >this>.rollNo = rollNo;> >}> >public> String getName() {> >return> name;> >}> >public> void> setName(String name) {> >this>.name = name;> >}> }> 

>

>

2. View (StudentView-Klasse)

Stellt dar, wie die Daten (Studentendetails) dem Benutzer angezeigt werden sollen. Enthält eine Methode ( printStudentDetails> ), um den Namen und die Rollennummer des Schülers auszudrucken.

Java




Java-Concat-String
class> StudentView {> >public> void> printStudentDetails(String studentName, String studentRollNo) {> >System.out.println(>'Student:'>);> >System.out.println(>'Name: '> + studentName);> >System.out.println(>'Roll No: '> + studentRollNo);> >}> }> 

>

>

Java-Benutzereingabe

3. Controller (StudentController-Klasse)

Fungiert als Vermittler zwischen dem Modell und der Ansicht. Enthält Verweise auf die Model- und View-Objekte. Bietet Methoden zum Aktualisieren des Modells (z. B. setStudentName> , setStudentRollNo> ) und um die Ansicht zu aktualisieren ( updateView> ).

Java




class> StudentController {> >private> Student model;> >private> StudentView view;> >public> StudentController(Student model, StudentView view) {> >this>.model = model;> >this>.view = view;> >}> >public> void> setStudentName(String name) {> >model.setName(name);> >}> >public> String getStudentName() {> >return> model.getName();> >}> >public> void> setStudentRollNo(String rollNo) {> >model.setRollNo(rollNo);> >}> >public> String getStudentRollNo() {> >return> model.getRollNo();> >}> >public> void> updateView() {> >view.printStudentDetails(model.getName(), model.getRollNo());> >}> }> 

>

>

Vollständiger Code für das obige Beispiel

Nachfolgend finden Sie den vollständigen Code für das obige Beispiel:

Java




class> Student {> >private> String rollNo;> >private> String name;> >public> String getRollNo() {> >return> rollNo;> >}> >public> void> setRollNo(String rollNo) {> >this>.rollNo = rollNo;> >}> >public> String getName() {> >return> name;> >}> >public> void> setName(String name) {> >this>.name = name;> >}> }> class> StudentView {> >public> void> printStudentDetails(String studentName, String studentRollNo) {> >System.out.println(>'Student:'>);> >System.out.println(>'Name: '> + studentName);> >System.out.println(>'Roll No: '> + studentRollNo);> >}> }> class> StudentController {> >private> Student model;> >private> StudentView view;> >public> StudentController(Student model, StudentView view) {> >this>.model = model;> >this>.view = view;> >}> >public> void> setStudentName(String name) {> >model.setName(name);> >}> >public> String getStudentName() {> >return> model.getName();> >}> >public> void> setStudentRollNo(String rollNo) {> >model.setRollNo(rollNo);> >}> >public> String getStudentRollNo() {> >return> model.getRollNo();> >}> >public> void> updateView() {> >view.printStudentDetails(model.getName(), model.getRollNo());> >}> }> public> class> MVCPattern {> >public> static> void> main(String[] args) {> >Student model = retriveStudentFromDatabase();> >StudentView view =>new> StudentView();> >StudentController controller =>new> StudentController(model, view);> >controller.updateView();> >controller.setStudentName(>'Vikram Sharma'>);> >controller.updateView();> >}> >private> static> Student retriveStudentFromDatabase() {> >Student student =>new> Student();> >student.setName(>'Lokesh Sharma'>);> >student.setRollNo(>'15UCS157'>);> >return> student;> >}> }> 

>

>

Ausgabe

Array in Java drucken




Student:> Name: Lokesh Sharma> Roll No: 15UCS157> Student:> Name: Vikram Sharma> Roll No: 15UCS157> 

>

>

Vorteile des MVC-Entwurfsmusters

  • Trennung von Bedenken: MVC trennt die verschiedenen Aspekte einer Anwendung (Daten, Benutzeroberfläche und Logik) und erleichtert so das Verständnis, die Wartung und die Änderung des Codes.
  • Modularität: Jede Komponente (Modell, Ansicht, Controller) kann separat entwickelt und getestet werden, was die Wiederverwendbarkeit und Skalierbarkeit des Codes fördert.
  • Flexibilität: Da die Komponenten unabhängig sind, wirken sich Änderungen an einer Komponente nicht auf die anderen aus, was Aktualisierungen und Änderungen erleichtert.
  • Parallele Entwicklung: Mehrere Entwickler können gleichzeitig an verschiedenen Komponenten arbeiten, was den Entwicklungsprozess beschleunigt.
  • Wiederverwendbarkeit des Codes: Die Komponenten können in anderen Teilen der Anwendung oder in anderen Projekten wiederverwendet werden, wodurch Entwicklungszeit und -aufwand reduziert werden.

Nachteile des MVC-Entwurfsmusters

  • Komplexität: Die Implementierung des MVC-Musters kann insbesondere bei einfacheren Anwendungen die Komplexität des Codes erhöhen und zu einem Mehraufwand bei der Entwicklung führen.
  • Lernkurve: Entwickler müssen das Konzept von MVC verstehen und wissen, wie sie es effektiv implementieren können, was möglicherweise zusätzliche Zeit und Ressourcen erfordert.
  • Gemeinkosten: Die Kommunikation zwischen Komponenten (Modell, Ansicht, Controller) kann zu Overhead führen und die Leistung der Anwendung beeinträchtigen, insbesondere in Umgebungen mit eingeschränkten Ressourcen.
  • Potenzial für Over-Engineering: In manchen Fällen können Entwickler die Anwendung überdimensionieren, indem sie unnötige Abstraktionen und Ebenen hinzufügen, was zu aufgeblähtem und schwer zu wartendem Code führt.
  • Erhöhte Dateianzahl: MVC kann im Vergleich zu einfacheren Architekturen zu einer größeren Anzahl von Dateien und Klassen führen, was die Projektstruktur komplexer und schwieriger zu navigieren machen kann.