Parte 8. Scriviamo una piccola applicazione usando Spring Boot

Questo materiale è la parte conclusiva della serie "Introduzione allo sviluppo aziendale". Articoli precedenti:

• sulla rete
• sull'architettura del software
• su HTTP/HTTPS
• sulle basi di Maven
• sui servlet (scrittura di una semplice applicazione web)
• sui contenitori servlet
• sulle basi di MVC

Diamo un'occhiata all'implementazione più semplice di MVC usando Spring MVC come esempio. Per fare questo, scriveremo una piccola applicazione Hello World usando Spring Boot. Ti darò istruzioni passo passo, così potrai ripetere tutto da solo. Per prima cosa scriveremo una piccola applicazione e poi la analizzeremo.

Passaggio 1. Creazione di un'applicazione Spring Boot in IntelliJ IDEA.

Utilizzare File -> Nuovo -> Progetto... per creare un nuovo progetto. Nella finestra che si apre, nel menu a sinistra, seleziona Spring Initializr e seleziona Project SDK. Lasciare l'impostazione predefinita per l'opzione URL del servizio Initializr. Fare clic sul pulsante "Avanti". Nella finestra successiva, dobbiamo selezionare le impostazioni del progetto. Avremo un progetto Maven. Seleziona Maven Project come tipo. Compila i campi Gruppo e Artefatto Fare clic su Avanti. Nella finestra successiva, dobbiamo selezionare i componenti di Spring Framework che utilizzeremo. A noi ne bastano due:

• Spring Web è un componente che ci permette di creare applicazioni web. Questo componente include Spring MVC.
• Thymeleaf è il nostro motore di template. È una cosa che ci consente di inviare dati da Java a pagine HTML

Nella finestra successiva, seleziona il nome e la posizione del progetto nel file system: fai clic sul pulsante "Fine". Il progetto è creato. Finiamo con la seguente struttura del progetto: Qui siamo interessati a 2 file: pom.xml (descrittore di distribuzione). Questa cosa ti consente di importare rapidamente e facilmente librerie da diversi framework nel nostro progetto. È anche il luogo in cui configuriamo il modo in cui viene creata la nostra applicazione. La nostra applicazione è stata creata utilizzando Maven e pom.xml è il file di configurazione per questo sistema di compilazione. La classe Java è MvcDemoApplication. Questa è la classe principale della nostra applicazione. Lanceremo il nostro progetto Spring Boot da esso. Per iniziare, basta eseguire il metodo principale di questa classe. Ecco il codice per questa classe, così come il file 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>

Passo 2. Creazione di una pagina web

La nostra applicazione sarà estremamente semplice. Avremo una pagina principale (index.html), che conterrà un link alla pagina di benvenuto (greeting.html). Nella pagina di saluto, mostriamo un saluto. Useremo i parametri URL per passare il nome da utilizzare nel saluto alla pagina greeting.html. Creiamo la pagina principale della nostra applicazione — 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>

Ora creeremo la pagina 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>

La nostra pagina ha un <p th:text="'Hello, ' + ${name} + '!'" />tag, che non è normale per l'HTML. L' thattributo del ptag è un meccanismo utilizzato dal motore di template Thymeleaf. Il pvalore del tag sarà "Hello, " + il valore della namevariabile , che imposteremo nel codice Java.

Passaggio 3. Creazione di un controller

All'interno del pacchetto mvc_demo, creeremo un pacchetto controller, in cui creeremo il nostro 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";
   }

}

Da un lato c'è pochissimo codice, ma dall'altro c'è molto da fare. Iniziamo la nostra analisi. L'annotazione @Controller indica che questa classe è un controller. In primavera, i controller elaborano le richieste HTTP dirette a URL specifici. La nostra classe ha un metodo helloWorldController contrassegnato con l'annotazione @RequestMapping(value = "/greeting"). Questa annotazione indica che questo metodo elabora le richieste HTTP GET dirette all'URL /greeting. In altre parole, questo metodo verrà invocato se qualcuno accede a /greeting. Questo metodo restituisce una stringa. Secondo Spring MVC, il metodo del controller dovrebbe restituire il nome della vista. Successivamente, Spring cercherà un file HTML con lo stesso nome, che restituirà come risposta alla richiesta HTTP. Come potete vedere, Il nostro metodo accetta 2 argomenti. Diamo un'occhiata a loro: Parametro 1: @RequestParam(name = "name", required = false, defaultValue = "World") String name. L'annotazione @RequestParam indica che il parametro String name è un parametro URL. Se l'annotazione indica che questo parametro URL è facoltativo (richiesto = false), se è assente, il valore del parametro String name sarà "World" (defaultValue = "World"). Se è presente, il parametro URL sarà "name" (name = "name"). Potrebbero esserci molte cose che non capisci qui. Forniamo alcuni esempi. La tabella seguente mostra quale sarà il valore del parametro String name, con varie opzioni per l'accesso a /greeting (con e senza parametri URL) Parametro 2: il secondo parametro è un modello Model. Questo parametro è un modello. Questo modello è costituito da vari attributi interni. Ogni attributo ha un nome e un valore. Qualcosa come coppie chiave-valore. Possiamo utilizzare questo parametro per inviare dati dal codice Java alle pagine HTML. Oppure, utilizzando la terminologia MVC, inviare i dati dal modello alla vista. Resta solo da esaminare l'ultima riga. È il modo in cui inviamo i dati da Java a HTML o dal modello alla vista. Il metodo include la seguente riga: model.addAttribute("name", name); Qui creiamo un nuovo attributo chiamato name e gli assegniamo il valore del parametro name. Ricorda, di recente abbiamo discusso di <p th:text = "'Hello,' + ${name} + '!'" /> Abbiamo detto che il valore del tag p è "Ciao", + il valore della variabile name, che imposteremo nel codice Java. Impostiamo questo valore usando la linea model.addAttribute("name", name);

Passaggio 5. Corri

Per iniziare, dobbiamo eseguire il metodo principale della classe MvcDemoApplication: Nei log, vedremo che la nostra applicazione web è stata avviata sulla porta 8080: E questo significa che in un browser, possiamo andare alla pagina all'indirizzo http:// localhost:8080 : Qui abbiamo la pagina index.html. Seguiamo il collegamento alla pagina di saluto: Il nostro controller è stato richiamato in questa transizione. Non abbiamo trasmesso alcun parametro tramite l'URL. Di conseguenza, l'attributo name assume il valore predefinito ("World") indicato nell'annotazione. Proviamo a passare il parametro tramite l'URL: Tutto funziona come previsto. Ora prova a tracciare il percorso della variabile name:

1. L'utente ha passato "name=Amigo" nell'URL ->
2. Il controller ha elaborato la nostra azione, ha ricevuto la variabile name e ha impostato un attributo del modello chiamato name uguale al valore ricevuto ->
3. Questi dati venivano visualizzati dal modello, finendo nella pagina greeting.html, e venivano mostrati all'utente

Questo è tutto per ora!