Il Model-View-Controller (MVC) è un noto design pattern nel campo dello sviluppo web. È un modo per organizzare il nostro codice. Specifica che un programma o un'applicazione deve consistere in un modello di dati, informazioni di presentazione e informazioni di controllo. Il modello MVC richiede che tutti questi componenti siano separati come oggetti diversi.

In questa sezione discuteremo dell'architettura MVC in Java, insieme ai suoi vantaggi e svantaggi ed esempi per comprendere l'implementazione di MVC in Java.

Cos'è l'architettura MVC in Java?

Le progettazioni del modello basate sull'architettura MVC seguono il modello di progettazione MVC. La logica dell'applicazione è separata dall'interfaccia utente durante la progettazione del software utilizzando progetti di modelli.

saltare l'elenco

L'architettura del pattern MVC è composta da tre livelli:

Modello:Rappresenta il livello aziendale dell'applicazione. È un oggetto che trasporta i dati che può contenere anche la logica per aggiornare il controller se i dati vengono modificati.Visualizzazione:Rappresenta il livello di presentazione dell'applicazione. Viene utilizzato per visualizzare i dati contenuti nel modello.Controllore:Funziona sia sul modello che sulla vista. Viene utilizzato per gestire il flusso dell'applicazione, ovvero il flusso di dati nell'oggetto del modello e per aggiornare la vista ogni volta che i dati vengono modificati.

Nella programmazione Java, il modello contiene il semplice Classi Java , la View utilizzata per visualizzare i dati e il Controller contiene il file servlet . A causa di questa separazione le richieste degli utenti vengono elaborate come segue:

1. Un client (browser) invia una richiesta al controller sul lato server, per una pagina.
2. Il controller quindi chiama il modello. Raccoglie i dati richiesti.
3. Quindi il controller trasferisce i dati recuperati al livello di visualizzazione.
4. Ora il risultato viene rimandato al browser (client) dalla vista.

Vantaggi dell'architettura MVC

I vantaggi dell'architettura MVC sono i seguenti:

• MVC ha la caratteristica della scalabilità che a sua volta aiuta la crescita dell'applicazione.
• I componenti sono facili da mantenere perché c'è meno dipendenza.
• Un modello può essere riutilizzato da più viste che garantiscono la riusabilità del codice.
• Gli sviluppatori possono lavorare contemporaneamente con i tre livelli (Modello, Vista e Controller).
• Utilizzando MVC, l'applicazione diventa più comprensibile.
• Utilizzando MVC, ogni livello viene mantenuto separatamente, quindi non è necessario gestire un codice di grandi dimensioni.
• L'estensione e il test dell'applicazione sono più semplici.

Implementazione di MVC utilizzando Java

Per implementare il modello MVC in Java, dobbiamo creare le seguenti tre classi.

Classe dei dipendenti, fungerà da livello del modelloClasse EmployeeView, fungerà da livello di visualizzazioneClasse EmployeeController, agirà come livello di controllo

Livelli dell'architettura MVC

Livello del modello

Il modello nel modello di progettazione MVC funge da livello dati per l'applicazione. Rappresenta la logica aziendale per l'applicazione e anche lo stato dell'applicazione. L'oggetto del modello recupera e memorizza lo stato del modello nel database. Utilizzando il livello del modello, ai dati vengono applicate regole che rappresentano i concetti di applicazione.

Consideriamo il seguente frammento di codice che crea un che è anche il primo passo per implementare il pattern MVC.

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

Il codice precedente consiste semplicemente di metodi getter e setter per la classe Employee.

Visualizza livello

Come indica il nome, view rappresenta la visualizzazione dei dati ricevuti dal modello. Il livello di visualizzazione è costituito dall'output dell'applicazione o dell'interfaccia utente. Invia i dati richiesti al client, che vengono recuperati dal livello del modello dal controller.

Prendiamo un esempio in cui creiamo una vista utilizzando la classe 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); } } 

Livello di controllo

Il livello controller riceve le richieste dell'utente dal livello vista e le elabora, con le convalide necessarie. Funge da interfaccia tra Modello e Vista. Le richieste vengono poi inviate al modello per l'elaborazione dei dati. Una volta elaborati, i dati vengono rinviati al responsabile del trattamento e quindi visualizzati nella vista.

Consideriamo il seguente frammento di codice che crea il controller utilizzando la classe 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()); } } 

File Java della classe principale

L'esempio seguente mostra il file principale per implementare l'architettura MVC. Qui stiamo utilizzando la classe 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; } } 

IL MVCMain class recupera i dati dei dipendenti dal metodo in cui abbiamo inserito i valori. Quindi spinge quei valori nel modello. Successivamente, inizializza la vista (EmployeeView.java). Quando la vista viene inizializzata, viene richiamato il Controller (EmployeeController.java) che lo associa alla classe Employee e alla classe EmployeeView. Infine il metodo updateView() (metodo del controller) aggiorna i dettagli del dipendente da stampare sulla console.

Produzione:

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

In questo modo, abbiamo appreso l'architettura MVC, il significato di ogni livello e la sua implementazione in Java.