Del 8. La oss skrive en liten applikasjon med Spring Boot

Dette materialet er den avsluttende delen av serien "Introduksjon til bedriftsutvikling". Tidligere artikler:

• om nettverk
• om programvarearkitektur
• om HTTP/HTTPS
• om det grunnleggende om Maven
• om servlets (skrive en enkel nettapplikasjon)
• om servletbeholdere
• om det grunnleggende om MVC

La oss se på den enkleste implementeringen av MVC ved å bruke Spring MVC som et eksempel. For å gjøre dette, skriver vi en liten Hello World-applikasjon med Spring Boot. Jeg vil gi deg trinnvise instruksjoner, slik at du kan gjenta alt selv. Først skal vi skrive en liten søknad, og deretter analysere den.

Trinn 1. Opprette en Spring Boot-applikasjon i IntelliJ IDEA.

Bruk Fil -> Ny -> Prosjekt... for å opprette et nytt prosjekt. I vinduet som åpnes, i menyen til venstre, velg Spring Initializr, og velg Project SDK. La standarden være for alternativet Initializr Service URL. Klikk på "Neste"-knappen. I det neste vinduet må vi velge prosjektinnstillingene. Vi skal ha et Maven-prosjekt. Velg Maven Project som type. Fyll ut gruppe- og artefaktfeltene Klikk på Neste. I det neste vinduet må vi velge Spring Framework-komponentene som vi skal bruke. To er nok for oss:

• Spring Web er en komponent som lar oss lage webapplikasjoner. Denne komponenten inkluderer Spring MVC.
• Thymeleaf er vår malmotor. Det er en ting som lar oss sende data fra Java til HTML-sider

I neste vindu velger du prosjektets navn og plassering i filsystemet: Klikk på "Fullfør"-knappen. Prosjektet er opprettet. Vi ender opp med følgende prosjektstruktur: Her er vi interessert i 2 filer: pom.xml (deployment descriptor). Denne tingen lar deg raskt og enkelt importere biblioteker fra forskjellige rammeverk inn i prosjektet vårt. Det er også her vi konfigurerer hvordan applikasjonen vår er bygget opp. Vår applikasjon er bygget med Maven, og pom.xml er konfigurasjonsfilen for dette byggesystemet. Java-klassen er MvcDemoApplication. Dette er vår applikasjons hovedklasse. Vi vil lansere vårt Spring Boot-prosjekt fra den. For å starte, bare kjør hovedmetoden for denne klassen. Her er koden for denne klassen, 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>

Trinn 2. Opprette en nettside

Vår søknad vil være ekstremt enkel. Vi vil ha en hovedside (index.html), som vil inneholde en lenke til velkomstsiden (greeting.html). På hilsensiden viser vi en hilsen. Vi bruker URL-parametere for å sende navnet som skal brukes i hilsenen til greeting.html-siden. La oss lage applikasjonens 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>

Nå skal vi lage greeting.html-siden:

<!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>

Siden vår har en <p th:text="'Hello, ' + ${name} + '!'" />tag, som ikke er vanlig for HTML. Attributten thtil taggen per en mekanisme som brukes av Thymeleaf-malmotoren. Taggens pverdi vil være "Hallo," + verdien til variabelen name, som vi vil sette i Java-kode.

Trinn 3. Opprette en kontroller

Inne i mvc_demo-pakken vil vi lage en contoller-pakke, der vi oppretter kontrolleren vår, 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 siden er det veldig lite kode, men på den andre siden er det mye som skjer. La oss starte vår analyse. @Controller-kommentaren indikerer at denne klassen er en kontroller. På våren behandler kontrollere HTTP-forespørsler rettet mot bestemte URL-er. Klassen vår har en helloWorldController-metode som er merket med @RequestMapping(verdi = "/hilsen")-kommentaren. Denne merknaden indikerer at denne metoden behandler HTTP GET-forespørsler rettet mot /greeting-URLen. Med andre ord, denne metoden vil bli påkalt hvis noen navigerer til /greeting. Denne metoden returnerer en streng. I følge Spring MVC skal kontrollermetoden returnere navnet på visningen. Deretter vil Spring se etter en HTML-fil med samme navn, som den vil returnere som svar på HTTP-forespørselen. Som du kan se, Vår metode tar 2 argumenter. La oss ta en titt på dem: Parameter 1: @RequestParam(navn = "navn", obligatorisk = usann, defaultValue = "Verden") Stringnavn. @RequestParam-kommentaren indikerer at String name-parameteren er en URL-parameter. Hvis merknaden indikerer at denne URL-parameteren er valgfri (obligatorisk = usann), og hvis den er fraværende, vil Stringnavn-parameterens verdi være "World" (defaultValue = "World"). Hvis den er til stede, vil URL-parameteren være "navn" (navn = "navn"). Det kan være mye du ikke forstår her. La oss gi noen eksempler. Tabellen nedenfor viser hva strengnavnparameterens verdi vil være, med ulike alternativer for tilgang til /greeting (med og uten URL-parametere) Parameter 2: Den andre parameteren er en modellmodell. Denne parameteren er en modell. Denne modellen består av ulike interne attributter. Hvert attributt har et navn og en verdi. Noe sånt som nøkkelverdi-par. Vi kan bruke denne parameteren til å sende data fra Java-kode til HTML-sider. Eller, ved å bruke MVC-terminologi, send data fra modellen til visningen. Det gjenstår bare å undersøke den siste linjen. Det er hvordan vi sender data fra Java til HTML, eller fra modellen til visningen. Metoden inkluderer følgende linje: model.addAttribute("name", name); Her lager vi et nytt attributt kalt name og tildeler det verdien av parameteren name. Husk at vi nylig diskuterte <p th:text = "'Hello,' + ${name} + '!'" /> Vi sa at verdien av p-taggen er "Hallo," + verdien av navnevariabelen, som vi vil sette i Java-kode. Vi setter denne verdien ved å bruke linjen model.addAttribute("name", name);

Trinn 5. Kjør

For å starte, må vi kjøre hovedmetoden til MvcDemoApplication-klassen: I loggene vil vi se at nettapplikasjonen vår startet på port 8080: Og dette betyr at i en nettleser kan vi gå til siden på http:// localhost:8080 : Her har vi siden index.html. La oss følge lenken til hilsensiden: Kontrolleren vår ble påkalt i denne overgangen. Vi sendte ingen parametere gjennom nettadressen. Som et resultat får navneattributtet standardverdien ("Verden") som er angitt i merknaden. La oss prøve å sende parameter via URL: Alt fungerer etter hensikten. Prøv nå å spore banen til navnevariabelen:

1. Brukeren ga "navn=Amigo" i URL-en ->
2. Kontrolleren behandlet handlingen vår, mottok navnvariabelen og satte et modellattributt kalt navn lik den mottatte verdien ->
3. Disse dataene kom til syne fra modellen, havnet på greeting.html-siden og ble vist til brukeren

Det var det for nå!