Wie man eine Spring MVC-Anwendung mit Maven in IntelliJ IDEA erstellt

Einführung

Dieses Tutorial führt Sie durch den Prozess der Erstellung einer Spring MVC-Anwendung mit Maven in der IntelliJ IDEA-Entwicklungsumgebung. Wir werden die wesentlichen Schritte abdecken, von der Einrichtung der Entwicklungsumgebung bis hin zur Nutzung von Docker für die Containerisierung, um Ihnen zu helfen, mit der Erstellung moderner Webanwendungen zu beginnen.

Skills Graph

Einführung in Spring MVC

Spring MVC ist ein beliebtes Web-Applikations-Framework, das Teil des Spring-Ökosystems ist. Es folgt dem Model-View-Controller (MVC)-Architekturmuster, das die Anwendungslogik in drei miteinander verbundene Komponenten aufteilt: das Modell, die Ansicht (View) und den Controller.

Was ist Spring MVC?

Spring MVC ist ein auf Java basierendes Web-Applikations-Framework, das ein umfassendes Programmier- und Konfigurationsmodell für die Entwicklung von Webanwendungen bietet. Es vereinfacht die Entwicklung von Webanwendungen, indem es die gängigen Aufgaben und Muster im Zusammenhang mit der Webentwicklung wie die Anforderungsverarbeitung, die Ansichtsrendering und die Datenbindung behandelt.

Hauptkomponenten von Spring MVC

Die Hauptkomponenten des Spring MVC-Frameworks sind:

1. Modell: Das Modell repräsentiert die Daten und die Geschäftslogik der Anwendung. Es ist für die Verwaltung der Daten und des Zustands der Anwendung verantwortlich.

2. Ansicht (View): Die Ansicht ist für das Rendern der Benutzeroberfläche der Anwendung verantwortlich. Sie ist für die Präsentation der Daten an den Benutzer und die Verarbeitung von Benutzerinteraktionen verantwortlich.

3. Controller: Der Controller ist das Bindeglied zwischen dem Modell und der Ansicht. Er empfängt Benutzeranforderungen, verarbeitet die Daten und übergibt die Daten an die Ansicht zum Rendern.

Vorteile der Verwendung von Spring MVC

Einige der wichtigsten Vorteile der Verwendung von Spring MVC sind:

1. Trennung von Zuständigkeiten: Das MVC-Muster fördert eine klare Trennung von Zuständigkeiten, wodurch der Code leichter wartbar und testbar wird.
2. Flexibilität: Spring MVC bietet eine flexible und konfigurierbare Architektur, die es Entwicklern ermöglicht, das Framework an ihre spezifischen Anforderungen anzupassen.
3. Skalierbarkeit: Spring MVC ist so konzipiert, dass es skalierbar ist, was es geeignet macht für die Entwicklung von Webanwendungen in großem Maßstab.
4. Integration mit anderen Spring-Modulen: Spring MVC integriert nahtlos mit anderen Spring-Modulen wie Spring Security, Spring Data und Spring Boot, was ein umfassendes und kohärentes Entwicklungsumfeld bietet.

Indem Sie die grundlegenden Konzepte und Komponenten von Spring MVC verstehen, sind Sie besser gerüstet, um mit diesem leistungsstarken Framework robuste und skalierbare Webanwendungen zu entwickeln.

Einrichten der Entwicklungsumgebung mit IntelliJ IDEA

Um mit der Entwicklung einer Spring MVC-Anwendung mit Maven in IntelliJ IDEA zu beginnen, müssen Sie Ihre Entwicklungsumgebung einrichten. So können Sie dies tun:

Installation des Java Development Kit (JDK)

Zunächst müssen Sie das Java Development Kit (JDK) auf Ihrem Ubuntu 22.04-System installieren. Sie können dies tun, indem Sie die folgenden Befehle in Ihrem Terminal ausführen:

sudo apt update
sudo apt install openjdk-11-jdk

Verifizieren Sie die Installation, indem Sie die Java-Version überprüfen:

java -version

Installation von IntelliJ IDEA

Als Nächstes müssen Sie IntelliJ IDEA installieren, eine beliebte integrierte Entwicklungsumgebung (Integrated Development Environment, IDE) für die Java-Entwicklung. Sie können die neueste Version von IntelliJ IDEA von der offiziellen Website herunterladen: https://www.jetbrains.com/idea/download/

Sobald der Download abgeschlossen ist, extrahieren Sie die ZIP-Datei und führen Sie den folgenden Befehl aus, um die IDE zu starten:

./idea.sh

Konfiguration des Spring MVC-Projekts

