Teil 8. Schreiben wir eine kleine Anwendung mit Spring Boot

Dieses Material ist der abschließende Teil der Reihe „Einführung in die Unternehmensentwicklung“. Vorherige Artikel:

• zum Thema Networking
• über Softwarearchitektur
• über HTTP/HTTPS
• über die Grundlagen von Maven
• über Servlets (Schreiben einer einfachen Webanwendung)
• über Servlet-Container
• über die Grundlagen von MVC

Schauen wir uns die einfachste Implementierung von MVC am Beispiel von Spring MVC an. Dazu schreiben wir eine kleine Hello World-Anwendung mit Spring Boot. Ich gebe dir eine Schritt-für-Schritt-Anleitung, damit du alles selbst wiederholen kannst. Zuerst schreiben wir eine kleine Bewerbung und analysieren diese dann.

Schritt 1. Erstellen einer Spring Boot-Anwendung in IntelliJ IDEA.

Verwenden Sie Datei -> Neu -> Projekt…, um ein neues Projekt zu erstellen. Wählen Sie im sich öffnenden Fenster im Menü auf der linken Seite „Spring Initializr“ und dann das Projekt-SDK aus. Behalten Sie die Standardeinstellung für die Option Initializr Service URL bei. Klicken Sie auf die Schaltfläche „Weiter“. Im nächsten Fenster müssen wir die Projekteinstellungen auswählen. Wir werden ein Maven-Projekt haben. Wählen Sie als Typ Maven-Projekt aus. Füllen Sie die Felder „Gruppe“ und „Artefakt“ aus. Klicken Sie auf „Weiter“. Im nächsten Fenster müssen wir die Spring Framework-Komponenten auswählen, die wir verwenden möchten. Zwei reichen uns:

• Spring Web ist eine Komponente, mit der wir Webanwendungen erstellen können. Diese Komponente enthält Spring MVC.
• Thymeleaf ist unsere Template-Engine. Damit können wir Daten von Java an HTML-Seiten senden

Wählen Sie im nächsten Fenster den Namen und den Speicherort des Projekts im Dateisystem aus: Klicken Sie auf die Schaltfläche „Fertig stellen“. Das Projekt wird erstellt. Am Ende erhalten wir die folgende Projektstruktur: Hier interessieren uns 2 Dateien: pom.xml (Bereitstellungsdeskriptor). Mit diesem Ding können Sie schnell und einfach Bibliotheken aus verschiedenen Frameworks in unser Projekt importieren. Hier konfigurieren wir auch, wie unsere Anwendung erstellt wird. Unsere Anwendung wird mit Maven erstellt und pom.xml ist die Konfigurationsdatei für dieses Build-System. Die Java-Klasse ist MvcDemoApplication. Dies ist die Hauptklasse unserer Anwendung. Wir werden daraus unser Spring Boot-Projekt starten. Führen Sie zunächst einfach die Hauptmethode dieser Klasse aus. Hier ist der Code für diese Klasse sowie die Datei pom.xml: MvcDemoApplication:

@SpringBootApplication
public class MvcDemoApplication {

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

}

pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.codegym/groupId>
    <artifactId>mvc_demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>mvc_demo</name>
    <description>Spring MVC Demo</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

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

</project>

Schritt 2. Erstellen einer Webseite

Unsere Anwendung wird äußerst einfach sein. Wir werden eine Hauptseite (index.html) haben, die einen Link zur Willkommensseite (greeting.html) enthält. Auf der Begrüßungsseite zeigen wir eine Begrüßung an. Wir verwenden URL-Parameter, um den Namen, der in der Begrüßung verwendet werden soll, an die Seite Greeting.html zu übergeben. Lassen Sie uns die Hauptseite unserer Anwendung erstellen – index.html:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Main page</title>
</head>
<body>
    <p>Get your greeting <a href="/greeting">here</a></p>
</body>
</html>

Jetzt erstellen wir die Seite Greeting.html:

<!DOCTYPE HTML>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Getting Started: Serving Web Content</title>
    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
</head>
<body>
    <p th:text="'Hello, ' + ${name} + '!'" />
</body>
</html>

Unsere Seite hat ein <p th:text="'Hello, ' + ${name} + '!'" />Tag, was für HTML nicht normal ist. Das thAttribut des pTags ist ein Mechanismus, der von der Thymeleaf-Vorlagen-Engine verwendet wird. Der pWert des Tags ist „Hallo“ + der Wert der nameVariablen, die wir im Java-Code festlegen.

Schritt 3. Erstellen eines Controllers

Innerhalb des mvc_demo-Pakets erstellen wir ein Controller-Paket, in dem wir unseren Controller HelloWorldController erstellen:

