Parte 8. Scrivere una piccola applicazione in spring-boot

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

• sulla rete ;
• sull'architettura del software ;
• sui protocolli HTTP/HTTPS ;
• sulle nozioni di base di Maven ;
• sulle servlet (stiamo scrivendo una semplice applicazione web) ;
• sui contenitori servlet .
• sulle nozioni di base di MVC .

Diamo un'occhiata all'esempio più semplice di implementazione MVC utilizzando Spring-MVC come esempio. Per fare ciò, scriviamo una piccola applicazione Hello World in spring-boot. Affinché tu possa ripetere tutto da solo, ti darò istruzioni passo passo. Per prima cosa scriveremo una piccola applicazione e poi la analizzeremo.

Passaggio 1: creare un'applicazione spring-boot in IntelliJ IDEA

Utilizzando File -> Nuovo -> Progetto... crea un nuovo progetto. Nella finestra che si apre, nel menu a sinistra, seleziona Spring Inizializr, seleziona Project SDK e lascia l'opzione URL del servizio Inizializr come predefinita. Fare clic sul pulsante Avanti. Nella finestra successiva dobbiamo selezionare i parametri del progetto. Avremo un progetto Maven. Selezionare Tipo - Progetto Maven, compilare Gruppo e Artifatto e fare clic su Avanti. Nella finestra successiva dobbiamo selezionare i componenti Spring Framework che utilizzeremo. Ne servono solo due:

• Spring Web è un componente che ci permetterà di creare applicazioni Web. Questo componente include Spring MVC.
• Thymeleaf - Il cosiddetto motore di template. Una cosa che ci permetterà di trasferire dati da Java alle pagine HTML

Nella finestra successiva seleziona il nome e la posizione del progetto nel file system: fai clic sul pulsante Fine. Il progetto è stato creato. Abbiamo la seguente struttura del progetto: Qui siamo interessati a 2 file: pom.xml - descrittore di distribuzione. Una cosa che ti consente di importare rapidamente e facilmente librerie da diversi framework nel nostro progetto, nonché una cosa in cui configuriamo l'assemblaggio della nostra applicazione. La nostra applicazione è creata utilizzando Maven, pom.xml è il file di configurazione di questo sistema di build. Classe Java: MvcDemoApplication. Questa è la classe principale della nostra applicazione, da cui lanceremo il nostro progetto spring-boot. Per iniziare, esegui semplicemente il metodo main in 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.javarush</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>

Passaggio 2. Crea pagine web

La nostra applicazione sarà estremamente semplice. Avremo una pagina principale - index.html, all'interno della quale ci sarà un collegamento alla pagina di benvenuto - Greeting.html. Nella pagina di saluto visualizzeremo il saluto. Implementiamo la possibilità di inviare un nome di saluto alla pagina Greeting.html tramite parametri URL. 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 creiamo 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>

Qui, da una pagina html atipica, puoi vedere un tag: L' <p th:text="'Hello, ' + ${name} + '!'" /> attributo thtag pè uno strumento del motore di template Thymeleaf. Grazie ad esso, il valore del tag psarà il testo “Ciao”, + il valore della variabile name, che imposteremo dal codice Java.

Passaggio 3: crea un controller

All'interno del pacchetto mvc_demo creeremo un pacchetto contoller, all'interno del quale 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 l'analisi. L'annotazione @Controller indica che questa classe è un controller. I controller in Spring elaborano le richieste HTTP a indirizzi specifici. La nostra classe ha un metodo helloWorldController, contrassegnato con l'annotazione - @RequestMapping(value = "/greeting"). Questa annotazione ci dice che questo metodo elabora le richieste HTTP GET all'indirizzo /greeting. In altre parole, questo metodo funzionerà se qualcuno va a /greeting. Questo metodo restituisce String. Secondo Spring-MVC, il metodo del controller deve restituire il nome della vista. Successivamente, Spring cercherà un file html con lo stesso nome, che verrà restituito come risposta alla richiesta HTTP. Come puoi vedere, il nostro metodo restituisce il nome della pagina web che abbiamo creato in precedenza: saluto. Il nostro metodo richiede 2 argomenti. Esaminiamoli: Parametro 1: @RequestParam(name = "name", obbligatorio = false, defaultValue = "World") Nome della stringa. L'annotazione @RequestParam afferma che il parametro String name è un parametro URL. Le parentesi di annotazione indicano che questo parametro nell'URL è facoltativo (richiesto = false), se è assente, il valore del parametro Nome stringa sarà World (defaultValue = "World"), e se è presente, allora questo parametro nell'URL verrà chiamato nome (nome = "nome") Potrebbero esserci molte cose non chiare qui. Facciamo degli esempi. La tabella seguente mostra quale sarà il valore del parametro String name per le diverse opzioni di accesso all'indirizzo /greeting (con e senza parametri nell'URL) Parametro 2: il secondo parametro è Modello modello. Questo parametro è un modello. Questo modello è costituito internamente da vari attributi. Ogni attributo ha un nome e un valore. Qualcosa come coppie chiave-valore. Utilizzando questo parametro, possiamo trasferire i dati dal codice Java alle pagine html. Oppure, nella terminologia MVC, trasferisci i dati dal modello alla vista. Resta da analizzare l'ultima riga. Il modo in cui passiamo i dati da Java a HTML o dal Modello alla Vista. Il corpo del metodo contiene la seguente riga: model.addAttribute("name", name); Qui creiamo un nuovo attributo chiamato name e gli assegniamo il valore del parametro name. Ricorda, proprio di recente abbiamo discusso del tag: <p th:text="'Hello, ' + ${name} + '!'" /> abbiamo detto che il valore del tag p sarà il testo "Ciao", + il valore della variabile nome, che imposteremo dal codice Java. Impostiamo questo valore utilizzando la linea model.addAttribute("name", name);

Passaggio 5. Avvia

Per avviarla dobbiamo eseguire il metodo main nella classe MvcDemoApplication: Nei log di avvio vedremo che la nostra applicazione web è stata avviata sulla porta 8080: Ciò significa che possiamo andare alla pagina nel browser: http:// localhost:8080 : qui ci è stata mostrata la pagina index.html. Seguiamo il collegamento a greetin: Durante questa transizione, il nostro controller ha funzionato. Non abbiamo passato alcun parametro attraverso l'URL, pertanto, come indicato nell'annotazione, il valore dell'attributo name ha assunto il valore predefinito World. Proviamo ora a passare il parametro tramite url: tutto funziona come previsto. Ora prova a tracciare il percorso della variabile nome:

1. L'utente ha passato il valore del parametro name = Amigo -> tramite url
2. Il controller ha elaborato la nostra azione, ha accettato la variabile name e ha impostato l'attributo model, con il nome name e il valore accettato ->
3. Dal modello, questi dati sono andati alla vista, alla pagina Greeting.html e sono stati visualizzati all'utente

È tutto!