Del 8. Lad os skrive en lille ansøgning ved hjælp af Spring Boot

Dette materiale er den afsluttende del af serien "Introduktion til virksomhedsudvikling". Tidligere artikler:

• om netværk
• om softwarearkitektur
• om HTTP/HTTPS
• om det grundlæggende i Maven
• om servlets (skrivning af en simpel webapplikation)
• om servletbeholdere
• om det grundlæggende i MVC

Lad os se på den enkleste implementering af MVC med Spring MVC som eksempel. For at gøre dette skriver vi en lille Hello World-applikation ved hjælp af Spring Boot. Jeg giver dig trin-for-trin instruktioner, så du kan gentage alt selv. Først skriver vi en lille ansøgning, og derefter analyserer vi den.

Trin 1. Oprettelse af en Spring Boot-applikation i IntelliJ IDEA.

Brug Filer -> Nyt -> Projekt... for at oprette et nyt projekt. I det vindue, der åbnes, i menuen til venstre, vælg Spring Initializr, og vælg Project SDK. Lad standarden være for indstillingen Initializr Service URL. Klik på knappen "Næste". I det næste vindue skal vi vælge projektindstillingerne. Vi skal have et Maven-projekt. Vælg Maven Project som type. Udfyld felterne Gruppe og Artefakt Klik på Næste. I det næste vindue skal vi vælge de Spring Framework-komponenter, som vi vil bruge. To er nok for os:

• Spring Web er en komponent, der lader os skabe webapplikationer. Denne komponent inkluderer Spring MVC.
• Thymeleaf er vores skabelonmotor. Det er en ting, der lader os sende data fra Java til HTML-sider

I det næste vindue skal du vælge projektets navn og placering i filsystemet: Klik på knappen "Udfør". Projektet er oprettet. Vi ender med følgende projektstruktur: Her er vi interesseret i 2 filer: pom.xml (deployment descriptor). Denne ting lader dig hurtigt og nemt importere biblioteker fra forskellige rammer til vores projekt. Det er også her, vi konfigurerer, hvordan vores applikation er bygget op. Vores applikation er bygget ved hjælp af Maven, og pom.xml er konfigurationsfilen for dette byggesystem. Java-klassen er MvcDemoApplication. Dette er vores applikations hovedklasse. Vi vil lancere vores Spring Boot-projekt fra det. For at starte skal du bare køre hovedmetoden for denne klasse. Her er koden til denne klasse samt pom.xml-filen: 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>

Trin 2. Oprettelse af en webside

Vores ansøgning vil være ekstremt enkel. Vi får en hovedside (index.html), som vil indeholde et link til velkomstsiden (greeting.html). På hilsensiden viser vi en hilsen. Vi bruger URL-parametre til at videregive det navn, der skal bruges i hilsenen, til siden greeting.html. Lad os oprette vores applikations hovedside — 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>

Nu vil vi oprette siden 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>

Vores side har et <p th:text="'Hello, ' + ${name} + '!'" />tag, som ikke er normalt for HTML. Attributten thaf p​​tagget er en mekanisme, der bruges af Thymeleaf-skabelonmotoren. Taggets pværdi vil være "Hej," + værdien af ​​variablen name, som vi indstiller i Java-kode.

Trin 3. Oprettelse af en controller

Inde i mvc_demo-pakken opretter vi en contoller-pakke, hvori vi vil oprette vores controller, HelloWorldController:

@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";
   }

}

På den ene side er der meget lidt kode, men på den anden side sker der meget. Lad os starte vores analyse. @Controller-annotationen angiver, at denne klasse er en controller. I foråret behandler controllere HTTP-anmodninger rettet mod specifikke URL'er. Vores klasse har en helloWorldController-metode, der er markeret med @RequestMapping(værdi = "/hilsen") annotation. Denne annotation angiver, at denne metode behandler HTTP GET-anmodninger rettet mod /greeting-URL'en. Med andre ord, denne metode vil blive påkaldt, hvis nogen navigerer til /greeting. Denne metode returnerer en streng. Ifølge Spring MVC skal controllermetoden returnere navnet på visningen. Dernæst vil Spring lede efter en HTML-fil med samme navn, som den returnerer som svar på HTTP-anmodningen. Som du kan se, Vores metode tager 2 argumenter. Lad os tage et kig på dem: Parameter 1: @RequestParam(navn = "navn", påkrævet = falsk, defaultValue = "Verden") Strengnavn. @RequestParam-annotationen angiver, at parameteren String name er en URL-parameter. Hvis annoteringen angiver, at denne URL-parameter er valgfri (påkrævet = falsk), vil værdien for strengnavnsparameteren være "World" (defaultValue = "World"), hvis den er fraværende. Hvis den er til stede, vil URL-parameteren være "navn" (navn = "navn"). Der er måske meget, du ikke forstår her. Lad os give nogle eksempler. Tabellen nedenfor viser, hvad værdien af ​​strengnavnsparameteren vil være, med forskellige muligheder for at få adgang til /hilsen (med og uden URL-parametre) Parameter 2: Den anden parameter er en modelmodel. Denne parameter er en model. Denne model består af forskellige interne attributter. Hver egenskab har et navn og en værdi. Noget som nøgle-værdi-par. Vi kan bruge denne parameter til at sende data fra Java-kode til HTML-sider. Eller send data fra modellen til visningen ved hjælp af MVC-terminologi. Det er kun tilbage at undersøge den sidste linje. Det er, hvordan vi sender data fra Java til HTML, eller fra modellen til visningen. Metoden omfatter følgende linje: model.addAttribute("name", name); Her opretter vi en ny attribut kaldet name og tildeler den værdien af ​​parameteren name. Husk, at vi for nylig diskuterede <p th:text = "'Hello,' + ${name} + '!'" /> Vi sagde, at værdien af ​​p-tagget er "Hej," + værdien af ​​navnevariablen, som vi indstiller i Java-kode. Vi indstiller denne værdi ved hjælp af linjen model.addAttribute("name", name);

Trin 5. Kør

For at starte skal vi køre hovedmetoden for MvcDemoApplication-klassen: I logfilerne vil vi se, at vores webapplikation startede på port 8080: Og det betyder, at vi i en browser kan gå til siden på http:// localhost:8080 : Her har vi siden index.html. Lad os følge linket til hilsensiden: Vores controller blev påkaldt i denne overgang. Vi sendte ingen parametre gennem URL'en. Som et resultat heraf antager navneattributten standardværdien ("Verden") angivet i annoteringen. Lad os prøve at sende parameter via URL'en: Alt fungerer efter hensigten. Prøv nu at spore stien til navnevariablen:

1. Brugeren sendte "name=Amigo" i URL'en ->
2. Controlleren behandlede vores handling, modtog navnevariablen og indstillede en modelattribut kaldet name lig med den modtagne værdi ->
3. Disse data kom til at se fra modellen, endte på siden greeting.html og blev vist til brugeren

Det var det for nu!