Teil 8. Eine kleine Anwendung in Spring-Boot schreiben

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

• über das Netzwerk ;
• über Softwarearchitektur ;
• über HTTP/HTTPS-Protokolle ;
• über Maven-Grundlagen ;
• über Servlets (wir schreiben eine einfache Webanwendung) ;
• über Servlet-Container .
• über MVC-Grundlagen .

Schauen wir uns das einfachste Beispiel einer MVC-Implementierung am Beispiel von Spring-MVC an. Schreiben wir dazu eine kleine Hello World-Anwendung in Spring-Boot. Damit du alles selbst wiederholen kannst, gebe ich dir eine Schritt-für-Schritt-Anleitung. Zuerst schreiben wir eine kleine Bewerbung und analysieren diese dann.

Schritt 1: Erstellen Sie eine Spring-Boot-Anwendung in IntelliJ IDEA

Erstellen Sie mit Datei -> Neu -> Projekt... ein neues Projekt. Wählen Sie im sich öffnenden Fenster im Menü auf der linken Seite „Spring Initializr“ und „Project SDK“ aus und belassen Sie die Option „Initializr-Dienst-URL“ als Standard. Klicken Sie auf die Schaltfläche Weiter. Im nächsten Fenster müssen wir Projektparameter auswählen. Wir werden ein Maven-Projekt haben. Wählen Sie „Typ – Maven-Projekt“, geben Sie „Gruppe“ und „Artefakt“ ein und klicken Sie auf „Weiter“. Im nächsten Fenster müssen wir die Spring Framework-Komponenten auswählen, die wir verwenden möchten. Wir brauchen nur zwei:

• Spring Web ist eine Komponente, die es uns ermöglicht, Webanwendungen zu erstellen. Diese Komponente enthält Spring MVC.
• Thymeleaf – Die sogenannte Template-Engine. Eine Sache, die es uns ermöglicht, Daten von Java auf HTML-Seiten zu übertragen

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 wurde erstellt. Wir haben folgende Projektstruktur: Hier interessieren uns 2 Dateien: pom.xml – Deployment Descriptor. Eine Sache, mit der Sie schnell und einfach Bibliotheken aus verschiedenen Frameworks in unser Projekt importieren können, sowie eine Sache, mit der wir die Assembly unserer Anwendung konfigurieren. Unsere Anwendung wird mit Maven erstellt. pom.xml ist die Konfigurationsdatei dieses Build-Systems. Java-Klasse – MvcDemoApplication. Dies ist die Hauptklasse unserer Anwendung, von der aus wir unser Spring-Boot-Projekt starten werden. Führen Sie zunächst einfach die Hauptmethode in 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.javarush</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. Webseiten erstellen

Unsere Anwendung wird äußerst einfach sein. Wir werden eine Hauptseite haben – index.html, in der sich ein Link zur Willkommensseite befindet – Greeting.html. Auf der Begrüßungsseite zeigen wir die Begrüßung an. Lassen Sie uns die Möglichkeit implementieren, über URL-Parameter einen Begrüßungsnamen an die Seite Greeting.html zu senden. 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>

Hier können Sie auf einer atypischen HTML-Seite ein Tag sehen: Das Tag- <p th:text="'Hello, ' + ${name} + '!'" /> Attribut ist ein Tool der Thymeleaf-Template-Engine. Dadurch wird der Wert des Tags der Text „Hallo“ + der Wert der Variablen sein , die wir aus dem Java-Code festlegen. thppname

