De Model-View-Controller (MVC) is een bekende ontwerp patroon op het gebied van webontwikkeling. Het is een manier om onze code te organiseren. Het specificeert dat een programma of applicatie moet bestaan uit een datamodel, presentatie-informatie en besturingsinformatie. Voor het MVC-patroon moeten al deze componenten worden gescheiden als verschillende objecten.
In deze sectie bespreken we de MVC-architectuur in Java, samen met de voor- en nadelen ervan en voorbeelden om de implementatie van MVC in Java te begrijpen.
Wat is MVC-architectuur in Java?
De modelontwerpen gebaseerd op de MVC-architectuur volgen het MVC-ontwerppatroon. De applicatielogica is gescheiden van de gebruikersinterface tijdens het ontwerpen van de software met behulp van modelontwerpen.
abstracte klasse in Java
De MVC-patroonarchitectuur bestaat uit drie lagen:
Bij Java-programmering bevat het model het eenvoudige Java-klassen , de weergave die wordt gebruikt om de gegevens weer te geven en de controller bevat de servetten . Door deze scheiding worden de gebruikersverzoeken als volgt verwerkt:
- Een client (browser) stuurt een verzoek voor een pagina naar de controller aan de serverzijde.
- De controller roept vervolgens het model aan. Het verzamelt de gevraagde gegevens.
- Vervolgens draagt de controller de opgehaalde gegevens over naar de weergavelaag.
- Nu wordt het resultaat door de weergave teruggestuurd naar de browser (client).
Voordelen van MVC-architectuur
De voordelen van MVC-architectuur zijn als volgt:
- MVC heeft de eigenschap van schaalbaarheid die op zijn beurt de groei van applicaties helpt.
- De componenten zijn eenvoudig te onderhouden omdat er minder afhankelijkheid is.
- Een model kan worden hergebruikt door meerdere weergaven, waardoor code opnieuw kan worden gebruikt.
- De ontwikkelaars kunnen tegelijkertijd met de drie lagen (Model, View en Controller) werken.
- Met behulp van MVC wordt de applicatie begrijpelijker.
- Met behulp van MVC wordt elke laag afzonderlijk onderhouden, waardoor we niet met enorme code te maken hebben.
- Het uitbreiden en testen van de applicatie is eenvoudiger.
Implementatie van MVC met behulp van Java
Om het MVC-patroon in Java te implementeren, moeten we de volgende drie klassen maken.
MVC-architectuurlagen
Modellaag
Het model in het MVC-ontwerppatroon fungeert als gegevenslaag voor de applicatie. Het vertegenwoordigt de bedrijfslogica voor de toepassing en ook de status van de toepassing. Het modelobject haalt de modelstatus op en slaat deze op in de database. Met behulp van de modellaag worden regels toegepast op de gegevens die de toepassingsconcepten vertegenwoordigen.
Laten we eens kijken naar het volgende codefragment waarmee een code wordt gemaakt die ook de eerste stap is om het MVC-patroon te implementeren.
Werknemer.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; } } De bovenstaande code bestaat eenvoudigweg uit getter- en setter-methoden voor de klasse Employee.
Laag bekijken
Zoals de naam aangeeft, vertegenwoordigt weergave de visualisatie van gegevens die zijn ontvangen van het model. De weergavelaag bestaat uit de uitvoer van een applicatie of gebruikersinterface. Het stuurt de gevraagde gegevens naar de client, die door de controller uit de modellaag worden opgehaald.
Laten we een voorbeeld nemen waarin we een weergave maken met behulp van de klasse EmployeeView.
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); } } Controllerlaag
De controllerlaag haalt de gebruikersverzoeken uit de viewlaag en verwerkt deze, met de nodige validaties. Het fungeert als een interface tussen Model en View. De verzoeken worden vervolgens naar het model voor gegevensverwerking gestuurd. Zodra ze zijn verwerkt, worden de gegevens teruggestuurd naar de controller en vervolgens weergegeven in de weergave.
Laten we eens kijken naar het volgende codefragment waarmee de controller wordt gemaakt met behulp van de klasse EmployeeController.
WerknemerController.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()); } } Hoofdklasse Java-bestand
In het volgende voorbeeld wordt het hoofdbestand weergegeven om de MVC-architectuur te implementeren. Hier gebruiken we de klasse MVCMain.
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; } } De MVCMain class haalt de werknemersgegevens op uit de methode waarin we de waarden hebben ingevoerd. Vervolgens worden deze waarden in het model gepusht. Daarna initialiseert het de weergave (EmployeeView.java). Wanneer de weergave wordt geïnitialiseerd, wordt de Controller (EmployeeController.java) aangeroepen en gekoppeld aan de klasse Employee en EmployeeView. Eindelijk werkt de updateView()-methode (methode van controller) de werknemersgegevens bij die naar de console moeten worden afgedrukt.
Uitgang:
Employee Details: Name: Anu Employee ID: 11 Employee Department: Salesforce Employee Details after updating: Name: Nirnay Employee ID: 11 Employee Department: Salesforce
Op deze manier hebben we geleerd over MVC-architectuur, de betekenis van elke laag en de implementatie ervan in Java.