1. Öffnen Sie IntelliJ IDEA und erstellen Sie ein neues Projekt, indem Sie auf der Willkommensseite "Create New Project" auswählen.
2. Wählen Sie "Maven" als Projekttyp und klicken Sie auf "Next".
3. Geben Sie einen Projektnamen und einen Speicherort an und klicken Sie dann auf "Finish".
4. Klicken Sie in der Projektstruktur mit der rechten Maustaste auf den Ordner "src/main/java" und wählen Sie "New" > "Package". Erstellen Sie ein Paket für Ihre Anwendung, z. B. "com.labex.springmvc".
5. Klicken Sie mit der rechten Maustaste auf das Paket und wählen Sie "New" > "Java Class". Erstellen Sie eine neue Klasse für Ihren Spring MVC-Controller, z. B. "HelloController.java".

package com.labex.springmvc;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {

    @GetMapping("/")
    public String hello(Model model) {
        model.addAttribute("message", "Hello from LabEx Spring MVC!");
        return "hello";
    }
}

6. Erstellen Sie einen neuen Ordner namens "templates" im Verzeichnis "src/main/resources". Hier platzieren Sie Ihre Spring MVC-Ansichtsvorlagen.
7. Erstellen Sie im Ordner "templates" eine neue Datei namens "hello.html" und fügen Sie den folgenden Inhalt hinzu:

<!doctype html>
<html xmlns:th="http://www.thymeleaf.org">
  <head>
    <title>Hello LabEx</title>
  </head>
  <body>
    <h1 th:text="${message}"></h1>
  </body>
</html>

Nun haben Sie die grundlegende Entwicklungsumgebung für Ihre Spring MVC-Anwendung mit IntelliJ IDEA und Maven eingerichtet. Sie können mit dem nächsten Schritt fortfahren, nämlich der Entwicklung der Spring MVC-Anwendung.

Erstellen einer Spring MVC-Anwendung mit Maven

Nachdem Sie Ihre Entwicklungsumgebung eingerichtet haben, können wir nun mit der Erstellung einer Spring MVC-Anwendung mithilfe von Maven beginnen.

Konfigurieren des Maven-Projekts

1. Öffnen Sie die pom.xml-Datei in Ihrem IntelliJ IDEA-Projekt.
2. Fügen Sie die erforderlichen Abhängigkeiten für Spring MVC und Thymeleaf (dem Ansichtsvorlagen-Engine) hinzu, indem Sie den folgenden Code innerhalb des <dependencies>-Abschnitts einfügen:

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
        <version>2.7.0</version>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-thymeleaf</artifactId>
        <version>2.7.0</version>
    </dependency>
</dependencies>

3. Fügen Sie das Spring Boot Maven-Plugin dem <plugins>-Abschnitt der pom.xml-Datei hinzu:

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
            <version>2.7.0</version>
        </plugin>
    </plugins>
</build>

Implementieren des Spring MVC-Controllers

In der HelloController.java-Datei können Sie die Controller-Logik definieren, die die eingehenden Anfragen verarbeiten und die entsprechende Ansicht zurückgeben wird:

package com.labex.springmvc;

import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.GetMapping;

@Controller
public class HelloController {

    @GetMapping("/")
    public String hello(Model model) {
        model.addAttribute("message", "Hello from LabEx Spring MVC!");
        return "hello";
    }
}

Konfigurieren der Spring MVC-Anwendung

Um die Spring MVC-Anwendung zu konfigurieren, müssen Sie eine SpringMvcApplication.java-Datei im Stamm-Paket (z.B. com.labex.springmvc) mit folgendem Inhalt erstellen:

package com.labex.springmvc;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class SpringMvcApplication {
    public static void main(String[] args) {
        SpringApplication.run(SpringMvcApplication.class, args);
    }
}

Ausführen der Spring MVC-Anwendung

1. Navigieren Sie im IntelliJ IDEA-Terminal in das Verzeichnis Ihres Projekts und führen Sie den folgenden Befehl aus, um die Anwendung zu erstellen und zu starten:

mvn spring-boot:run

2. Sobald die Anwendung läuft, öffnen Sie Ihren Webbrowser und navigieren Sie zu http://localhost:0000/. Sie sollten die Nachricht "Hello from LabEx Spring MVC!" auf der Seite sehen.

Herzlichen Glückwunsch! Sie haben erfolgreich eine Spring MVC-Anwendung mit Maven in IntelliJ IDEA erstellt. Sie können nun Ihre Anwendung weiter verbessern, indem Sie weitere Funktionen hinzufügen, wie z.B. Controller, Services und Ansichten.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie Sie mit Maven in IntelliJ IDEA eine Spring MVC-Anwendung erstellen und wie Sie Docker zur Containerisierung nutzen können. Wenn Sie die beschriebenen Schritte befolgt haben, sollten Sie nun in der Lage sein, Ihre Entwicklungsumgebung einzurichten, ein Spring MVC-Projekt zu erstellen und Ihre Anwendung als Docker-Container für die Bereitstellung zu verpacken. Dieses Wissen wird Ihnen bei der weiteren Erkundung und Entwicklung von Webanwendungen mit Spring MVC und Docker von Wert sein.