@Controller
public class HelloWorldController {

   @RequestMapping(value = "/greeting")
   public String helloWorldController(@RequestParam(name = "name", required = false, defaultValue = "World") String name, Model model) {
       model.addAttribute("name", name);
       return "greeting";
   }

}

Einerseits gibt es sehr wenig Code, andererseits ist aber auch viel los. Beginnen wir mit unserer Analyse. Die Annotation @Controller gibt an, dass es sich bei dieser Klasse um einen Controller handelt. Im Frühjahr verarbeiten Controller HTTP-Anfragen, die an bestimmte URLs gerichtet sind. Unsere Klasse verfügt über eine helloWorldController-Methode, die mit der Annotation @RequestMapping(value = "/greeting") gekennzeichnet ist. Diese Anmerkung gibt an, dass diese Methode HTTP-GET-Anfragen verarbeitet, die an die URL /greeting gerichtet sind. Mit anderen Worten: Diese Methode wird aufgerufen, wenn jemand zu /greeting navigiert. Diese Methode gibt einen String zurück. Laut Spring MVC sollte die Controller-Methode den Namen der Ansicht zurückgeben. Als nächstes sucht Spring nach einer HTML-Datei mit demselben Namen, die es als Antwort auf die HTTP-Anfrage zurückgibt. Wie du sehen kannst, Unsere Methode benötigt 2 Argumente. Werfen wir einen Blick darauf: Parameter 1: @RequestParam(name = „name“, erforderlich = false, defaultValue = „World“) String-Name. Die Annotation @RequestParam gibt an, dass der String-Namensparameter ein URL-Parameter ist. Wenn die Anmerkung darauf hinweist, dass dieser URL-Parameter optional ist (erforderlich = falsch), ist der Wert des String-Namensparameters „World“, wenn er nicht vorhanden ist (defaultValue = „World“). Wenn es vorhanden ist, lautet der URL-Parameter „name“ (name = „name“). Es kann sein, dass Sie hier vieles nicht verstehen. Lassen Sie uns einige Beispiele nennen. Die folgende Tabelle zeigt den Wert des String-Namensparameters mit verschiedenen Optionen für den Zugriff auf /greeting (mit und ohne URL-Parameter). Parameter 2: Der zweite Parameter ist ein Modellmodell. Dieser Parameter ist ein Modell. Dieses Modell besteht aus verschiedenen internen Attributen. Jedes Attribut hat einen Namen und einen Wert. So etwas wie Schlüssel-Wert-Paare. Mit diesem Parameter können wir Daten aus Java-Code an HTML-Seiten senden. Oder senden Sie mithilfe der MVC-Terminologie Daten vom Modell an die Ansicht. Es bleibt nur noch die letzte Zeile zu untersuchen. Auf diese Weise senden wir Daten von Java an HTML oder vom Modell an die Ansicht. Die Methode enthält die folgende Zeile: model.addAttribute("name", name); Hier erstellen wir ein neues Attribut namens name und weisen ihm den Wert des name-Parameters zu. Denken Sie daran, dass wir kürzlich darüber gesprochen haben <p th:text = "'Hello,' + ${name} + '!'" /> , dass der Wert des p-Tags „Hallo“ + der Wert der Namensvariablen ist, die wir im Java-Code festlegen werden. Diesen Wert stellen wir über die Linie ein model.addAttribute("name", name);

Schritt 5. Ausführen

Um zu beginnen, müssen wir die Hauptmethode der MvcDemoApplication-Klasse ausführen: In den Protokollen sehen wir, dass unsere Webanwendung auf Port 8080 gestartet wurde: Und das bedeutet, dass wir in einem Browser auf die Seite unter http:// gehen können. localhost:8080 : Hier haben wir die Seite index.html. Folgen wir dem Link zur Begrüßungsseite: Unser Controller wurde in diesem Übergang aufgerufen. Wir haben keine Parameter über die URL übergeben. Dadurch nimmt das Namensattribut den in der Annotation angegebenen Standardwert („Welt“) an. Versuchen wir, Parameter über die URL zu übergeben: Alles funktioniert wie vorgesehen. Versuchen Sie nun, den Pfad der Namensvariablen zu verfolgen:

1. Der Benutzer hat „name=Amigo“ in der URL übergeben ->
2. Der Controller verarbeitete unsere Aktion, empfing die Namensvariable und setzte ein Modellattribut namens Name gleich dem empfangenen Wert ->
3. Diese Daten wurden vom Modell angezeigt, landeten auf der Seite „gruss.html“ und wurden dem Benutzer angezeigt

Das war es fürs Erste!