Le Model-View-Controller (MVC) est un design pattern dans le domaine du développement web. C'est une façon d'organiser notre code. Il précise qu'un programme ou une application doit être constitué d'un modèle de données, d'informations de présentation et d'informations de contrôle. Le modèle MVC nécessite que tous ces composants soient séparés en tant qu'objets différents.

Dans cette section, nous discuterons de l'architecture MVC en Java, ainsi que de ses avantages et inconvénients et des exemples pour comprendre l'implémentation de MVC en Java.

Qu’est-ce que l’architecture MVC en Java ?

Les conceptions de modèles basées sur l'architecture MVC suivent le modèle de conception MVC. La logique de l'application est séparée de l'interface utilisateur lors de la conception du logiciel à l'aide de conceptions de modèles.

L'architecture de modèle MVC se compose de trois couches :

convertir un entier en chaîne

Modèle:Il représente la couche métier de l’application. Il s'agit d'un objet destiné à transporter les données qui peut également contenir la logique permettant de mettre à jour le contrôleur si les données sont modifiées.Voir:Il représente la couche de présentation de l'application. Il est utilisé pour visualiser les données contenues dans le modèle.Manette:Cela fonctionne à la fois sur le modèle et sur la vue. Il est utilisé pour gérer le flux d'application, c'est-à-dire le flux de données dans l'objet modèle et pour mettre à jour la vue chaque fois que les données sont modifiées.

En programmation Java, le modèle contient le simple Cours Java , la Vue utilisée pour afficher les données et le Contrôleur contient les servlets . En raison de cette séparation, les demandes des utilisateurs sont traitées comme suit :

1. Un client (navigateur) envoie une requête au contrôleur côté serveur, pour une page.
2. Le contrôleur appelle ensuite le modèle. Il rassemble les données demandées.
3. Ensuite, le contrôleur transfère les données récupérées vers la couche de visualisation.
4. Maintenant, le résultat est renvoyé au navigateur (client) par la vue.

Avantages de l'architecture MVC

Les avantages de l'architecture MVC sont les suivants :

strep c

• MVC présente la caractéristique d'évolutivité qui, à son tour, contribue à la croissance des applications.
• Les composants sont faciles à entretenir car il y a moins de dépendance.
• Un modèle peut être réutilisé par plusieurs vues, ce qui permet de réutiliser le code.
• Les développeurs peuvent travailler simultanément avec les trois couches (Modèle, Vue et Contrôleur).
• En utilisant MVC, l'application devient plus compréhensible.
• En utilisant MVC, chaque couche est gérée séparément, nous n'avons donc pas besoin de gérer un code volumineux.
• L'extension et le test de l'application sont plus faciles.

Implémentation de MVC en utilisant Java

Pour implémenter le modèle MVC en Java, nous devons créer les trois classes suivantes.

Catégorie d'employés, fera office de calque modèleClasse EmployeeView, agira comme un calque de vueClasse EmployeeController, agira comme une couche de contrôleur

Couches d'architecture MVC

Couche de modèle

Le modèle dans le modèle de conception MVC agit comme une couche de données pour l'application. Il représente la logique métier de l'application ainsi que l'état de l'application. L'objet modèle récupère et stocke l'état du modèle dans la base de données. À l'aide de la couche modèle, des règles sont appliquées aux données qui représentent les concepts d'application.

Considérons l'extrait de code suivant qui crée un qui est également la première étape pour implémenter le modèle MVC.

Employé.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; } } 

Le code ci-dessus se compose simplement de méthodes getter et setter pour la classe Employee.

Afficher le calque

Comme son nom l'indique, la vue représente la visualisation des données reçues du modèle. La couche d'affichage se compose de la sortie de l'application ou de l'interface utilisateur. Il envoie les données demandées au client, qui sont récupérées de la couche modèle par le contrôleur.

Prenons un exemple où nous créons une vue à l'aide de la classe EmployeeView.

EmployeeView.java

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

Couche de contrôleur

La couche contrôleur récupère les demandes des utilisateurs de la couche vue et les traite, avec les validations nécessaires. Il agit comme une interface entre le modèle et la vue. Les requêtes sont ensuite envoyées au modèle pour le traitement des données. Une fois traitées, les données sont renvoyées au contrôleur puis affichées sur la vue.

Considérons l'extrait de code suivant qui crée le contrôleur à l'aide de la classe EmployeeController.

neige contre glace

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

Fichier Java de classe principale

L'exemple suivant affiche le fichier principal pour implémenter l'architecture MVC. Ici, nous utilisons 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; } } 

Le MVCMain class récupère les données des employés à partir de la méthode dans laquelle nous avons entré les valeurs. Ensuite, il pousse ces valeurs dans le modèle. Après cela, il initialise la vue (EmployeeView.java). Lorsque la vue est initialisée, le contrôleur (EmployeeController.java) est invoqué et le lie à la classe Employee et à la classe EmployeeView. Enfin, la méthode updateView() (méthode du contrôleur) met à jour les détails de l'employé à imprimer sur la console.

Sortir:

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

De cette manière, nous avons découvert l'architecture MVC, l'importance de chaque couche et son implémentation en Java.