Der Model-View-Controller (MVC) ist ein bekannter Designmuster im Bereich Webentwicklung. Auf diese Weise können wir unseren Code organisieren. Es legt fest, dass ein Programm oder eine Anwendung aus einem Datenmodell, Präsentationsinformationen und Steuerinformationen bestehen muss. Das MVC-Muster erfordert, dass alle diese Komponenten als unterschiedliche Objekte getrennt werden.

In diesem Abschnitt besprechen wir die MVC-Architektur in Java sowie ihre Vor- und Nachteile und Beispiele zum Verständnis der Implementierung von MVC in Java.

Was ist MVC-Architektur in Java?

Die auf der MVC-Architektur basierenden Modellentwürfe folgen dem MVC-Entwurfsmuster. Die Anwendungslogik wird beim Entwerfen der Software mithilfe von Modellentwürfen von der Benutzeroberfläche getrennt.

Fabrikdesignmuster

Die MVC-Musterarchitektur besteht aus drei Schichten:

Modell:Es stellt die Geschäftsschicht der Anwendung dar. Es handelt sich um ein Objekt zum Übertragen der Daten, das auch die Logik zur Aktualisierung des Controllers enthalten kann, wenn Daten geändert werden.Sicht:Es stellt die Präsentationsschicht der Anwendung dar. Es dient zur Visualisierung der im Modell enthaltenen Daten.Regler:Es funktioniert sowohl am Modell als auch an der Ansicht. Es wird verwendet, um den Anwendungsfluss, d. h. den Datenfluss im Modellobjekt, zu verwalten und die Ansicht zu aktualisieren, wenn Daten geändert werden.

In der Java-Programmierung enthält das Modell das Einfache Java-Klassen , die Ansicht, die zum Anzeigen der Daten verwendet wird, und der Controller enthält die Servlets . Aufgrund dieser Trennung werden die Benutzeranfragen wie folgt bearbeitet:

1. Ein Client (Browser) sendet eine Anfrage für eine Seite an den Controller auf der Serverseite.
2. Der Controller ruft dann das Modell auf. Es sammelt die angeforderten Daten.
3. Anschließend überträgt der Controller die abgerufenen Daten an die Ansichtsschicht.
4. Nun wird das Ergebnis von der Ansicht an den Browser (Client) zurückgesendet.

Vorteile der MVC-Architektur

Die Vorteile der MVC-Architektur sind wie folgt:

• MVC verfügt über die Eigenschaft der Skalierbarkeit, die wiederum das Wachstum der Anwendung unterstützt.
• Die Komponenten sind einfach zu warten, da weniger Abhängigkeiten bestehen.
• Ein Modell kann von mehreren Ansichten wiederverwendet werden, was die Wiederverwendbarkeit des Codes gewährleistet.
• Die Entwickler können gleichzeitig mit den drei Ebenen (Modell, Ansicht und Controller) arbeiten.
• Mit MVC wird die Anwendung verständlicher.
• Bei Verwendung von MVC wird jede Ebene separat verwaltet, sodass wir uns nicht mit umfangreichem Code befassen müssen.
• Das Erweitern und Testen der Anwendung ist einfacher.

Implementierung von MVC mit Java

Um das MVC-Muster in Java zu implementieren, müssen wir die folgenden drei Klassen erstellen.

Mitarbeiterklasse, fungiert als ModellebeneEmployeeView-Klassefungiert als AnsichtsebeneEmployeeController-Klassefungiert als Controller-Ebene

MVC-Architekturschichten

Modellebene

Das Modell im MVC-Entwurfsmuster fungiert als Datenschicht für die Anwendung. Es repräsentiert die Geschäftslogik für die Anwendung und auch den Anwendungsstatus. Das Modellobjekt ruft den Modellstatus ab und speichert ihn in der Datenbank. Mithilfe der Modellebene werden Regeln auf die Daten angewendet, die die Anwendungskonzepte darstellen.

Betrachten wir den folgenden Codeausschnitt, der ein erstellt, das auch der erste Schritt zur Implementierung des MVC-Musters ist.

