Model-View-Controller (MVC)

Model-View-Controller (MVC) Entwurfsmuster

Das Model-View-Controller-Muster (kurz: MVC) ist ein grundlegendes Architekturmuster der Softwareentwicklung, das zur **Trennung von Daten, Darstellung und Logik** dient. Es sorgt für eine klare Struktur, bessere Wartbarkeit und Wiederverwendbarkeit von Code, insbesondere in GUI- und Webanwendungen.

Grundidee

Das MVC-Muster teilt eine Anwendung in drei klar getrennte Komponenten:

Komponente	Aufgabe
Model	Enthält die Anwendungslogik, Datenstrukturen und Regeln. Verwaltet den Zustand der Anwendung unabhängig von der Benutzeroberfläche.
View	Präsentiert die Daten des Models dem Benutzer (z. B. GUI, Webseite, Konsole). Reagiert auf Änderungen im Model.
Controller	Nimmt Benutzereingaben entgegen, interpretiert sie und ändert Model oder View entsprechend.

+--------------+        +--------------+        +--------------+
|    View      | <----> |  Controller  | <----> |    Model     |
| (Anzeige)    |        | (Steuerung)  |        | (Daten)      |
+--------------+        +--------------+        +--------------+

Ablauf

1. **Benutzeraktion:** Der Benutzer interagiert mit der View (z. B. klickt einen Button). 2. **Steuerung:** Der Controller empfängt das Ereignis und ändert den Zustand des Models. 3. **Datenänderung:** Das Model aktualisiert seine Daten und informiert die View. 4. **Anzeige:** Die View aktualisiert die Darstellung gemäß den neuen Modeldaten.

Beispiel (C++ mit Pseudocode)

#include <iostream>
#include <string>

// MODEL
class Model {
    std::string text = "Hello";
public:
    std::string getText() const { return text; }
    void setText(const std::string& t) { text = t; }
};

// VIEW
class View {
public:
    void display(const std::string& data) {
        std::cout << "Anzeige: " << data << std::endl;
    }
};

// CONTROLLER
class Controller {
    Model& model;
    View& view;
public:
    Controller(Model& m, View& v) : model(m), view(v) {}
    void onUserInput(const std::string& input) {
        model.setText(input);
        view.display(model.getText());
    }
};

int main() {
    Model model;
    View view;
    Controller controller(model, view);

    controller.onUserInput("Hallo MVC!");
}

• • Ergebnis:**

Anzeige: Hallo MVC!

Vorteile

• **Klare Trennung von Logik, Daten und Darstellung**
• **Einfachere Wartung und Testbarkeit**
• **Mehrfachverwendung des Models mit unterschiedlichen Views**
• **Unabhängige Entwicklung von Frontend und Backend**

Nachteile

• Zusätzlicher Strukturierungsaufwand
• Höhere Komplexität bei kleinen Projekten
• Kommunikation zwischen Komponenten kann aufwendig werden

Varianten

Das MVC-Muster wurde in vielen Frameworks weiterentwickelt oder angepasst:

Variante	Beschreibung
MVP (Model-View-Presenter)	Der Presenter übernimmt mehr Logik und kommuniziert direkter mit der View.
MVVM (Model-View-ViewModel)	Typisch für GUI-Frameworks (z. B. WPF, MAUI). Datenbindung zwischen View und ViewModel.
HMVC	Hierarchisches MVC für modulare Anwendungen mit verschachtelten Controllern.

MVC in Webanwendungen

In modernen Webframeworks wird MVC weit verbreitet eingesetzt:

• **Model:** Daten und Geschäftslogik (z. B. Datenbankmodelle)
• **View:** HTML-/Template-Dateien
• **Controller:** Vermittelt zwischen HTTP-Anfragen und Modellen

Beispiel in Frameworks:

• **Laravel (PHP)**
• **Django (Python)**
• **ASP.NET MVC (C#)**
• **Spring MVC (Java)**
• **Ruby on Rails**

Beispiel einer Webstruktur

/app
 ├── models/
 │   └── user.php
 ├── views/
 │   └── userView.html
 └── controllers/
     └── userController.php

Vergleich mit ähnlichen Mustern

Muster	Fokus	Besonderheit
MVP (Model-View-Presenter)	GUI-Architektur	Presenter kontrolliert die View direkt
MVVM (Model-View-ViewModel)	Datenbindung	ViewModel abstrahiert View komplett
PAC (Presentation-Abstraction-Control)	Interaktive Systeme	Hierarchisch strukturierte Variante von MVC

Einsatzgebiete

• Benutzeroberflächen (Desktop, Web, Mobile)
• GUI-Frameworks (Qt, JavaFX, WPF)
• Webframeworks (Laravel, Django, Spring, Rails)
• Software mit klarer Trennung von Logik und Darstellung

Siehe auch

• MVP (Model-View-Presenter)
• MVVM (Model-View-ViewModel)
• PAC (Presentation-Abstraction-Control)
• Entwurfsmuster (Softwareentwicklung)
• Event-Driven Architecture
• Observer-Entwurfsmuster

Quellen

• Erich Gamma et al.: *Design Patterns – Elements of Reusable Object-Oriented Software*
• Trygve Reenskaug: *MVC Introduction (1979)*
• Wikipedia: Model–View–Controller
• Refactoring.Guru: MVC Pattern