Un esempio MVC con servlet e JSP

1. Panoramica

In questo rapido articolo, creeremo una piccola applicazione Web che implementa il modello di progettazione Model View Controller (MVC), utilizzando Servlet e JSP di base.

Esploreremo un po 'come funziona MVC e le sue caratteristiche chiave prima di passare all'implementazione.

2. Introduzione a MVC

Model-View-Controller (MVC) è un modello utilizzato nell'ingegneria del software per separare la logica dell'applicazione dall'interfaccia utente. Come suggerisce il nome, il pattern MVC ha tre livelli.

Il Modello definisce il livello aziendale dell'applicazione, il Controller gestisce il flusso dell'applicazione e la Vista definisce il livello di presentazione dell'applicazione.

Sebbene il pattern MVC non sia specifico per le applicazioni Web, si adatta molto bene a questo tipo di applicazioni. In un contesto Java, il Modello è costituito da semplici classi Java, il Controller è costituito da servlet e la Vista è costituita da pagine JSP.

Ecco alcune caratteristiche chiave del pattern:

  • Separa il livello di presentazione dal livello aziendale
  • Il Titolare esegue l'azione di invocare il Modello e di inviare i dati a View
  • Il Modello non è nemmeno a conoscenza di essere utilizzato da qualche applicazione web o da un'applicazione desktop

Diamo un'occhiata a ogni strato.

2.1. Il livello del modello

Questo è il livello dati che contiene la logica di business del sistema e rappresenta anche lo stato dell'applicazione.

È indipendente dal livello di presentazione, il controller recupera i dati dal livello del modello e li invia al livello di visualizzazione.

2.2. Il livello del controller

Il livello del controller funge da interfaccia tra View e Model. Riceve le richieste dal livello di visualizzazione e le elabora, comprese le convalide necessarie.

Le richieste vengono ulteriormente inviate al livello Modello per l'elaborazione dei dati e, una volta elaborate, i dati vengono rinviati al Controller e quindi visualizzati nella Vista.

2.3. Il livello di visualizzazione

Questo livello rappresenta l'output dell'applicazione, solitamente una forma di interfaccia utente. Il livello di presentazione viene utilizzato per visualizzare i dati del Modello recuperati dal Controller.

3. MVC con servlet e JSP

Per implementare un'applicazione Web basata sul modello di progettazione MVC, creeremo le classi Student e StudentService , che fungeranno da livello del modello.

La classe S tudentServlet fungerà da controller e per il livello di presentazione creeremo la pagina student-record.jsp .

Ora, scriviamo questi livelli uno per uno e iniziamo con la classe Student :

public class Student { private int id; private String firstName; private String lastName; // constructors, getters and setters goes here } 

Scriviamo ora il nostro StudentService che elaborerà la nostra logica di business:

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

Ora creiamo la nostra classe Controller StudentServlet :

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

Questo servlet è il controller della nostra applicazione web.

Innanzitutto, legge un ID parametro dalla richiesta. Se l' ID viene inviato, un oggetto Student viene recuperato dal livello aziendale.

Una volta recuperati i dati necessari dal modello, inserisce questi dati nella richiesta utilizzando il metodo setAttribute () .

Infine, il controller inoltra gli oggetti richiesta e risposta a un JSP, la visualizzazione dell'applicazione.

Quindi, scriviamo il nostro livello di presentazione student-record.jsp :

  Student Record ID: First Name: Last Name: 

E, naturalmente, il JSP è la vista dell'applicazione; riceve tutte le informazioni di cui ha bisogno dal Controller, non ha bisogno di interagire direttamente con il livello aziendale.

4. Conclusione

In questo tutorial, abbiamo imparato a conoscere l'architettura MVC, ovvero Model View Controller, e ci siamo concentrati su come implementare un semplice esempio.

Come al solito, il codice presentato qui può essere trovato su GitHub.