Kontroler widoku modelu (MVC) jest dobrze znanym rozwiązaniem wzór projektowy w dziedzinie tworzenia stron internetowych. Jest to sposób na uporządkowanie naszego kodu. Określa, że program lub aplikacja będzie składać się z modelu danych, informacji prezentacyjnych i informacji sterujących. Wzorzec MVC wymaga oddzielenia wszystkich tych komponentów jako różnych obiektów.
W tej sekcji omówimy architekturę MVC w Javie, wraz z jej zaletami i wadami oraz przykładami pozwalającymi zrozumieć implementację MVC w Javie.
Jaka jest architektura MVC w Javie?
Projekty modeli oparte na architekturze MVC są zgodne ze wzorcem projektowym MVC. Logika aplikacji jest oddzielona od interfejsu użytkownika podczas projektowania oprogramowania z wykorzystaniem projektów modelowych.
Architektura wzorców MVC składa się z trzech warstw:
zamień na ciąg
W programowaniu w języku Java model zawiera proste Klasy Javy , Widok używany do wyświetlania danych, a Kontroler zawiera serwlety . Ze względu na tę separację żądania użytkowników są przetwarzane w następujący sposób:
- Klient (przeglądarka) wysyła do kontrolera po stronie serwera żądanie wyświetlenia strony.
- Następnie kontroler wywołuje model. Gromadzi żądane dane.
- Następnie kontroler przesyła pobrane dane do warstwy widoku.
- Teraz wynik jest wysyłany z powrotem do przeglądarki (klienta) przez widok.
Zalety architektury MVC
Zalety architektury MVC są następujące:
dlaczego ciąg niezmienny w Javie
- MVC ma funkcję skalowalności, która z kolei pomaga w rozwoju aplikacji.
- Komponenty są łatwe w utrzymaniu, ponieważ istnieje mniejsza zależność.
- Model może być ponownie wykorzystany w wielu widokach, co zapewnia możliwość ponownego wykorzystania kodu.
- Programiści mogą pracować jednocześnie z trzema warstwami (Modelem, Widokiem i Kontrolerem).
- Dzięki MVC aplikacja staje się bardziej zrozumiała.
- Używając MVC, każda warstwa jest utrzymywana osobno, dzięki czemu nie musimy zajmować się ogromnym kodem.
- Rozszerzanie i testowanie aplikacji jest łatwiejsze.
Implementacja MVC przy użyciu języka Java
Aby zaimplementować wzorzec MVC w Javie, musimy utworzyć następujące trzy klasy.
Warstwy architektury MVC
Warstwa modelu
Model we wzorcu projektowym MVC działa jako warstwa danych dla aplikacji. Reprezentuje logikę biznesową aplikacji, a także stan aplikacji. Obiekt modelu pobiera i przechowuje stan modelu w bazie danych. Za pomocą warstwy modelu reguły są stosowane do danych reprezentujących koncepcje aplikacji.
Rozważmy następujący fragment kodu, który tworzy element będący jednocześnie pierwszym krokiem do wdrożenia wzorca MVC.
Pracownik.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; } } Powyższy kod składa się po prostu z metod pobierających i ustawiających klasę Pracownik.
Wyświetl warstwę
Jak sama nazwa wskazuje, widok reprezentuje wizualizację danych otrzymanych z modelu. Warstwa widoku składa się z danych wyjściowych aplikacji lub interfejsu użytkownika. Wysyła do klienta żądane dane, które są pobierane z warstwy modelu przez kontroler.
Weźmy przykład, w którym tworzymy widok za pomocą klasy EmployeeView.
EmployeeView.java
k najbliższy sąsiad
// 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); } } Warstwa kontrolera
Warstwa kontrolera pobiera żądania użytkowników z warstwy widoku i przetwarza je, poddając niezbędne walidacje. Działa jako interfejs pomiędzy modelem i widokiem. Żądania są następnie wysyłane do modelu w celu przetworzenia danych. Po przetworzeniu dane są przesyłane z powrotem do kontrolera, a następnie wyświetlane na widoku.
Rozważmy następujący fragment kodu, który tworzy kontroler przy użyciu klasy EmployeeController.
plik csv odczytuje Java
Kontroler pracownika.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()); } } Główny plik Java klasy
Poniższy przykład wyświetla główny plik służący do implementacji architektury MVC. Tutaj używamy klasy 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; } } The MVCMain class pobiera dane pracownika z metody, w której wprowadziliśmy wartości. Następnie wypycha te wartości do modelu. Następnie inicjuje widok (EmployeeView.java). Po zainicjowaniu widoku wywoływany jest kontroler (EmployeeController.java), który wiąże go z klasą Employee i klasą EmployeeView. Wreszcie metoda updateView() (metoda kontrolera) aktualizuje dane pracownika, które mają zostać wydrukowane na konsoli.
Wyjście:
Employee Details: Name: Anu Employee ID: 11 Employee Department: Salesforce Employee Details after updating: Name: Nirnay Employee ID: 11 Employee Department: Salesforce
W ten sposób poznaliśmy architekturę MVC, znaczenie poszczególnych warstw oraz jej implementację w Javie.