Le modèle de conception MVC est un modèle d'architecture logicielle qui divise une application en trois composants principaux : le modèle, la vue et le contrôleur, ce qui facilite la gestion et la maintenance de la base de code. Il permet également la réutilisation des composants et favorise une approche plus modulaire du développement logiciel.
Sujets importants pour le modèle de conception MVC
- Qu'est-ce que le modèle de conception MVC ?
- Composants du modèle de conception MVC
- Communication entre les composants
- Exemple de modèle de conception MVC
- Avantages du modèle de conception MVC
- Inconvénients du modèle de conception MVC
Qu'est-ce que le modèle de conception MVC ?
Le Modèle Vue Contrôleur Le modèle de conception (MVC) spécifie qu'une application se compose d'un modèle de données, d'informations de présentation et d'informations de contrôle. Le modèle nécessite que chacun d'entre eux soit séparé en objets différents.
- Le modèle MVC sépare les préoccupations d’une application en trois composants distincts, chacun responsable d’un aspect spécifique des fonctionnalités de l’application.
- Cette séparation des préoccupations rend l'application plus facile à maintenir et à étendre, car les modifications apportées à un composant n'exigent pas de modifications aux autres composants.
Composants du modèle de conception MVC
1. Modèle
Le composant Modèle dans le modèle de conception MVC (Model-View-Controller) représente les données et la logique métier d'une application. Il est responsable de la gestion des données de l’application, du traitement des règles métier et de la réponse aux demandes d’informations provenant d’autres composants, tels que la Vue et le Contrôleur.
2. Voir
Affiche les données du modèle à l'utilisateur et envoie les entrées de l'utilisateur au contrôleur. Il est passif et n’interagit pas directement avec le Modèle. Au lieu de cela, il reçoit les données du modèle et envoie les entrées de l'utilisateur au contrôleur pour traitement.
3. Contrôleur
Le contrôleur agit comme intermédiaire entre le modèle et la vue. Il gère les entrées de l'utilisateur et met à jour le modèle en conséquence et met à jour la vue pour refléter les modifications apportées au modèle. Il contient la logique d'application, telle que la validation des entrées et la transformation des données.
Communication entre les composants
Ce flux de communication ci-dessous garantit que chaque composant est responsable d'un aspect spécifique de la fonctionnalité de l'application, conduisant à une architecture plus maintenable et évolutive.
- Interaction de l'utilisateur avec la vue :
- L'utilisateur interagit avec la vue, par exemple en cliquant sur un bouton ou en saisissant du texte dans un formulaire.
- La vue reçoit l'entrée de l'utilisateur :
- La vue reçoit l'entrée de l'utilisateur et la transmet au contrôleur.
- Le contrôleur traite les entrées de l'utilisateur :
- Le contrôleur reçoit l'entrée de l'utilisateur de la vue.
- Il interprète l'entrée, effectue toutes les opérations nécessaires (telles que la mise à jour du modèle) et décide comment répondre.
- Modèle de mises à jour du contrôleur :
- Le contrôleur met à jour le modèle en fonction de l'entrée de l'utilisateur ou de la logique de l'application.
- Le modèle notifie la vue des modifications :
- Si le modèle change, il en informe la vue.
- Afficher les données des demandes à partir du modèle :
- La vue demande des données au modèle pour mettre à jour son affichage.
- Vue des mises à jour du contrôleur :
- Le contrôleur met à jour la vue en fonction des modifications apportées au modèle ou en réponse aux entrées de l'utilisateur.
- Afficher l'interface utilisateur mise à jour des rendus :
- La vue restitue l'interface utilisateur mise à jour en fonction des modifications apportées par le contrôleur.
Exemple de modèle de conception MVC
Vous trouverez ci-dessous le code de l'énoncé du problème ci-dessus utilisant le modèle de conception MVC :
Décomposons le code par composant :
1. Modèle (classe d'étudiant)
Représente les données (nom de l’étudiant et numéro de matricule) et fournit des méthodes pour accéder et modifier ces données.
Java
inversion de chaîne en c
class> Student {> >private> String rollNo;> >private> String name;> >public> String getRollNo() {> >return> rollNo;> >}> >public> void> setRollNo(String rollNo) {> >this>.rollNo = rollNo;> >}> >public> String getName() {> >return> name;> >}> >public> void> setName(String name) {> >this>.name = name;> >}> }> |
>
>
2. Vue (classe StudentView)
Représente la façon dont les données (détails de l’étudiant) doivent être affichées à l’utilisateur. Contient une méthode ( printStudentDetails> ) pour imprimer le nom et le numéro de matricule de l’élève.
Java
encapsulation Java
class> StudentView {> >public> void> printStudentDetails(String studentName, String studentRollNo) {> >System.out.println(>'Student:'>);> >System.out.println(>'Name: '> + studentName);> >System.out.println(>'Roll No: '> + studentRollNo);> >}> }> |
>
>
3. Contrôleur (classe StudentController)
Agit comme intermédiaire entre le modèle et la vue. Contient des références aux objets Model et View. Fournit des méthodes pour mettre à jour le modèle (par exemple, setStudentName> , setStudentRollNo> ) et pour mettre à jour la vue ( updateView> ).
Java
est une relation
class> StudentController {> >private> Student model;> >private> StudentView view;> >public> StudentController(Student model, StudentView view) {> >this>.model = model;> >this>.view = view;> >}> >public> void> setStudentName(String name) {> >model.setName(name);> >}> >public> String getStudentName() {> >return> model.getName();> >}> >public> void> setStudentRollNo(String rollNo) {> >model.setRollNo(rollNo);> >}> >public> String getStudentRollNo() {> >return> model.getRollNo();> >}> >public> void> updateView() {> >view.printStudentDetails(model.getName(), model.getRollNo());> >}> }> |
>
>
Code complet pour l'exemple ci-dessus
Vous trouverez ci-dessous le code complet de l'exemple ci-dessus :
Java
class> Student {> >private> String rollNo;> >private> String name;> >public> String getRollNo() {> >return> rollNo;> >}> >public> void> setRollNo(String rollNo) {> >this>.rollNo = rollNo;> >}> >public> String getName() {> >return> name;> >}> >public> void> setName(String name) {> >this>.name = name;> >}> }> class> StudentView {> >public> void> printStudentDetails(String studentName, String studentRollNo) {> >System.out.println(>'Student:'>);> >System.out.println(>'Name: '> + studentName);> >System.out.println(>'Roll No: '> + studentRollNo);> >}> }> class> StudentController {> >private> Student model;> >private> StudentView view;> >public> StudentController(Student model, StudentView view) {> >this>.model = model;> >this>.view = view;> >}> >public> void> setStudentName(String name) {> >model.setName(name);> >}> >public> String getStudentName() {> >return> model.getName();> >}> >public> void> setStudentRollNo(String rollNo) {> >model.setRollNo(rollNo);> >}> >public> String getStudentRollNo() {> >return> model.getRollNo();> >}> >public> void> updateView() {> >view.printStudentDetails(model.getName(), model.getRollNo());> >}> }> public> class> MVCPattern {> >public> static> void> main(String[] args) {> >Student model = retriveStudentFromDatabase();> >StudentView view =>new> StudentView();> >StudentController controller =>new> StudentController(model, view);> >controller.updateView();> >controller.setStudentName(>'Vikram Sharma'>);> >controller.updateView();> >}> >private> static> Student retriveStudentFromDatabase() {> >Student student =>new> Student();> >student.setName(>'Lokesh Sharma'>);> >student.setRollNo(>'15UCS157'>);> >return> student;> >}> }> |
>
>
Sortir
code de nombre aléatoire c
Student:> Name: Lokesh Sharma> Roll No: 15UCS157> Student:> Name: Vikram Sharma> Roll No: 15UCS157> |
>
>
Avantages du modèle de conception MVC
- Séparation des préoccupations: MVC sépare les différents aspects d'une application (données, interface utilisateur et logique), ce qui rend le code plus facile à comprendre, à maintenir et à modifier.
- Modularité : Chaque composant (Modèle, Vue, Contrôleur) peut être développé et testé séparément, favorisant la réutilisabilité et l'évolutivité du code.
- La flexibilité: Puisque les composants sont indépendants, les modifications apportées à un composant n’affectent pas les autres, ce qui permet des mises à jour et des modifications plus faciles.
- Développement parallèle : Plusieurs développeurs peuvent travailler simultanément sur différents composants, accélérant ainsi le processus de développement.
- Réutilisabilité du code : Les composants peuvent être réutilisés dans d’autres parties de l’application ou dans différents projets, réduisant ainsi le temps et les efforts de développement.
Inconvénients du modèle de conception MVC
- Complexité: La mise en œuvre du modèle MVC peut ajouter de la complexité au code, en particulier pour les applications plus simples, entraînant une surcharge de développement.
- Courbe d'apprentissage: Les développeurs doivent comprendre le concept de MVC et savoir comment le mettre en œuvre efficacement, ce qui peut nécessiter du temps et des ressources supplémentaires.
- Aérien: La communication entre les composants (Modèle, Vue, Contrôleur) peut entraîner une surcharge, affectant les performances de l'application, en particulier dans les environnements aux ressources limitées.
- Potentiel de sur-ingénierie : Dans certains cas, les développeurs peuvent sur-concevoir l'application en ajoutant des abstractions et des couches inutiles, ce qui conduit à un code volumineux et difficile à maintenir.
- Augmentation du nombre de fichiers : MVC peut générer un plus grand nombre de fichiers et de classes par rapport aux architectures plus simples, ce qui peut rendre la structure du projet plus complexe et plus difficile à naviguer.