Ein MVC-Beispiel mit Servlets und JSP

1. Überblick

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 Ebenen.

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 wichtige Merkmale des Musters:

Es trennt die Präsentationsschicht von der Geschäftsschicht
Der Controller ruft das Modell auf und sendet Daten an View
Dem Modell ist nicht einmal bewusst, dass es von einer Webanwendung oder einer Desktopanwendung verwendet wird

Schauen wir uns jede Ebene 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-Ebene fungiert als Schnittstelle zwischen Ansicht und Modell. Es empfängt Anforderungen von der View-Ebene 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 in der Ansicht angezeigt.

2.3. Die Ansichtsebene

Diese Ebene stellt die Ausgabe der Anwendung dar, normalerweise eine Art Benutzeroberfläche. Die Präsentationsebene 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 KlassenStudent undStudentService, die als Modellebene fungieren.

Die Klasse von StudentServletfungiert als Controller. Für die Präsentationsebene erstellen wir die Seite vonstudent-record.jsp.

Schreiben wir nun diese Ebenen einzeln und beginnen mit der KlasseStudent:

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

    // constructors, getters and setters goes here
}

Schreiben wir nun unsereStudentService, die unsere Geschäftslogik verarbeiten:

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-KlasseStudentServlet:

@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 einen Parameterid aus der Anforderung. Wennid gesendet wird, wird einStudent-Objekt aus der Geschäftsschicht abgerufen.

Sobald die erforderlichen Daten aus dem Modell abgerufen wurden, werden diese Daten mit der MethodesetAttribute()in die Anforderung eingefügt.

Schließlich stellt der Controllerforwardsdie Anforderungs- und Antwortobjekte an eine JSP, die Ansicht der Anwendung.

Als nächstes schreiben wir unsere Präsentationsebenestudent-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.

    <% } %>

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

4. Fazit

In diesem Tutorial haben wir etwas über die MVC gelernt, d. H. Model View Controller-Architektur, und wir haben uns auf die Implementierung eines einfachen Beispiels konzentriert.

Der hier dargestellte Code befindet sich wie üblich inover on GitHub.

TOC

Ein MVC-Beispiel mit Servlets und JSP