Model-View-Controller (MVC) är en välkänd design mönster inom webbutvecklingsområdet. Det är sättet att organisera vår kod. Den anger att ett program eller en applikation ska bestå av datamodell, presentationsinformation och styrinformation. MVC-mönstret behöver alla dessa komponenter separeras som olika objekt.

I det här avsnittet kommer vi att diskutera MVC-arkitekturen i Java, tillsammans med dess fördelar och nackdelar och exempel för att förstå implementeringen av MVC i Java.

Vad är MVC-arkitektur i Java?

Modelldesignerna baserade på MVC-arkitekturen följer MVC-designmönster. Applikationslogiken separeras från användargränssnittet medan programvaran designas med modelldesigner.

java varaktighet

MVC-mönsterarkitekturen består av tre lager:

Modell:Det representerar affärsskiktet för tillämpningen. Det är ett objekt att bära data som också kan innehålla logiken att uppdatera styrenheten om data ändras.Se:Det representerar presentationslagret för tillämpningen. Den används för att visualisera de data som modellen innehåller.Kontroller:Det fungerar på både modell och vy. Den används för att hantera applikationsflödet, det vill säga dataflödet i modellobjektet och för att uppdatera vyn när data ändras.

I Java-programmering innehåller modellen det enkla Java klasser , vyn som används för att visa data och styrenheten innehåller servlets . På grund av denna separation behandlas användarförfrågningarna enligt följande:

1. En klient (webbläsare) skickar en begäran till kontrollenheten på serversidan om en sida.
2. Styrenheten anropar sedan modellen. Den samlar in de begärda uppgifterna.
3. Sedan överför styrenheten den hämtade datan till vylagret.
4. Nu skickas resultatet tillbaka till webbläsaren (klienten) av vyn.

Fördelar med MVC Architecture

Fördelarna med MVC-arkitektur är följande:

• MVC har funktionen av skalbarhet som i sin tur hjälper tillväxten av applikationer.
• Komponenterna är lätta att underhålla eftersom det är mindre beroende.
• En modell kan återanvändas av flera vyer som ger återanvändbarhet av kod.
• Utvecklarna kan arbeta med de tre lagren (Model, View och Controller) samtidigt.
• Med hjälp av MVC blir applikationen mer begriplig.
• Med MVC underhålls varje lager separat, därför behöver vi inte hantera massiv kod.
• Det är lättare att utöka och testa applikationen.

Implementering av MVC med Java

För att implementera MVC-mönster i Java måste vi skapa följande tre klasser.

Anställd klass, kommer att fungera som modelllagerEmployeeView-klass, kommer att fungera som ett vylagerEmployeeContoller Class, kommer att fungera som ett kontrolllager

MVC arkitekturlager

Modelllager

Modellen i MVC-designmönstret fungerar som ett datalager för applikationen. Det representerar affärslogiken för tillämpningen och även tillämpningsläget. Modellobjektet hämtar och lagrar modelltillståndet i databasen. Med hjälp av modelllagret tillämpas regler på data som representerar tillämpningsbegreppet.

Låt oss överväga följande kodavsnitt som skapar ett som också är det första steget för att implementera MVC-mönster.

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; } } 

Ovanstående kod består helt enkelt av getter- och settermetoder till klassen Employee.

Visa lager

Som namnet visar representerar view visualiseringen av data som tas emot från modellen. Vyskiktet består av utdata från applikation eller användargränssnitt. Den skickar den begärda informationen till klienten, som hämtas från modellskiktet av styrenheten.

Låt oss ta ett exempel där vi skapar en vy med klassen 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); } } 

Kontrolllager

Kontrolllagret hämtar användarförfrågningar från vylagret och bearbetar dem, med nödvändiga valideringar. Den fungerar som ett gränssnitt mellan Model och View. Förfrågningarna skickas sedan till modell för databehandling. När de har bearbetats skickas data tillbaka till kontrollanten och visas sedan på vyn.

Låt oss överväga följande kodavsnitt som skapar styrenheten med klassen EmployeeController.

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()); } } 

Main Class Java-fil

Följande exempel visar huvudfilen för att implementera MVC-arkitekturen. Här använder vi klassen 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 hämtar personaldata från metoden där vi har skrivit in värdena. Sedan pressar den de värdena i modellen. Efter det initieras vyn (EmployeeView.java). När vyn initieras, anropas styrenheten (EmployeeController.java) och binder den till klassen Employee och EmployeeView. Äntligen uppdaterar metoden updateView() (kontrolleringsmetod) personaluppgifterna som ska skrivas ut till konsolen.

Produktion:

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

På så sätt har vi lärt oss om MVC-arkitektur, betydelsen av varje lager och dess implementering i Java.