Devido à configuração de dependência complicada, a configuração do Spring para aplicativos corporativos tornou-se uma tarefa muito tediosa e propensa a erros. Isto é especialmente verdade para aplicativos que também usam várias bibliotecas de terceiros.
Cada vez que você cria outro aplicativo Java corporativo baseado em Spring, precisa repetir as mesmas etapas de rotina para configurá-lo:
- Dependendo do tipo de aplicativo que está sendo criado (Spring MVC, Spring JDBC, Spring ORM, etc.), importe os módulos Spring necessários
- Importar uma biblioteca de contêiner da web (para aplicativos da web)
- Importe as bibliotecas de terceiros necessárias (por exemplo, Hibernate, Jackson), enquanto você deve procurar versões compatíveis com a versão especificada do Spring
- Configure componentes DAO, como: fontes de dados, gerenciamento de transações, etc.
- Configure componentes da camada da web, como: gerenciador de recursos, resolvedor de exibição
- Defina uma classe que carregará todas as configurações necessárias.
1. Apresentando o Spring Boot
Os autores do Spring decidiram fornecer aos desenvolvedores alguns utilitários que automatizam o processo de configuração e aceleram o processo de criação e implantação de aplicativos Spring, coletivamente chamados Spring Boot
O Spring Boot é um projeto útil cujo objetivo é simplificar a criação de aplicativos baseados no Spring. Ele permite que você crie um aplicativo da Web da maneira mais simples, exigindo um esforço mínimo dos desenvolvedores para configurar e escrever código.
2. Recursos do Spring Boot
O Spring Boot tem ótima funcionalidade, mas seus recursos mais significativos são: gerenciamento de dependências, configuração automática e contêineres de servlets internos
2.1 Fácil gerenciamento de dependências
Para acelerar o processo de gerenciamento de dependências, o Spring Boot empacota implicitamente as dependências de terceiros necessárias para cada tipo de aplicativo baseado no Spring e as fornece ao desenvolvedor através dos chamados pacotes iniciais (spring-boot-starter-web, spring-boot-starter-data-jpa, etc.) .d.)
Os pacotes iniciais são um conjunto de descritores de dependência convenientes que você pode incluir em seu aplicativo. Isso fornecerá uma solução universal para todas as tecnologias relacionadas ao Spring, poupando o programador de procurar desnecessariamente exemplos de código e carregando deles os descritores de dependência necessários (um exemplo desses descritores e pacotes iniciais será mostrado abaixo)
Por exemplo, se você deseja começar a usar o Spring Data JPA para acessar o banco de dados, inclua a dependência spring-boot-starter-data-jpa em seu projeto e pronto (você não precisa procurar drivers de banco de dados compatíveis e bibliotecas Hibernate)
Se você deseja criar um aplicativo Web Spring, basta adicionar a dependência spring-boot-starter-web , que puxa para o projeto todas as bibliotecas necessárias para desenvolver aplicativos Spring MVC, como spring-webmvc , jackson-json , validation-api e Tomcat
Em outras palavras, o Spring Boot coleta todas as dependências comuns e as define em um único local, o que permite aos desenvolvedores simplesmente usá-las, em vez de reinventar a roda toda vez que criam um novo aplicativo
Portanto, ao usar o Spring Boot , o arquivo pom.xml contém muito menos linhas do que ao usá-lo nos aplicativos Spring
Consulte a documentação para todos os pacotes iniciantes do Spring Boot.
2.2 Configuração automática
O segundo excelente recurso Spring Boot é a configuração automática de aplicativos
Depois de escolher o pacote inicial apropriado, o Spring Boot tentará configurar automaticamente o aplicativo Spring com base nas dependências do jar que você adicionou
Por exemplo, se você adicionar Spring-boot-starter-web , o Spring Boot configurará automaticamente beans registrados, como DispatcherServlet , ResourceHandlers , MessageSource
Se você usar spring-boot-starter-jdbc , o Spring Boot registrará automaticamente os beans DataSource , EntityManagerFactory , TransactionManager e lerá as informações para conectar-se ao banco de dados a partir do arquivo application.properties
Se você não usar o banco de dados e não fornecer informações detalhadas sobre a conexão no modo manual, o Spring Boot configurará automaticamente o banco de dados na memória, sem nenhuma configuração adicional da sua parte (se você tiver bibliotecas H2 ou HSQL)
A configuração automática pode ser completamente redefinida a qualquer momento com as configurações do usuário
2.3 Suporte nativo para servidor de aplicativos - contêiner de servlet
Cada aplicativo da Web Spring Boot inclui um servidor da Web incorporado. Dê uma olhada na lista de contêineres de servlet que são suportados de imediato.
Os desenvolvedores não precisam mais se preocupar em configurar o contêiner de servlet e implantar o aplicativo nele. Agora, o aplicativo pode iniciar por si só, como um arquivo jar executável usando o servidor embutido
Se você precisar usar um servidor HTTP separado, exclua as dependências padrão para isso. O Spring Boot fornece pacotes iniciais separados para diferentes servidores HTTP
Criar aplicativos Web independentes com servidores incorporados não é apenas conveniente para o desenvolvimento, mas também uma solução aceitável para aplicativos em nível corporativo e está se tornando cada vez mais útil no mundo dos microsserviços. A capacidade de compactar rapidamente um serviço inteiro (como autenticação do usuário) em um artefato independente e totalmente implementável, que também fornece uma API, facilita a instalação e a implantação de aplicativos.
3. Requisitos de instalação do Boot Spring
Para configurar e executar aplicativos Spring Boot, é necessário o seguinte:
4. Criando um aplicativo de inicialização Spring
Agora, vamos praticar e implementar uma API REST muito simples para aceitar pagamentos usando os recursos do Spring Boot
4.1 Criando um projeto da Web usando o Maven
Crie um projeto Maven no IDE que você está usando, chamando-o SpringBootRestService
Certifique-se de usar a versão Java 8+, pois o Spring Boot não funciona com versões anteriores
4.2 Configuração Pom.xml
A segunda etapa é configurar o Spring Boot no arquivo pom.xml
Todos os aplicativos Spring Boot são configurados a partir de spring-boot-starter-parent , portanto, antes de definir melhor as dependências, adicione starter-parent da seguinte maneira:
<parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.1.RELEASE</version> </parent>
Porque Como estamos criando uma API REST, é necessário usar o spring-boot-starter-web como uma dependência, que define implicitamente todas as outras dependências, como spring-core , spring-web , spring-webmvc , servlet api e a biblioteca jackson-databind , portanto basta adicionar o seguinte ao pom.xml:
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency>
Agora, as seguintes bibliotecas jar são importadas automaticamente para o seu projeto:
O próximo passo é adicionar o plugin Spring Boot:
<build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build>
A etapa final é fazer o Maven gerar um arquivo jar executável durante a montagem:
<packaging>jar</packaging>
Abaixo está o arquivo pom.xml completo:
<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>springboot.topjava.ru</groupId> <artifactId>SpringBootRestService</artifactId> <version>1.0</version> <packaging>jar</packaging> <properties> <maven.compiler.source>1.8</maven.compiler.source> <maven.compiler.target>1.8</maven.compiler.target> </properties> <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.1.RELEASE</version> </parent> <dependencies> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> </dependencies> <build> <plugins> <plugin> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-maven-plugin</artifactId> </plugin> </plugins> </build> </project>
Como você pode ver, usando uma dependência, podemos criar um aplicativo Web totalmente funcional
4.3 Criando recursos REST
Agora vamos criar um controlador de pagamento junto com as classes POJO para solicitações e respostas
Vamos escrever a classe da solicitação de pagamento:
package springboot.topjava.ru; public class PaymentRequest { private int userId; private String itemId; private double discount; public String getItemId() { return itemId; } public void setItemId(String itemId) { this.itemId = itemId; } public double getDiscount() { return discount; } public void setDiscount(double discount) { this.discount = discount; } public int getUserId() { return userId; } public void setUserId(int userId) { this.userId = userId; } }
E também uma classe que processa a resposta básica retornada pelo nosso serviço:
package springboot.topjava.ru; public class BaseResponse { private final String status; private final Integer code; public BaseResponse(String status, Integer code) { this.status = status; this.code = code; } public String getStatus() { return status; } public Integer getCode() { return code; } }
Agora crie um controlador:
package springboot.topjava.ru; import org.springframework.web.bind.annotation.*; @RestController @RequestMapping("/payment") public class PaymentController { private final String sharedKey = "SHARED_KEY"; private static final String SUCCESS_STATUS = "success"; private static final String ERROR_STATUS = "error"; private static final int CODE_SUCCESS = 100; private static final int AUTH_FAILURE = 102; @GetMapping public BaseResponse showStatus() { return new BaseResponse(SUCCESS_STATUS, 1); } @PostMapping("/pay") public BaseResponse pay(@RequestParam(value = "key") String key, @RequestBody PaymentRequest request) { final BaseResponse response; if (sharedKey.equalsIgnoreCase(key)) { int userId = request.getUserId(); String itemId = request.getItemId(); double discount = request.getDiscount();
4.4 Criando a classe principal do aplicativo
Esta etapa final é criar uma classe de configuração e iniciar o aplicativo. O Spring Boot suporta a nova anotação @SpringBootApplication , equivalente a usar @Configuration , @EnableAutoConfiguration e @ComponentScan com seus atributos padrão
Portanto, você só precisa criar uma classe anotada com @SpringBootApplication , e o Spring Boot ativará a configuração automática e verificará seus recursos no pacote atual:
package springboot.topjava.ru; import org.springframework.boot.SpringApplication; import org.springframework.boot.autoconfigure.SpringBootApplication; @SpringBootApplication public class Application { public static void main(String[] args) { SpringApplication.run(Application.class, args); } }
5. Implantando o aplicativo de inicialização Spring
Agora vamos aproveitar o terceiro ótimo recurso do Spring Boot - é um servidor incorporado. Tudo o que precisamos fazer é criar um arquivo jar executável usando o Maven e executá-lo como um aplicativo independente normal:
- Entre no modo de linha de comando (comando cmd), vá para a pasta com pom.xml e digite o comando mvn clean package
- O Maven irá gerar um arquivo jar executável chamado SpringBootRestService-1.0.jar
- Vá para a pasta de destino do CD
- Em seguida, execute o arquivo jar: java -jar SpringBootRestService-1.0.jar
- Vá para o navegador em http: // localhost: 8080 / payment
Nossa API REST está em execução e pronta para atender solicitações pela porta 8080 (por padrão)
Neste artigo, analisamos os recursos do Spring Boot e criamos um exemplo completo usando o servidor interno.
Fonte:
https://dzone.com/articles/introducing-spring-boot
- Spring-boot-starter-parent alterou a versão de 1.5.8.RELEASE para 2.1.1.RELEASE e, portanto, a lista de bibliotecas que o Maven abre foi atualizada
- Removidas as declarações do repositório Spring, as dependências são extraídas do repositório central
- Na classe BaseResponse, os campos foram finalizados, adicionaram um construtor e removeram setters
- No PaymentController, introduzimos o método showStatus () com @GetMapping para testar o aplicativo no navegador
- Substituiu @RequestMapping nos métodos por @ GetMapping / @ PostMapping
- Também foram feitas alterações para implantar o aplicativo na linha de comando
ATUALIZAÇÃO:
Como Lure_of_Chaos observou, agora tudo pode ser feito automaticamente através do SPRING INITIALIZR . E sem sair do seu JetBrains IntelliJ IDEA favorito .