Schritt 3: Erstellen Sie einen Controller

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 der Analyse. Die Annotation @Controller gibt an, dass es sich bei dieser Klasse um einen Controller handelt. Controller in Spring verarbeiten HTTP-Anfragen an bestimmte Adressen. Unsere Klasse verfügt über eine helloWorldController-Methode, die mit der Annotation @RequestMapping(value = "/greeting") gekennzeichnet ist. Diese Anmerkung sagt uns, dass diese Methode HTTP-GET-Anfragen an die /greeting-Adresse verarbeitet. Mit anderen Worten: Diese Methode funktioniert, wenn jemand zu /greeting geht. Diese Methode gibt String zurück. Laut Spring-MVC muss die Controller-Methode den Namen der Ansicht zurückgeben. Als nächstes sucht Spring nach einer HTML-Datei mit demselben Namen, die als Antwort auf die HTTP-Anfrage zurückgegeben wird. Wie Sie sehen, gibt unsere Methode den Namen der zuvor erstellten Webseite zurück – Begrüßung. Unsere Methode benötigt 2 Argumente. Schauen wir sie uns an: Parameter 1: @RequestParam(name = "name", erforderlich = false, defaultValue = "World") String-Name. Die Annotation @RequestParam gibt an, dass der String-Namensparameter ein URL-Parameter ist. Die Anmerkungsklammern geben an, dass dieser Parameter in der URL optional ist (erforderlich = falsch). Wenn er nicht vorhanden ist, ist der Wert des String-Namensparameters World (defaultValue = „World“), und wenn er vorhanden ist, ist dieser Parameter In der URL heißt es Name (name = „name“). Möglicherweise ist hier einiges unklar. Lassen Sie uns Beispiele nennen. Die folgende Tabelle zeigt den Wert des String-Namensparameters für verschiedene Optionen für den Zugriff auf die /greeting-Adresse (mit und ohne Parameter in der URL). Parameter 2: Der zweite Parameter ist Modellmodell. Dieser Parameter ist ein Modell. Dieses Modell besteht intern aus verschiedenen Attributen. Jedes Attribut hat einen Namen und einen Wert. So etwas wie Schlüssel-Wert-Paare. Mit diesem Parameter können wir Daten vom Java-Code auf HTML-Seiten übertragen. Oder, in der MVC-Terminologie, Daten vom Modell in die Ansicht übertragen. Es bleibt die letzte Zeile zu analysieren. Die Art und Weise, wie wir Daten von Java an HTML oder von Model an View übergeben. Der Hauptteil der Methode enthält die folgende Zeile: model.addAttribute("name", name); Hier erstellen wir ein neues Attribut namens name und weisen ihm den Wert des Parameters name zu. Denken Sie daran, dass wir das Tag erst kürzlich besprochen haben: <p th:text="'Hello, ' + ${name} + '!'" /> Wir sagten, dass der Wert des p-Tags der Text „Hallo“ + der Wert der Namensvariablen sein wird, die wir aus Java-Code festlegen werden. Diesen Wert stellen wir über die Linie ein model.addAttribute("name", name);

Schritt 5. Starten

Zum Starten müssen wir die Hauptmethode in der MvcDemoApplication-Klasse ausführen: In den Startprotokollen sehen wir, dass unsere Webanwendung auf Port 8080 gestartet wurde: Und das bedeutet, dass wir im Browser auf die Seite gehen können: http:// localhost:8080 : Hier wurde uns die Seite index.html angezeigt. Folgen wir dem Link zur Begrüßung: Während dieses Übergangs funktionierte unser Controller. Wir haben keine Parameter über die URL übergeben, daher nahm der Wert des Namensattributs, wie in der Anmerkung angegeben, den Standardwert World an. Versuchen wir nun, den Parameter per URL zu übergeben: Alles funktioniert wie vorgesehen. Versuchen Sie nun, den Pfad der Namensvariablen zu verfolgen:

1. Der Benutzer hat den Wert des Parameters name = Amigo -> über die URL übergeben
2. Der Controller hat unsere Aktion verarbeitet, die Namensvariable akzeptiert und das Modellattribut mit dem Namen name und dem akzeptierten Wert festgelegt ->
3. Vom Modell gingen diese Daten zur Ansicht, zur Seite „gruss.html“ und wurden dem Benutzer angezeigt

Das ist alles!