Deel 8. Laten we een kleine applicatie schrijven met Spring Boot

Dit materiaal is het afsluitende deel van de serie "Inleiding tot bedrijfsontwikkeling". Vorige artikelen:

• over netwerken
• over software-architectuur
• over HTTP/HTTPS
• over de basis van Maven
• over servlets (een eenvoudige webapplicatie schrijven)
• over servletcontainers
• over de basisprincipes van MVC

Laten we eens kijken naar de eenvoudigste implementatie van MVC met Spring MVC als voorbeeld. Om dit te doen, schrijven we een kleine Hello World-applicatie met behulp van Spring Boot. Ik geef je stap voor stap instructies, zodat je alles zelf kunt herhalen. Eerst schrijven we een kleine applicatie en daarna analyseren we deze.

Stap 1. Een Spring Boot-toepassing maken in IntelliJ IDEA.

Gebruik Bestand -> Nieuw -> Project… om een ​​nieuw project aan te maken. In het venster dat wordt geopend, selecteert u in het menu aan de linkerkant Spring Initializr en selecteert u de Project SDK. Laat de standaard waarde staan ​​voor de optie Initializr Service URL. Klik op de knop "Volgende". In het volgende venster moeten we de projectinstellingen selecteren. We krijgen een Maven-project. Selecteer Maven Project als het type. Vul de velden Groep en Artefact in Klik op Volgende. In het volgende venster moeten we de Spring Framework-componenten selecteren die we zullen gebruiken. Twee zijn genoeg voor ons:

• Spring Web is een component waarmee we webapplicaties kunnen maken. Dit onderdeel bevat Spring MVC.
• Thymeleaf is onze template-engine. Het is iets waarmee we gegevens van Java naar HTML-pagina's kunnen sturen

Selecteer in het volgende venster de naam van het project en de locatie in het bestandssysteem: Klik op de knop "Voltooien". Het project wordt gemaakt. We eindigen met de volgende projectstructuur: Hier zijn we geïnteresseerd in 2 bestanden: pom.xml (deployment descriptor). Met dit ding kun je snel en eenvoudig bibliotheken uit verschillende frameworks in ons project importeren. Het is ook waar we configureren hoe onze applicatie is gebouwd. Onze applicatie is gebouwd met Maven en pom.xml is het configuratiebestand voor dit buildsysteem. De Java-klasse is MvcDemoApplication. Dit is de hoofdklasse van onze applicatie. Van daaruit lanceren we ons Spring Boot-project. Voer om te beginnen gewoon de hoofdmethode van deze klasse uit. Hier is de code voor deze klasse, evenals het bestand 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>

Stap 2. Een webpagina maken

Onze applicatie zal uiterst eenvoudig zijn. We zullen een hoofdpagina hebben (index.html), die een link zal bevatten naar de welkomstpagina (greeting.html). Op de begroetingspagina tonen we een begroeting. We gebruiken URL-parameters om de naam die in de begroeting moet worden gebruikt, door te geven aan de pagina greeting.html. Laten we de hoofdpagina van onze applicatie maken — 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 gaan we de pagina greeting.html maken:

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

Onze pagina heeft een <p th:text="'Hello, ' + ${name} + '!'" />tag, wat niet normaal is voor HTML. Het thattribuut van de ptag is een mechanisme dat wordt gebruikt door de Thymeleaf-sjabloonengine. De pwaarde van de tag is "Hallo", + de waarde van de namevariabele , die we in Java-code zullen instellen.

Stap 3. Een controller maken

Binnen het mvc_demo-pakket maken we een contoller-pakket, waarin we onze controller, HelloWorldController, maken:

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

}

Aan de ene kant is er heel weinig code, maar aan de andere kant gebeurt er veel. Laten we beginnen met onze analyse. De annotatie @Controller geeft aan dat deze klasse een controller is. In het voorjaar verwerken controllers HTTP-verzoeken die zijn gericht op specifieke URL's. Onze klasse heeft een methode helloWorldController die is gemarkeerd met de annotatie @RequestMapping(value = "/greeting"). Deze annotatie geeft aan dat deze methode HTTP GET-verzoeken verwerkt die zijn gericht aan de /greeting-URL. Met andere woorden, deze methode wordt aangeroepen als iemand naar /greeting navigeert. Deze methode retourneert een string. Volgens Spring MVC zou de controllermethode de naam van de weergave moeten retourneren. Vervolgens zoekt Spring naar een HTML-bestand met dezelfde naam, dat wordt geretourneerd als antwoord op het HTTP-verzoek. Zoals je kan zien, Onze methode heeft 2 argumenten nodig. Laten we ze eens bekijken: Parameter 1: @RequestParam(name = "name", required = false, defaultValue = "World") Tekenreeksnaam. De annotatie @RequestParam geeft aan dat de stringnaamparameter een URL-parameter is. Als de annotatie aangeeft dat deze URL-parameter optioneel is (vereist = false), en als deze afwezig is, is de waarde van de stringnaamparameter "World" (defaultValue = "World"). Als deze aanwezig is, is de URL-parameter "name" (name = "name"). Er is misschien veel dat je hier niet begrijpt. Laten we enkele voorbeelden geven. De onderstaande tabel laat zien wat de waarde van de String name-parameter zal zijn, met verschillende opties voor toegang tot /greeting (met en zonder URL-parameters) Parameter 2: De tweede parameter is een modelmodel. Deze parameter is een model. Dit model bestaat uit verschillende interne attributen. Elk attribuut heeft een naam en een waarde. Iets als sleutel-waardeparen. We kunnen deze parameter gebruiken om gegevens van Java-code naar HTML-pagina's te sturen. Of, gebruik MVC-terminologie, verzend gegevens van het model naar de weergave. Het blijft alleen om de laatste regel te onderzoeken. Het is hoe we gegevens van Java naar HTML sturen, of van het model naar de weergave. De methode bevat de volgende regel: model.addAttribute("name", name); Hier maken we een nieuw attribuut met de naam naam en kennen we het de waarde toe van de naamparameter. Onthoud dat we onlangs de <p th:text = "'Hello,' + ${name} + '!'" /> We zeiden dat de waarde van de p-tag "Hallo" is + de waarde van de naamvariabele, die we in Java-code zullen instellen. We stellen deze waarde in met behulp van de regel model.addAttribute("name", name);

Stap 5. Rennen

Om te beginnen moeten we de hoofdmethode van de klasse MvcDemoApplication uitvoeren: in de logboeken zullen we zien dat onze webtoepassing is gestart op poort 8080: en dit betekent dat we in een browser naar de pagina kunnen gaan op http:// localhost:8080 : Hier hebben we de index.html pagina. Laten we de link naar de begroetingspagina volgen: Onze controller is aangeroepen in deze overgang. We hebben geen parameters doorgegeven via de URL. Als gevolg hiervan krijgt het naamkenmerk de standaardwaarde ("Wereld") die in de annotatie wordt aangegeven. Laten we proberen de parameter door te geven via de URL: alles werkt zoals bedoeld. Probeer nu het pad van de naamvariabele te traceren:

1. De gebruiker heeft "name=Amigo" doorgegeven in de URL ->
2. De controller heeft onze actie verwerkt, de naamvariabele ontvangen en een modelattribuut met de naam naam ingesteld dat gelijk is aan de ontvangen waarde ->
3. Deze gegevens kwamen vanuit het model te zien, kwamen terecht op de pagina greeting.html en werden getoond aan de gebruiker

Dat is het voor nu!