Employee.java

 // class that represents model public class Employee { // declaring the variables private String EmployeeName; private String EmployeeId; private String EmployeeDepartment; // defining getter and setter methods public String getId() { return EmployeeId; } public void setId(String id) { this.EmployeeId = id; } public String getName() { return EmployeeName; } public void setName(String name) { this.EmployeeName = name; } public String getDepartment() { return EmployeeDepartment; } public void setDepartment(String Department) { this.EmployeeDepartment = Department; } } 

Der obige Code besteht einfach aus Getter- und Setter-Methoden für die Employee-Klasse.

Ebene anzeigen

Wie der Name schon sagt, stellt die Ansicht die Visualisierung der vom Modell empfangenen Daten dar. Die Ansichtsschicht besteht aus der Ausgabe der Anwendung oder Benutzeroberfläche. Es sendet die angeforderten Daten an den Client, die vom Controller aus der Modellebene abgerufen werden.

Nehmen wir ein Beispiel, in dem wir eine Ansicht mithilfe der EmployeeView-Klasse erstellen.

EmployeeView.java

 // class which represents the view public class EmployeeView { // method to display the Employee details public void printEmployeeDetails (String EmployeeName, String EmployeeId, String EmployeeDepartment){ System.out.println('Employee Details: '); System.out.println('Name: ' + EmployeeName); System.out.println('Employee ID: ' + EmployeeId); System.out.println('Employee Department: ' + EmployeeDepartment); } } 

Controller-Schicht

Die Controller-Schicht ruft die Benutzeranfragen von der Ansichtsschicht ab und verarbeitet sie mit den erforderlichen Validierungen. Es fungiert als Schnittstelle zwischen Modell und Ansicht. Die Anfragen werden dann zur Datenverarbeitung an das Modell gesendet. Nach der Verarbeitung werden die Daten an die Steuerung zurückgesendet und dann in der Ansicht angezeigt.

Betrachten wir den folgenden Codeausschnitt, der den Controller mithilfe der EmployeeController-Klasse erstellt.

EmployeeController.java

 // class which represent the controller public class EmployeeController { // declaring the variables model and view private Employee model; private EmployeeView view; // constructor to initialize public EmployeeController(Employee model, EmployeeView view) { this.model = model; this.view = view; } // getter and setter methods public void setEmployeeName(String name){ model.setName(name); } public String getEmployeeName(){ return model.getName(); } public void setEmployeeId(String id){ model.setId(id); } public String getEmployeeId(){ return model.getId(); } public void setEmployeeDepartment(String Department){ model.setDepartment(Department); } public String getEmployeeDepartment(){ return model.getDepartment(); } // method to update view public void updateView() { view.printEmployeeDetails(model.getName(), model.getId(), model.getDepartment()); } } 

Hauptklassen-Java-Datei

Das folgende Beispiel zeigt die Hauptdatei zur Implementierung der MVC-Architektur. Hier verwenden wir die MVCMain-Klasse.

MVCMain.java

 // main class public class MVCMain { public static void main(String[] args) { // fetching the employee record based on the employee_id from the database Employee model = retriveEmployeeFromDatabase(); // creating a view to write Employee details on console EmployeeView view = new EmployeeView(); EmployeeController controller = new EmployeeController(model, view); controller.updateView(); //updating the model data controller.setEmployeeName('Nirnay'); System.out.println('
 Employee Details after updating: '); controller.updateView(); } private static Employee retriveEmployeeFromDatabase(){ Employee Employee = new Employee(); Employee.setName('Anu'); Employee.setId('11'); Employee.setDepartment('Salesforce'); return Employee; } } 

Der MVCMain Die Klasse ruft die Mitarbeiterdaten von der Methode ab, in der wir die Werte eingegeben haben. Dann werden diese Werte in das Modell verschoben. Danach wird die Ansicht initialisiert (EmployeeView.java). Wenn die Ansicht initialisiert wird, wird der Controller (EmployeeController.java) aufgerufen und an die Employee-Klasse und die EmployeeView-Klasse gebunden. Zuletzt aktualisiert die updateView()-Methode (Methode des Controllers) die Mitarbeiterdetails, die auf der Konsole gedruckt werden sollen.

Ausgabe:

 Employee Details: Name: Anu Employee ID: 11 Employee Department: Salesforce Employee Details after updating: Name: Nirnay Employee ID: 11 Employee Department: Salesforce 

Auf diese Weise haben wir etwas über die MVC-Architektur, die Bedeutung jeder Schicht und ihre Implementierung in Java gelernt.