Crud Simples Spring Mvc
Este guia fornece uma amostra de como o Spring Boot ajuda a acelerar o desenvolvimento de aplicativos. Conforme você lê mais guias de primeiros passos do Spring, verá mais casos de uso para o Spring Boot. Este guia tem como objetivo dar uma ideia rápida do Spring Boot. Se você deseja criar seu próprio projeto baseado em Spring Boot, visite Spring Initializr , preencha os detalhes do projeto, escolha suas opções e baixe um projeto agrupado como um arquivo zip.
O que você construirá
Você construirá um aplicativo da web simples com Spring Boot e adicionará alguns serviços úteis a ele.
O que você precisa
Cerca de 15 minutos
Um editor de texto ou IDE favorito
JDK 1.8 ou posterior
Você também pode importar o código diretamente para o seu IDE:
Para começar do zero , vá para Iniciando com Spring Initializr .
Para pular o básico , faça o seguinte:
Baixe e descompacte o repositório de origem deste guia ou clone-o usando Git :
git clone https://github.com/spring-guides/gs-spring-boot.gitcd em
gs-spring-boot/initialAvance para Criar um Aplicativo da Web Simples .
Ao terminar , você pode comparar seus resultados com o código em gs-spring-boot/complete.
Aprenda o que você pode fazer com Spring Boot
Spring Boot oferece uma maneira rápida de criar aplicativos. Ele examina seu caminho de classe e os beans que você configurou, faz suposições razoáveis sobre o que está faltando e adiciona esses itens. Com o Spring Boot, você pode se concentrar mais nos recursos de negócios e menos na infraestrutura.
Os exemplos a seguir mostram o que Spring Boot pode fazer por você:
O Spring MVC está no caminho de classe? Existem vários beans específicos de que você quase sempre precisa, e o Spring Boot os adiciona automaticamente. Um aplicativo Spring MVC também precisa de um contêiner de servlet, portanto, o Spring Boot configura automaticamente o Tomcat integrado.
O Jetty está no caminho de classe? Em caso afirmativo, você provavelmente NÃO quer o Tomcat, mas sim o Jetty incorporado. Spring Boot cuida disso para você.
O Thymeleaf está no caminho de classe? Nesse caso, há alguns beans que sempre devem ser adicionados ao contexto do seu aplicativo. Spring Boot os adiciona para você.
Estes são apenas alguns exemplos da configuração automática que o Spring Boot fornece. Ao mesmo tempo, o Spring Boot não atrapalha. Por exemplo, se Thymeleaf estiver em seu caminho, Spring Boot adiciona automaticamente um SpringTemplateEngineao contexto de seu aplicativo. Mas se você definir seu próprio SpringTemplateEnginecom suas próprias configurações, Spring Boot não adiciona um. Isso deixa você no controle com pouco esforço de sua parte.
| Spring Boot não gera código ou faz edições em seus arquivos. Em vez disso, quando você inicia seu aplicativo, o Spring Boot liga dinamicamente os beans e as configurações e os aplica ao contexto do aplicativo. |
Começando com Spring Initializr
Se você usa o Maven, visite o Spring Initializr para gerar um novo projeto com as dependências necessárias (Spring Web).
A lista a seguir mostra o pom.xmlarquivo que é criado quando você escolhe o Maven:
<?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.4.4</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<groupId>com.example</groupId>
<artifactId>spring-boot</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>spring-boot</name>
<description>Demo project for Spring Boot</description>
<properties>
<java.version>1.8</java.version>
</properties>
<dependencies>
<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>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>Se você usa o Gradle, visite o Spring Initializr para gerar um novo projeto com as dependências necessárias (Spring Web).
A lista a seguir mostra o build.gradlearquivo criado quando você escolhe o Gradle:
plugins {
id 'org.springframework.boot' version '2.4.4'
id 'io.spring.dependency-management' version '1.0.11.RELEASE'
id 'java'
}
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = '1.8'
repositories {
mavenCentral()
}
dependencies {
implementation 'org.springframework.boot:spring-boot-starter-web'
testImplementation 'org.springframework.boot:spring-boot-starter-test'
}
test {
useJUnitPlatform()
}Inicialização manual (opcional)
Se você deseja inicializar o projeto manualmente em vez de usar os links mostrados anteriormente, siga as etapas abaixo:
Navegue até https://start.spring.io . Este serviço extrai todas as dependências de que você precisa para um aplicativo e faz a maior parte da configuração para você.
Escolha Gradle ou Maven e o idioma que deseja usar. Este guia presume que você escolheu Java.
Clique em Dependências e selecione Spring Web .
Clique em Gerar .
Baixe o arquivo ZIP resultante, que é um arquivo de um aplicativo da web configurado com suas escolhas.
| Se o seu IDE possui a integração Spring Initializr, você pode concluir este processo a partir do seu IDE. |
Crie um aplicativo da web simples
Agora você pode criar um controlador da web para um aplicativo da web simples, como src/main/java/com/example/springboot/HelloController.javamostra a seguinte lista (de ):
package com.example.springboot;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
@RestController
public class HelloController {
@RequestMapping("/")
public String index() {
return "Greetings from Spring Boot!";
}
}A classe é sinalizada como um @RestController, o que significa que está pronta para uso pelo Spring MVC para lidar com solicitações da web. @RequestMappingmapas /para o index()método. Quando chamado de um navegador ou usando curl na linha de comando, o método retorna texto puro. Isso ocorre porque @RestControllercombina @Controllere @ResponseBody, duas anotações que resultam em solicitações da web que retornam dados em vez de uma visualização.
Crie uma classe de aplicativo
O Spring Initializr cria uma classe de aplicativo simples para você. No entanto, neste caso, é muito simples. Você precisa modificar a classe do aplicativo para corresponder à seguinte listagem (de src/main/java/com/example/springboot/Application.java):
package com.example.springboot;
import java.util.Arrays;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
@SpringBootApplication
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
@Bean
public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
return args -> {
System.out.println("Let's inspect the beans provided by Spring Boot:");
String[] beanNames = ctx.getBeanDefinitionNames();
Arrays.sort(beanNames);
for (String beanName : beanNames) {
System.out.println(beanName);
}
};
}
}@SpringBootApplication é uma anotação de conveniência que adiciona todos os seguintes:
@Configuration: Marca a classe como uma fonte de definições de bean para o contexto do aplicativo.@EnableAutoConfiguration: Diz ao Spring Boot para começar a adicionar beans com base nas configurações de classpath, outros beans e várias configurações de propriedade. Por exemplo, sespring-webmvcestiver no caminho de classe, essa anotação sinaliza o aplicativo como um aplicativo da web e ativa comportamentos-chave, como configurar umDispatcherServlet.@ComponentScan: Diz ao Spring para procurar outros componentes, configurações e serviços nocom/examplepacote, permitindo que ele encontre os controladores.
O main()método usa o método Spring Boot SpringApplication.run()para lançar um aplicativo. Você percebeu que não havia uma única linha de XML? Também não há nenhum web.xmlarquivo. Este aplicativo da web é 100% Java puro e você não precisou configurar nenhum encanamento ou infraestrutura.
Também existe um CommandLineRunnermétodo marcado como a @Beane é executado na inicialização. Ele recupera todos os beans que foram criados por seu aplicativo ou que foram adicionados automaticamente pelo Spring Boot. Ele os classifica e imprime.
Execute o aplicativo
Para executar o aplicativo, execute o seguinte comando em uma janela de terminal (no complete) diretório:
./gradlew bootRunSe você usar o Maven, execute o seguinte comando em uma janela de terminal (no complete) diretório:
./mvnw spring-boot: executeVocê deve ver uma saída semelhante a esta:
Let's inspect the beans provided by Spring Boot:
application
beanNameHandlerMapping
defaultServletHandlerMapping
dispatcherServlet
embeddedServletContainerCustomizerBeanPostProcessor
handlerExceptionResolver
helloController
httpRequestHandlerAdapter
messageSource
mvcContentNegotiationManager
mvcConversionService
mvcValidator
org.springframework.boot.autoconfigure.MessageSourceAutoConfiguration
org.springframework.boot.autoconfigure.PropertyPlaceholderAutoConfiguration
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration$DispatcherServletConfiguration
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration$EmbeddedTomcat
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration
org.springframework.boot.context.embedded.properties.ServerProperties
org.springframework.context.annotation.ConfigurationClassPostProcessor.enhancedConfigurationProcessor
org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor
org.springframework.context.annotation.internalAutowiredAnnotationProcessor
org.springframework.context.annotation.internalCommonAnnotationProcessor
org.springframework.context.annotation.internalConfigurationAnnotationProcessor
org.springframework.context.annotation.internalRequiredAnnotationProcessor
org.springframework.web.servlet.config.annotation.DelegatingWebMvcConfiguration
propertySourcesBinder
propertySourcesPlaceholderConfigurer
requestMappingHandlerAdapter
requestMappingHandlerMapping
resourceHandlerMapping
simpleControllerHandlerAdapter
tomcatEmbeddedServletContainerFactory
viewControllerHandlerMappingVocê pode ver claramente os org.springframework.boot.autoconfigurefeijões. Também existe um tomcatEmbeddedServletContainerFactory.
Agora execute o serviço com curl (em uma janela de terminal separada), executando o seguinte comando (mostrado com sua saída):
$ curl localhost:8080
Greetings from Spring Boot!Adicionar testes de unidade
Você desejará adicionar um teste para o endpoint adicionado, e o Spring Test fornece alguns mecanismos para isso.
Se você usa o Gradle, adicione a seguinte dependência ao seu build.gradlearquivo:
testImplementation('org.springframework.boot:spring-boot-starter-test')Se você usa o Maven, adicione o seguinte ao seu pom.xmlarquivo:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>Agora escreva um teste de unidade simples que simule a solicitação e a resposta do servlet por meio de seu endpoint, como src/test/java/com/example/springboot/HelloControllerTest.javamostra a seguinte listagem (de ):
package com.example.springboot;
import static org.hamcrest.Matchers.equalTo;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.content;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;
@SpringBootTest
@AutoConfigureMockMvc
public class HelloControllerTest {
@Autowired
private MockMvc mvc;
@Test
public void getHello() throws Exception {
mvc.perform(MockMvcRequestBuilders.get("/").accept(MediaType.APPLICATION_JSON))
.andExpect(status().isOk())
.andExpect(content().string(equalTo("Greetings from Spring Boot!")));
}
}MockMvcvem do Spring Test e permite que você, por meio de um conjunto de classes de construtor convenientes, envie solicitações HTTP para o DispatcherServlete faça afirmações sobre o resultado. Observe o uso de @AutoConfigureMockMvce @SpringBootTestpara injetar uma MockMvcinstância. Tendo usado @SpringBootTest, estamos pedindo que todo o contexto do aplicativo seja criado. Uma alternativa seria pedir ao Spring Boot para criar apenas as camadas da web do contexto usando @WebMvcTest. Em qualquer um dos casos, o Spring Boot tenta localizar automaticamente a classe de aplicativo principal do seu aplicativo, mas você pode sobrescrevê-la ou restringi-la se quiser construir algo diferente.
Além de simular o ciclo de solicitação HTTP, você também pode usar Spring Boot para escrever um teste simples de integração full-stack. Por exemplo, em vez de (ou também) o teste simulado mostrado anteriormente, poderíamos criar o seguinte teste (de src/test/java/com/example/springboot/HelloControllerIT.java):
package com.example.springboot;
import static org.assertj.core.api.Assertions.*;
import java.net.URL;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.boot.web.server.LocalServerPort;
import org.springframework.http.ResponseEntity;
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT)
public class HelloControllerIT {
@LocalServerPort
private int port;
private URL base;
@Autowired
private TestRestTemplate template;
@BeforeEach
public void setUp() throws Exception {
this.base = new URL("http://localhost:" + port + "/");
}
@Test
public void getHello() throws Exception {
ResponseEntity<String> response = template.getForEntity(base.toString(),
String.class);
assertThat(response.getBody()).isEqualTo("Greetings from Spring Boot!");
}
}O servidor incorporado é iniciado em uma porta aleatória por causa de webEnvironment = SpringBootTest.WebEnvironment.RANDOM_PORT, e a porta real é descoberta em tempo de execução com @LocalServerPort.
Adicionar serviços de nível de produção
Se você estiver construindo um site para sua empresa, provavelmente precisará adicionar alguns serviços de gerenciamento. Spring Boot fornece vários desses serviços (como saúde, auditorias, beans e muito mais) com seu módulo atuador .
Se você usa o Gradle, adicione a seguinte dependência ao seu build.gradlearquivo:
implementation 'org.springframework.boot:spring-boot-starter-actuator'Se você usar o Maven, adicione a seguinte dependência ao seu pom.xmlarquivo:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>Em seguida, reinicie o aplicativo. Se você usar o Gradle, execute o seguinte comando em uma janela de terminal (no completediretório):
./gradlew bootRunSe você usar o Maven, execute o seguinte comando em uma janela de terminal (no completediretório):
./mvnw spring-boot: executeVocê deve ver que um novo conjunto de terminais RESTful foi adicionado ao aplicativo. Esses são serviços de gerenciamento fornecidos pelo Spring Boot. A lista a seguir mostra a saída típica:
management.endpoint.configprops-org.springframework.boot.actuate.autoconfigure.context.properties.ConfigurationPropertiesReportEndpointProperties
management.endpoint.env-org.springframework.boot.actuate.autoconfigure.env.EnvironmentEndpointProperties
management.endpoint.health-org.springframework.boot.actuate.autoconfigure.health.HealthEndpointProperties
management.endpoint.logfile-org.springframework.boot.actuate.autoconfigure.logging.LogFileWebEndpointProperties
management.endpoints.jmx-org.springframework.boot.actuate.autoconfigure.endpoint.jmx.JmxEndpointProperties
management.endpoints.web-org.springframework.boot.actuate.autoconfigure.endpoint.web.WebEndpointProperties
management.endpoints.web.cors-org.springframework.boot.actuate.autoconfigure.endpoint.web.CorsEndpointProperties
management.health.status-org.springframework.boot.actuate.autoconfigure.health.HealthIndicatorProperties
management.info-org.springframework.boot.actuate.autoconfigure.info.InfoContributorProperties
management.metrics-org.springframework.boot.actuate.autoconfigure.metrics.MetricsProperties
management.metrics.export.simple-org.springframework.boot.actuate.autoconfigure.metrics.export.simple.SimpleProperties
management.server-org.springframework.boot.actuate.autoconfigure.web.server.ManagementServerProperties
management.trace.http-org.springframework.boot.actuate.autoconfigure.trace.http.HttpTracePropertiesO atuador expõe o seguinte:
Também existe um /actuator/shutdownponto de extremidade, mas, por padrão, é visível apenas por meio do JMX. Para habilitá-lo como um ponto de extremidade HTTP , adicione management.endpoint.shutdown.enabled=trueao seu application.propertiesarquivo e exponha-o com management.endpoints.web.exposure.include=health,info,shutdown. No entanto, você provavelmente não deve habilitar o endpoint de desligamento para um aplicativo disponível publicamente. |
Você pode verificar a integridade do aplicativo executando o seguinte comando:
$ curl localhost:8080/actuator/health
{"status":"UP"}Você também pode tentar invocar shutdown por meio de curl, para ver o que acontece quando você não adicionou a linha necessária (mostrada na nota anterior) para application.properties:
$ curl -X POST localhost:8080/actuator/shutdown
{"timestamp":1401820343710,"error":"Not Found","status":404,"message":"","path":"/actuator/shutdown"}Como não o ativamos, o ponto de extremidade solicitado não está disponível (porque o ponto de extremidade não existe).
Para obter mais detalhes sobre cada um desses terminais REST e como você pode ajustar suas configurações com um application.propertiesarquivo (in src/main/resources), consulte a documentação sobre os terminais .
O último exemplo mostrou como o Spring Boot permite que você arame beans que você pode não estar ciente de que precisa. Também mostrou como ativar serviços de gerenciamento convenientes.
No entanto, o Spring Boot faz mais do que isso. Ele suporta não apenas implementações de arquivos WAR tradicionais, mas também permite que você crie JARs executáveis, graças ao módulo de carregamento do Spring Boot. Os vários guias demonstram esse suporte duplo por meio do spring-boot-gradle-plugine spring-boot-maven-plugin.
Além disso, o Spring Boot também tem suporte para Groovy, permitindo que você crie aplicativos da web Spring MVC com apenas um único arquivo.
Crie um novo arquivo chamado app.groovye coloque o seguinte código nele:
@RestController
class ThisWillActuallyRun {
@RequestMapping("/")
String home() {
return "Hello, World!"
}
}| Não importa onde o arquivo está. Você pode até colocar um aplicativo tão pequeno dentro de um único tweet ! |
Em seguida, instale a CLI do Spring Boot .
Execute o aplicativo Groovy executando o seguinte comando:
$ spring run app.groovy| Encerre o aplicativo anterior para evitar uma colisão de portas. |
Em uma janela de terminal diferente, execute o seguinte comando curl (mostrado com sua saída):
$ curl localhost:8080
Hello, World!Spring Boot faz isso adicionando dinamicamente anotações de chave ao seu código e usando Groovy Grape para puxar para baixo as bibliotecas que são necessárias para fazer o aplicativo funcionar.
Comentários
Postar um comentário