Parte 8. Vamos escrever um pequeno aplicativo usando Spring Boot

Este material é a parte final da série "Introdução ao Desenvolvimento Corporativo". Artigos anteriores:

• sobre networking
• sobre arquitetura de software
• sobre HTTP/HTTPS
• sobre o básico do Maven
• sobre servlets (escrever uma aplicação web simples)
• sobre contêineres de servlet
• sobre o básico do MVC

Vejamos a implementação mais simples do MVC usando o Spring MVC como exemplo. Para fazer isso, escreveremos um pequeno aplicativo Hello World usando Spring Boot. Darei instruções passo a passo para que você possa repetir tudo sozinho. Primeiro, escreveremos um pequeno aplicativo e depois o analisaremos.

Etapa 1. Criando um aplicativo Spring Boot no IntelliJ IDEA.

Use Arquivo -> Novo -> Projeto… para criar um novo projeto. Na janela que se abre, no menu do lado esquerdo, selecione Spring Initializr e selecione o Project SDK. Deixe o padrão para a opção Initializr Service URL. Clique no botão "Avançar". Na próxima janela, precisamos selecionar as configurações do projeto. Nós vamos ter um projeto Maven. Selecione Maven Project como o tipo. Preencha os campos Grupo e Artefato Clique em Avançar. Na próxima janela, precisamos selecionar os componentes do Spring Framework que usaremos. Dois são suficientes para nós:

• Spring Web é um componente que nos permite criar aplicações web. Este componente inclui o Spring MVC.
• Thymeleaf é o nosso mecanismo de modelo. É algo que nos permite enviar dados de páginas Java para HTML

Na próxima janela, selecione o nome do projeto e a localização no sistema de arquivos: Clique no botão "Concluir". O projeto é criado. Terminamos com a seguinte estrutura de projeto: Aqui estamos interessados ​​em 2 arquivos: pom.xml (descritor de implantação). Isso permite que você importe rápida e facilmente bibliotecas de diferentes estruturas para o nosso projeto. É também onde configuramos como nosso aplicativo é construído. Nosso aplicativo é construído usando Maven e pom.xml é o arquivo de configuração para este sistema de compilação. A classe Java é MvcDemoApplication. Esta é a classe principal da nossa aplicação. Vamos lançar nosso projeto Spring Boot a partir dele. Para começar, basta executar o método main desta classe. Aqui está o código para esta classe, bem como o arquivo 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>

Etapa 2. Criando uma página da Web

Nossa aplicação será extremamente simples. Teremos uma página principal (index.html), que conterá um link para a página de boas-vindas (greeting.html). Na página de saudação, exibimos uma saudação. Usaremos parâmetros de URL para passar o nome a ser usado na saudação para a página greeting.html. Vamos criar a página principal do nosso aplicativo — 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>

Agora vamos criar a página 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>

Nossa página possui uma <p th:text="'Hello, ' + ${name} + '!'" />tag, o que não é normal para HTML. O thatributo da ptag é um mecanismo usado pelo mecanismo de modelo Thymeleaf. O pvalor da tag será "Hello, " + o valor da namevariável , que definiremos no código Java.

Etapa 3. Criando um controlador

Dentro do pacote mvc_demo, criaremos um pacote contoller, no qual criaremos nosso controlador, 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";
   }

}

Por um lado, há muito pouco código, mas, por outro lado, há muita coisa acontecendo. Vamos começar nossa análise. A anotação @Controller indica que esta classe é um controlador. No Spring, os controladores processam solicitações HTTP direcionadas a URLs específicos. Nossa classe tem um método helloWorldController que é marcado com a anotação @RequestMapping(value = "/greeting"). Essa anotação indica que esse método processa solicitações HTTP GET direcionadas à URL /greeting. Em outras palavras, esse método será invocado se alguém navegar para /greeting. Este método retorna uma String. De acordo com o Spring MVC, o método do controller deve retornar o nome da view. Em seguida, o Spring procurará um arquivo HTML com o mesmo nome, que retornará como resposta à solicitação HTTP. Como você pode ver, Nosso método leva 2 argumentos. Vamos dar uma olhada neles: Parâmetro 1: @RequestParam(name = "name", required = false, defaultValue = "World") Nome da string. A anotação @RequestParam indica que o parâmetro String name é um parâmetro de URL. Se a anotação indicar que este parâmetro de URL é opcional (obrigatório = false), então se estiver ausente, o valor do parâmetro String name será "World" (defaultValue = "World"). Se estiver presente, o parâmetro da URL será "nome" (nome = "nome"). Pode haver muita coisa que você não entende aqui. Vamos fornecer alguns exemplos. A tabela abaixo mostra qual será o valor do parâmetro String name, com várias opções de acesso ao /greeting (com e sem parâmetros de URL) Parâmetro 2: O segundo parâmetro é um modelo de modelo. Este parâmetro é algum modelo. Este modelo consiste em vários atributos internos. Cada atributo tem um nome e um valor. Algo como pares chave-valor. Podemos usar esse parâmetro para enviar dados do código Java para páginas HTML. Ou, usando a terminologia MVC, envie dados do modelo para a exibição. Resta apenas examinar a última linha. É assim que enviamos dados de Java para HTML, ou do model para a view. O método inclui a seguinte linha: model.addAttribute("name", name); Aqui criamos um novo atributo chamado name e atribuímos a ele o valor do parâmetro name. Lembre-se, discutimos recentemente o <p th:text = "'Hello,' + ${name} + '!'" /> que dissemos que o valor da tag p é "Hello, " + o valor da variável name, que definiremos no código Java. Definimos esse valor usando a linha model.addAttribute("name", name);

Etapa 5. Executar

Para começar, precisamos executar o método main da classe MvcDemoApplication: Nos logs, veremos que nossa aplicação web iniciou na porta 8080: E isso significa que em um navegador, podemos acessar a página http:// localhost:8080 : Aqui temos a página index.html. Vamos seguir o link para a página de saudação: Nosso controlador foi invocado nesta transição. Não passamos nenhum parâmetro pela URL. Como resultado, o atributo name assume o valor padrão ("World") indicado na anotação. Vamos tentar passar o parâmetro por meio da URL: Tudo funciona conforme o esperado. Agora tente rastrear o caminho da variável name:

1. O usuário passou "name=Amigo" na URL ->
2. O controlador processou nossa ação, recebeu a variável name e definiu um atributo de modelo chamado name igual ao valor recebido ->
3. Esses dados vieram para visualização do modelo, terminando na página greeting.html e foram exibidos para o usuário

Por enquanto é isso!