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.

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ödni EmployeeView osztály , nézetrétegként fog működni EmployeeContoller 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.