Ein MVC-Beispiel mit Servlets und JSP

1. Übersicht

In diesem kurzen Artikel erstellen wir eine kleine Webanwendung, die das MVC-Entwurfsmuster (Model View Controller) unter Verwendung grundlegender Servlets und JSPs implementiert.

Wir werden uns ein wenig mit der Funktionsweise von MVC und seinen Hauptfunktionen befassen, bevor wir mit der Implementierung fortfahren.

2. Einführung in MVC

Model-View-Controller (MVC) ist ein Muster, das in der Softwareentwicklung verwendet wird, um die Anwendungslogik von der Benutzeroberfläche zu trennen. Wie der Name schon sagt, besteht das MVC-Muster aus drei Schichten.

Das Modell definiert die Geschäftsschicht der Anwendung, der Controller verwaltet den Ablauf der Anwendung und die Ansicht definiert die Präsentationsschicht der Anwendung.

Obwohl das MVC-Muster nicht spezifisch für Webanwendungen ist, passt es sehr gut in diese Art von Anwendungen. In einem Java-Kontext besteht das Modell aus einfachen Java-Klassen, der Controller aus Servlets und die Ansicht aus JSP-Seiten.

Hier sind einige Hauptmerkmale des Musters:

  • Es trennt die Präsentationsschicht von der Geschäftsschicht
  • Der Controller führt die Aktion aus, das Modell aufzurufen und Daten an View zu senden
  • Dem Modell ist nicht einmal bekannt, dass es von einer Webanwendung oder einer Desktopanwendung verwendet wird

Schauen wir uns jede Schicht an.

2.1. Die Modellebene

Dies ist die Datenschicht, die die Geschäftslogik des Systems enthält und auch den Status der Anwendung darstellt.

Es ist unabhängig von der Präsentationsebene. Der Controller ruft die Daten aus der Modellebene ab und sendet sie an die Ansichtsebene.

2.2. Die Controller-Schicht

Die Controller-Schicht fungiert als Schnittstelle zwischen Ansicht und Modell. Es empfängt Anforderungen von der Ansichtsebene und verarbeitet sie einschließlich der erforderlichen Überprüfungen.

Die Anforderungen werden zur Datenverarbeitung weiter an die Modellebene gesendet. Sobald sie verarbeitet sind, werden die Daten an den Controller zurückgesendet und dann in der Ansicht angezeigt.

2.3. Die Ansichtsebene

Diese Ebene stellt die Ausgabe der Anwendung dar, normalerweise eine Form der Benutzeroberfläche. Die Präsentationsschicht wird verwendet, um die vom Controller abgerufenen Modelldaten anzuzeigen.

3. MVC mit Servlets und JSP

Um eine Webanwendung basierend auf dem MVC-Entwurfsmuster zu implementieren, erstellen wir die Klassen Student und StudentService , die als Modellebene fungieren.

Die S tudentServlet- Klasse fungiert als Controller, und für die Präsentationsebene erstellen wir die Seite student-record.jsp .

Schreiben wir nun diese Ebenen einzeln und beginnen mit der Schülerklasse :

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

Schreiben wir jetzt unseren StudentService, der unsere Geschäftslogik verarbeitet:

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

Erstellen wir nun unsere Controller-Klasse 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); } }

Dieses Servlet ist der Controller unserer Webanwendung.

Zunächst liest es eine Parameter- ID aus der Anforderung. Wenn die ID übermittelt wird, wird ein Student- Objekt aus der Business-Schicht abgerufen.

Sobald die erforderlichen Daten aus dem Modell abgerufen wurden, werden diese Daten mithilfe der setAttribute () -Methode in die Anforderung eingefügt .

Schließlich leitet der Controller die Anforderungs- und Antwortobjekte an eine JSP weiter, die Ansicht der Anwendung.

Als nächstes schreiben wir unsere Präsentationsschicht student-record.jsp :

  Student Record ID: First Name: Last Name: 

Und natürlich ist die JSP die Ansicht der Anwendung; Es erhält alle benötigten Informationen vom Controller und muss nicht direkt mit der Business-Schicht interagieren.

4. Fazit

In diesem Tutorial haben wir uns mit der MVC, dh der Model View Controller-Architektur, vertraut gemacht und uns darauf konzentriert, wie ein einfaches Beispiel implementiert wird.

Der hier vorgestellte Code ist wie gewohnt auf GitHub zu finden.