El Model-View-Controller (MVC) és un conegut patró de disseny en l'àmbit del desenvolupament web. És una manera d'organitzar el nostre codi. Especifica que un programa o aplicació ha de consistir en un model de dades, informació de presentació i informació de control. El patró MVC necessita que tots aquests components es separen com a objectes diferents.

En aquesta secció, parlarem de l'arquitectura MVC a Java, juntament amb els seus avantatges i desavantatges i exemples per entendre la implementació de MVC a Java.

Què és l'arquitectura MVC a Java?

Els dissenys de models basats en l'arquitectura MVC segueixen el patró de disseny MVC. La lògica de l'aplicació està separada de la interfície d'usuari mentre es dissenya el programari mitjançant dissenys de models.

iterant una llista en java

L'arquitectura del patró MVC consta de tres capes:

Model:Representa la capa empresarial d'aplicació. És un objecte per portar les dades que també pot contenir la lògica per actualitzar el controlador si es canvien les dades.Visualització:Representa la capa de presentació de l'aplicació. S'utilitza per visualitzar les dades que conté el model.Controlador:Funciona tant al model com a la vista. S'utilitza per gestionar el flux de l'aplicació, és a dir, el flux de dades a l'objecte model i per actualitzar la vista sempre que es canvien les dades.

A la programació Java, el model conté el senzill Classes de Java , la Vista utilitzada per mostrar les dades i el Controlador conté el servlets . A causa d'aquesta separació, les sol·licituds dels usuaris es processen de la següent manera:

1. Un client (navegador) envia una sol·licitud al controlador del costat del servidor, per a una pàgina.
2. Aleshores, el controlador crida al model. Recull les dades sol·licitades.
3. A continuació, el controlador transfereix les dades recuperades a la capa de visualització.
4. Ara el resultat es torna a enviar al navegador (client) per la vista.

Avantatges de l'arquitectura MVC

Els avantatges de l'arquitectura MVC són els següents:

• MVC té la característica d'escalabilitat que al seu torn ajuda al creixement de l'aplicació.
• Els components són fàcils de mantenir perquè hi ha menys dependència.
• Un model es pot reutilitzar per múltiples vistes que proporcionen la reutilització del codi.
• Els desenvolupadors poden treballar amb les tres capes (Model, Vista i Controlador) simultàniament.
• Amb MVC, l'aplicació es fa més comprensible.
• Amb MVC, cada capa es manté per separat, per la qual cosa no necessitem tractar amb codi massiu.
• L'ampliació i prova de l'aplicació és més fàcil.

Implementació de MVC mitjançant Java

Per implementar el patró MVC a Java, hem de crear les tres classes següents.

Classe d'empleats, actuarà com a capa de modelClasse EmployeeView, actuarà com a capa de vistaClasse EmployeeContoller, actuarà com a capa de controlador

Capes d'arquitectura MVC

Capa de model

El model del patró de disseny MVC actua com a capa de dades per a l'aplicació. Representa la lògica de negoci per a l'aplicació i també l'estat de l'aplicació. L'objecte model recull i emmagatzema l'estat del model a la base de dades. Mitjançant la capa de model, s'apliquen regles a les dades que representen els conceptes d'aplicació.

Considerem el següent fragment de codi que crea un que també és el primer pas per implementar el patró MVC.

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

El codi anterior consisteix simplement en mètodes getter i setter per a la classe Employee.

Visualitza la capa

Tal com indica el nom, la vista representa la visualització de les dades rebudes del model. La capa de visualització consisteix en la sortida de l'aplicació o la interfície d'usuari. Envia les dades sol·licitades al client, que s'obtenen de la capa de model pel controlador.

Prenguem un exemple on creem una vista mitjançant 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); } } 

Capa de controlador

La capa de controlador rep les peticions dels usuaris de la capa de visualització i les processa, amb les validacions necessàries. Actua com a interfície entre Model i View. A continuació, les sol·licituds s'envien al model per al tractament de dades. Un cop processats, les dades s'envien de nou al controlador i després es mostren a la vista.

Considerem el següent fragment de codi que crea el controlador mitjançant 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()); } } 

Fitxer Java de classe principal

L'exemple següent mostra el fitxer principal per implementar l'arquitectura MVC. Aquí, estem utilitzant 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; } } 

El MVCMain class obté les dades dels empleats del mètode on hem introduït els valors. A continuació, empeny aquests valors al model. Després d'això, inicialitza la vista (EmployeeView.java). Quan s'inicialitza la vista, s'invoca el controlador (EmployeeController.java) i l'enllaça a la classe Employee i a la classe EmployeeView. Finalment, el mètode updateView() (mètode del controlador) actualitza els detalls de l'empleat que s'imprimiran a la consola.

Sortida:

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

D'aquesta manera, hem conegut l'arquitectura MVC, la importància de cada capa i la seva implementació en Java.