Del 8. Låt oss skriva en liten applikation med Spring Boot

Detta material är den avslutande delen av serien "Introduktion till företagsutveckling". Tidigare artiklar:

• om nätverkande
• om mjukvaruarkitektur
• om HTTP/HTTPS
• om grunderna i Maven
• om servlets (att skriva en enkel webbapplikation)
• om servletbehållare
• om grunderna i MVC

Låt oss titta på den enklaste implementeringen av MVC med Spring MVC som exempel. För att göra detta kommer vi att skriva en liten Hello World-applikation med Spring Boot. Jag ger dig steg-för-steg-instruktioner, så att du kan upprepa allt själv. Först skriver vi en liten ansökan och sedan analyserar vi den.

Steg 1. Skapa en Spring Boot-applikation i IntelliJ IDEA.

Använd Arkiv -> Nytt -> Projekt... för att skapa ett nytt projekt. I fönstret som öppnas, i menyn till vänster, välj Spring Initializr och välj Project SDK. Lämna standard för alternativet Initializr Service URL. Klicka på knappen "Nästa". I nästa fönster måste vi välja projektinställningar. Vi ska ha ett Maven-projekt. Välj Maven Project som typ. Fyll i grupp- och artefaktfälten Klicka på Nästa. I nästa fönster måste vi välja de Spring Framework-komponenter som vi ska använda. Två räcker för oss:

• Spring Web är en komponent som låter oss skapa webbapplikationer. Denna komponent inkluderar Spring MVC.
• Thymeleaf är vår mallmotor. Det är en sak som låter oss skicka data från Java till HTML-sidor

I nästa fönster väljer du projektets namn och plats i filsystemet: Klicka på knappen "Slutför". Projektet är skapat. Vi slutar med följande projektstruktur: Här är vi intresserade av 2 filer: pom.xml (deployment descriptor). Denna sak låter dig snabbt och enkelt importera bibliotek från olika ramverk till vårt projekt. Det är också där vi konfigurerar hur vår applikation är byggd. Vår applikation är byggd med Maven, och pom.xml är konfigurationsfilen för detta byggsystem. Java-klassen är MvcDemoApplication. Detta är vår applikations huvudklass. Vi kommer att lansera vårt Spring Boot-projekt från det. För att börja, kör bara huvudmetoden för den här klassen. Här är koden för den här klassen, såväl som filen 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>

Steg 2. Skapa en webbsida

Vår ansökan kommer att vara extremt enkel. Vi kommer att ha en huvudsida (index.html), som kommer att innehålla en länk till välkomstsidan (greeting.html). På hälsningssidan visar vi en hälsning. Vi använder URL-parametrar för att skicka namnet som ska användas i hälsningen till sidan greeting.html. Låt oss skapa vår applikations huvudsida — 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 ska vi skapa sidan 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>

Vår sida har en <p th:text="'Hello, ' + ${name} + '!'" />tagg, vilket inte är normalt för HTML. Attributet thför ptaggen är en mekanism som används av Thymeleafs mallmotor. Taggens pvärde kommer att vara "Hello," + värdet på variabeln , namesom vi ställer in i Java-kod.

Steg 3. Skapa en kontroller

Inuti mvc_demo-paketet skapar vi ett contoller-paket, där vi skapar vår kontroller, 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";
   }

}

Å ena sidan finns det väldigt lite kod, men å andra sidan är det mycket som händer. Låt oss börja vår analys. @Controller-anteckningen indikerar att den här klassen är en kontroller. Under våren behandlar kontrollanter HTTP-förfrågningar riktade mot specifika URL:er. Vår klass har en helloWorldController-metod som är markerad med @RequestMapping(värde = "/hälsning") annotering. Den här anteckningen indikerar att den här metoden bearbetar HTTP GET-förfrågningar riktade till /hälsningsadressen. Med andra ord kommer den här metoden att anropas om någon navigerar till /hälsning. Denna metod returnerar en sträng. Enligt Spring MVC ska kontrollmetoden returnera namnet på vyn. Därefter kommer Spring att leta efter en HTML-fil med samma namn, som den kommer att returnera som svar på HTTP-förfrågan. Som du kan se, Vår metod tar 2 argument. Låt oss ta en titt på dem: Parameter 1: @RequestParam(name = "name", required = false, defaultValue = "World") Strängnamn. @RequestParam-anteckningen indikerar att parametern String name är en URL-parameter. Om anteckningen indikerar att den här URL-parametern är valfri (required = false), och om den saknas, kommer String name-parameterns värde att vara "World" (defaultValue = "World"). Om den finns kommer URL-parametern att vara "namn" (namn = "namn"). Det kan finnas mycket du inte förstår här. Låt oss ge några exempel. Tabellen nedan visar vad strängnamnsparameterns värde kommer att vara, med olika alternativ för åtkomst till /hälsning (med och utan URL-parametrar) Parameter 2: Den andra parametern är en modellmodell. Denna parameter är någon modell. Denna modell består av olika interna attribut. Varje attribut har ett namn och ett värde. Något som nyckel-värde-par. Vi kan använda denna parameter för att skicka data från Java-kod till HTML-sidor. Eller, med hjälp av MVC-terminologi, skicka data från modellen till vyn. Det återstår bara att undersöka den sista raden. Det är hur vi skickar data från Java till HTML, eller från modellen till vyn. Metoden innehåller följande rad: model.addAttribute("name", name); Här skapar vi ett nytt attribut som heter namn och tilldelar det värdet på parametern name. Kom ihåg att vi nyligen diskuterade <p th:text = "'Hello,' + ${name} + '!'" /> Vi sa att värdet på p-taggen är "Hej", + värdet på namnvariabeln, som vi kommer att ställa in i Java-kod. Vi ställer in detta värde med hjälp av linjen model.addAttribute("name", name);

Steg 5. Kör

För att börja måste vi köra huvudmetoden för MvcDemoApplication-klassen: I loggarna kommer vi att se att vår webbapplikation startade på port 8080: Och detta betyder att vi i en webbläsare kan gå till sidan på http:// localhost:8080 : Här har vi sidan index.html. Låt oss följa länken till hälsningssidan: Vår kontrollant anropades i denna övergång. Vi skickade inga parametrar genom webbadressen. Som ett resultat får namnattributet standardvärdet ("World") som anges i anteckningen. Låt oss försöka skicka parameter via URL: Allt fungerar som det är tänkt. Försök nu att spåra sökvägen till namnvariabeln:

1. Användaren skickade "name=Amigo" i URL-adressen ->
2. Styrenheten bearbetade vår åtgärd, fick namnvariabeln och satte ett modellattribut som heter namn lika med det mottagna värdet ->
3. Dessa data kom att se från modellen, hamnade på sidan greeting.html och visades för användaren

Det var allt för nu!