Un exemple MVC avec des servlets et des JSP

Un exemple MVC avec Servlets et JSP

1. Vue d'ensemble

Dans cet article rapide, nous allons créer une petite application Web qui implémente le modèle de conception Model View Controller (MVC), à l'aide de servlets et de JSP de base.

Nous allons explorer un peu le fonctionnement de MVC et ses principales fonctionnalités avant de passer à la mise en œuvre.

2. Introduction à MVC

MVC (Model-View-Controller) est un modèle utilisé en génie logiciel pour séparer la logique d'application de l'interface utilisateur. Comme son nom l'indique, le modèle MVC comporte trois couches.

Le modèle définit la couche métier de l'application, le contrôleur gère le flux de l'application et la vue définit la couche de présentation de l'application.

Bien que le modèle MVC ne soit pas spécifique aux applications Web, il s'intègre très bien dans ce type d'applications. Dans un contexte Java, le modèle consiste en de simples classes Java, le contrôleur en servlets et la vue en pages JSP.

Voici quelques caractéristiques clés du modèle:

Il sépare la couche de présentation de la couche de gestion
Le contrôleur appelle le modèle et envoie les données à View.
Le modèle n'est même pas conscient qu'il est utilisé par une application Web ou une application de bureau

Jetons un coup d'œil à chaque calque.

2.1. Le calque modèle

C'est la couche de données qui contient la logique applicative du système et représente également l'état de l'application.

Indépendamment de la couche de présentation, le contrôleur extrait les données de la couche Modèle et les envoie à la couche Vue.

2.2. La couche contrôleur

La couche contrôleur agit comme une interface entre View et Model. Il reçoit les demandes de la couche de vue et les traite, y compris les validations nécessaires.

Les demandes sont ensuite envoyées à la couche Modèle pour le traitement des données. Une fois traitées, les données sont renvoyées au contrôleur puis affichées dans la vue.

2.3. Le calque de vue

Cette couche représente la sortie de l'application, généralement une forme d'interface utilisateur. La couche de présentation est utilisée pour afficher les données de modèle extraites par le contrôleur.

3. MVC avec servlets et JSP

Pour implémenter une application Web basée sur le modèle de conception MVC, nous allons créer les classesStudent etStudentService - qui agiront comme notre couche de modèle.

La classe StudentServlet agira en tant que contrôleur, et pour la couche de présentation, nous allons créer la page destudent-record.jsp.

Maintenant, écrivons ces calques un par un et commençons par la classeStudent:

public class Student {
    private int id;
    private String firstName;
    private String lastName;

    // constructors, getters and setters goes here
}

Écrivons maintenant nosStudentService qui traiteront notre logique métier:

public class StudentService {

    public Optional getStudent(int id) {
        switch (id) {
            case 1:
                return Optional.of(new Student(1, "John", "Doe"));
            case 2:
                return Optional.of(new Student(2, "Jane", "Goodall"));
            case 3:
                return Optional.of(new Student(3, "Max", "Born"));
            default:
                return Optional.empty();
        }
    }
}

Créons maintenant notre classe ControllerStudentServlet:

@WebServlet(
  name = "StudentServlet",
  urlPatterns = "/student-record")
public class StudentServlet extends HttpServlet {

    private StudentService studentService = new StudentService();

    private void processRequest(
      HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

        String studentID = request.getParameter("id");
        if (studentID != null) {
            int id = Integer.parseInt(studentID);
            studentService.getStudent(id)
              .ifPresent(s -> request.setAttribute("studentRecord", s));
        }

        RequestDispatcher dispatcher = request.getRequestDispatcher(
          "/WEB-INF/jsp/student-record.jsp");
        dispatcher.forward(request, response);
    }

    @Override
    protected void doGet(
      HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

        processRequest(request, response);
    }

    @Override
    protected void doPost(
      HttpServletRequest request, HttpServletResponse response)
      throws ServletException, IOException {

        processRequest(request, response);
    }
}

Ce servlet est le contrôleur de notre application Web.

Tout d'abord, il lit un paramètreid de la requête. Si leid est soumis, un objetStudent est extrait de la couche de gestion.

Une fois qu'il a récupéré les données nécessaires du modèle, il place ces données dans la requête à l'aide de la méthodesetAttribute().

Enfin, le Controllerforwards les objets de requête et de réponse à une JSP, la vue de l'application.

Ensuite, écrivons notre couche de présentationstudent-record.jsp:


    
        Student Record
    
    
    <%
        if (request.getAttribute("studentRecord") != null) {
            Student student = (Student) request.getAttribute("studentRecord");
    %>

    Student Record
    ID: <%= student.getId()%>
    First Name: <%= student.getFirstName()%>
    Last Name: <%= student.getLastName()%>

    <%
        } else {
    %>

    No student record found.

    <% } %>

Et, bien sûr, le JSP est la vue de l'application; il reçoit toutes les informations dont il a besoin du contrôleur, il n’a pas besoin d’interagir directement avec la couche de gestion.

4. Conclusion

Dans ce didacticiel, nous avons découvert le MVC, c'est-à-dire L'architecture du contrôleur de vue de modèle et nous nous sommes concentrés sur la mise en œuvre d'un exemple simple.

Comme d'habitude, le code présenté ici peut être trouvéover on GitHub.

TOC