A Model-View-Controller (MVC) jól ismert tervezési minta a webfejlesztés területén. Ez egy módja annak, hogy rendszerezzük a kódunkat. Meghatározza, hogy egy programnak vagy alkalmazásnak adatmodellből, megjelenítési információból és vezérlőinformációból kell állnia. Az MVC-mintának ezeket az összetevőket külön objektumként kell elválasztani.

Ebben a részben a Java MVC architektúráját, annak előnyeit és hátrányait, valamint az MVC Java-ban való megvalósításának megértéséhez szükséges példákat tárgyaljuk.

Mi az MVC architektúra a Java-ban?

Az MVC architektúrán alapuló modelltervek az MVC tervezési mintát követik. A szoftver modelltervek segítségével történő tervezése során az alkalmazás logikája elválik a felhasználói felülettől.

React js oktatóanyag

Az MVC minta architektúra három rétegből áll:

Modell:Az alkalmazás üzleti rétegét képviseli. Ez egy adathordozó objektum, amely tartalmazhatja a vezérlő frissítésének logikáját is, ha az adatok megváltoznak.Kilátás:Az alkalmazás bemutatási rétegét képviseli. A modellben található adatok megjelenítésére szolgál.Vezérlő:Modell és nézet esetén is működik. Az alkalmazás folyamatának, azaz a modellobjektumban lévő adatfolyamnak a kezelésére és a nézet frissítésére szolgál, amikor az adatok megváltoznak.

A Java programozásban a Modell az egyszerűt tartalmazza Java osztályok , az adatok megjelenítésére használt Nézet és a Vezérlő tartalmazza a szervletek . Ennek az elválasztásnak köszönhetően a felhasználói kérések feldolgozása a következőképpen történik:

1. Egy kliens (böngésző) kérést küld a szerveroldali vezérlőnek egy oldalra vonatkozóan.
2. A vezérlő ezután meghívja a modellt. Összegyűjti a kért adatokat.
3. Ezután a vezérlő a visszakeresett adatokat továbbítja a nézetrétegre.
4. Most az eredményt a nézet visszaküldi a böngészőnek (kliensnek).

Az MVC Architecture előnyei

Az MVC architektúra előnyei a következők:

• Az MVC rendelkezik a skálázhatóság jellemzőivel, ami viszont segíti az alkalmazások növekedését.
• Az alkatrészeket könnyű karbantartani, mert kisebb a függőség.
• Egy modell több nézetben is újrafelhasználható, ami biztosítja a kód újrafelhasználását.
• A fejlesztők a három réteggel (Modell, View és Controller) dolgozhatnak egyszerre.
• Az MVC használatával az alkalmazás érthetőbbé válik.
• Az MVC használatával minden réteget külön karbantartanak, ezért nem kell nagy mennyiségű kóddal foglalkoznunk.
• Az alkalmazás bővítése és tesztelése egyszerűbb.

MVC implementációja Java segítségével

Az MVC minta Java-ban való megvalósításához a következő három osztályt kell létrehoznunk.

Alkalmazotti osztály, mintarétegként fog működniEmployeeView osztály, nézetrétegként fog működniEmployeeContoller osztály, vezérlő rétegként fog működni

MVC Architecture Layers

Modellréteg

Az MVC tervezési mintájában lévő modell adatrétegként működik az alkalmazás számára. Ez képviseli az alkalmazás üzleti logikáját és az alkalmazás állapotát is. A modellobjektum lekéri és tárolja a modellállapotot az adatbázisban. A modellréteg használatával szabályokat alkalmaznak azokra az adatokra, amelyek az alkalmazás fogalmait képviselik.

Tekintsük a következő kódrészletet, amely létrehoz egy, amely egyben az MVC minta megvalósításának első lépése is.

Munkavállaló.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; } } 

A fenti kód egyszerűen getter és setter metódusokból áll az Employee osztályba.

Réteg megtekintése

Ahogy a név is mutatja, a nézet a modelltől kapott adatok megjelenítését jelenti. A nézeti réteg az alkalmazás vagy a felhasználói felület kimenetéből áll. A kért adatokat elküldi a kliensnek, amelyeket vezérlőnként kér le a modellrétegről.

Vegyünk egy példát, ahol az EmployeeView osztály használatával hozunk létre egy nézetet.

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

Vezérlőréteg

A vezérlőréteg megkapja a felhasználói kéréseket a nézetrétegtől, és feldolgozza azokat a szükséges érvényesítésekkel. Interfészként működik a Modell és a View között. A kérések ezután elküldésre kerülnek a modellnek adatfeldolgozás céljából. Feldolgozásuk után az adatok visszaküldésre kerülnek a vezérlőnek, majd megjelennek a nézetben.

Tekintsük a következő kódrészletet, amely az EmployeeController osztály használatával hozza létre a vezérlőt.

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

Főosztályú Java fájl

A következő példa az MVC architektúra megvalósításához szükséges fő fájlt jeleníti meg. Itt az MVCMain osztályt használjuk.

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

A MVCMain osztály lekéri az alkalmazottak adatait abból a metódusból, ahol az értékeket megadtuk. Ezután ezeket az értékeket benyomja a modellbe. Ezt követően inicializálja a nézetet (EmployeeView.java). A nézet inicializálásakor a Vezérlő (EmployeeController.java) meghívásra kerül, és az Employee osztályhoz és az EmployeeView osztályhoz kötődik. Végül az updateView() metódus (a vezérlő módszere) frissíti a konzolra nyomtatandó munkavállalói adatokat.

Kimenet:

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

Ily módon megismertük az MVC architektúrát, az egyes rétegek jelentőségét és a Java-ban való megvalósítását.