Conteúdo


Informações básicas sobre o Spring Boot

Comece a usar o Spring Boot para escrever aplicativos Spring que 'simplesmente funcionam'

O Spring Boot é uma estrutura leve que simplifica a configuração de aplicativos baseados em Spring. Neste tutorial, você aprenderá a usar inicializadores, opiniões e a estrutura do arquivo JAR executável do Spring Boot para criar rapidamente aplicativos baseados em Spring que "simplesmente funcionam".

Após uma breve introdução do Spring Boot, mostrarei a você como configurar e executar dois aplicativos Spring Boot: um aplicativo simples do tipo "Hello, World" e um aplicativo de serviços da web Spring MVC RESTful um pouco mais complexo. Observe que uso a versão 1.5.2 do Spring Boot para meus exemplos de aplicativos. Sugiro que você utilize a 1.5.2 ou uma posterior, mas os exemplos devem funcionar para qualquer release após a 1.5.

Pré-requisitos

Para aproveitar o tutorial ao máximo, você deve saber usar o Java™ Development Kit, versão 8 (JDK 8). Também será necessário estar familiarizado com o Eclipse IDE, o Maven e o Git.

Para acompanhar o tutorial, este software deve estar instalado:

Antes de começarmos o tutorial, quero falar um pouco sobre o Spring Boot.

O que é o Spring Boot?

O objetivo do Spring Boot é fornecer um conjunto de ferramentas para a construção rápida de aplicativos Spring que sejam fáceis de configurar.

Existe um problema: a configuração do Spring é complicada!

Se você já escreveu um aplicativo baseado em Spring, sabe que configurá-lo para dizer apenas "Hello, World" envolve muito trabalho. Isso não é ruim: o Spring é um conjunto elegante de estruturas que precisam de uma configuração cuidadosamente coordenada para funcionar corretamente. Mas essa elegância implica em complexidade na configuração (sem falar na grande quantidade de XML).

A solução: Spring Boot

Insira Spring Boot. O O website do Spring Boot explica de forma bastante sucinta:

O Spring Boot facilita a criação de aplicativos baseados em Spring independentes e de nível de produção que "simplesmente funcionam". Nossa perspectiva da plataforma do Spring e das bibliotecas de terceiros é opinativa, para que você possa começar sem preocupações.

Basicamente, isso significa que é possível colocar um aplicativo Spring para funcionar rapidamente com pouquíssima configuração. A pouca configuração envolvida assume a forma de anotações; portanto, não há XML.

Isso parece ótimo, não é? Mas como o Spring Boot funciona exatamente?

Em primeiro lugar, ele é opinativo

O Spring Boot tem opiniões. É outra forma de dizer que o Spring Boot tem padrões razoáveis; assim, é possível desenvolver um aplicativo rapidamente utilizando esses valores usados com frequência.

Por exemplo, o Tomcat é um contêiner da web muito popular. Por padrão, um aplicativo da web Spring Boot usa um contêiner Tomcat integrado.

Em segundo lugar, ele é customizável

Uma estrutura opinativa não será muito boa se não puder mudar de opinião. É possível customizar facilmente um aplicativo Spring Boot conforme suas preferências, tanto na configuração inicial quanto posteriormente, no ciclo de desenvolvimento.

Por exemplo, se você prefere o Maven, pode facilmente fazer alterações de <dependência> no seu arquivo POM para substituir o valor padrão do Spring Boot. Isso será feito mais tarde, no tutorial.

Introdução ao uso do Spring Boot

Inicializadores

Os inicializadores são parte importante da magia do Spring Boot, usados para limitar a quantia de configuração de dependência manual que precisa ser feita. Para utilizar o Spring Boot de forma eficaz, é necessário conhecer os inicializadores.

Um inicializador é, essencialmente, um conjunto de dependências (como um POM Maven) específicas do tipo de aplicativo que o inicializador representa.

Todos os inicializadores usam a convenção de nomenclatura: spring-boot-starter-XYZ, em que XYZ é o tipo de aplicativo que você deseja desenvolver. Estes são alguns inicializadores populares do Spring Boot:

  • spring-boot-starter-web é utilizado para desenvolver serviços da web RESTful usando Spring MVC e Tomcat como contêiner do aplicativo integrado.
  • spring-boot-starter-jersey é uma alternativa ao spring-boot-starter-web que usa o Apache Jersey em vez do Spring MVC.
  • spring-boot-starter-jdbc é utilizado para definição do conjunto de conexões do JDBC. Baseia-se na implementação do conjunto de conexões do JDBC do Tomcat.

A página de referência dos inicializadores do Spring Boot lista muitos outros inicializadores. Acesse-a para ver o POM e as dependências para cada inicializador.

Configuração automática

Se for autorizado, o Spring Boot utilizará sua anotação @EnableAutoConfiguration para configurar seu aplicativo automaticamente. A configuração automática baseia-se nos JARs presentes no seu caminho de classe e em como seus beans foram definidos:

  • O Spring Boot utiliza os JARs cuja presença no CLASSPATH foi especificada para formar uma opinião acerca de como configurar um comportamento automático específico. Por exemplo, se você tem o JAR do banco de dados H2 no seu caminho de classe e não configurou nenhum outro bean DataSource , seu aplicativo será configurado automaticamente com um banco de dados em memória.
  • O Spring Boot usa a maneira como os beans foram definidos para determinar como se configurar automaticamente. Por exemplo, se seus beans JPA forem anotados com @Entity, o Spring Boot configurará o JPA automaticamente para não haver necessidade de um arquivo persistence.xml .

O über jar do Spring Boot

A meta do Spring Boot é ajudar os desenvolvedores a criarem aplicativos que "simplesmente funcionam". Para esse fim, ele empacota o aplicativo e suas dependências em um único JAR executável. Para executar o aplicativo, inicie o Java desta forma:

$ java -jar PATH_TO_EXECUTABLE_JAR/executableJar.jar

O über JAR do Spring Boot não é um conceito novo. Como o Java não oferece uma forma padrão de carregar JARs aninhados, os desenvolvedores utilizam ferramentas como o plug-in do Apache Maven Shade para desenvolver JARs "sombreados" há anos. Um JAR sombreado simplesmente contém os arquivos .class de todos os JARs dependentes do aplicativo. No entanto, à medida que a complexidade do aplicativo cresce e as dependências aumentam, os JARs sombreados podem apresentar dois problemas:

  1. Colisões de nome, em que duas classes de JARs diferentes têm o mesmo nome.
  2. Problemas na versão da dependência, em que dois JARs utilizam versões diferentes da mesma dependência.

Para resolver esses problemas, o Spring Boot define um layout de arquivo JAR especial em que os próprios JARs ficam aninhados dentro do über JAR. O suporte para ferramentas Spring (por exemplo, o plug-in spring-boot-maven ) desenvolve o über JAR executável para seguir esse layout (não apenas desempacotar e reempacotar arquivos .class , como ocorre com um JAR sombreado). Quando o JAR executável é executado, o Spring Boot utiliza um carregador de classe especial para fazer o carregamento das classes dentro dos JARs aninhados.

Diga Hello, World!

Agora, você está pronto para começar a trabalhar diretamente com o Spring Boot. Os exemplos desta seção baseiam-se em um aplicativo simples chamado HelloSpringBoot. Sugiro que você acompanhe o exemplo de desenvolvimento de aplicativo comigo; porém, se quiser começar imediatamente, pode fazer download o código do aplicativo no Github.

Vamos colocar as mãos à obra e criar um novo projeto Maven!

1

Crie o projeto Maven

No Eclipse, acesse File > New project e selecione Maven > Maven Project, como mostrado na Figura 1.

Figura 1. Selecionando um projeto Maven
Captura de tela da caixa de diálogo Novo projeto do Eclipse para selecionar um projeto Maven.
Captura de tela da caixa de diálogo Novo projeto do Eclipse para selecionar um projeto Maven.

Clique em Next; depois, clique em Next novamente na caixa de diálogo seguinte (não mostrada).

Você precisará escolher o arquétipo do seu novo projeto Maven. Selecione maven-archetype-quickstart, conforme mostrado na Figura 2.

Figura 2. Selecionando o arquétipo de iniciação rápida do Maven
Captura de tela da caixa de diálogo do novo projeto para selecionar o arquétipo do início rápido do Maven.
Captura de tela da caixa de diálogo do novo projeto para selecionar o arquétipo do início rápido do Maven.

Clique em Next.

Por fim, acesse as configurações do artefato, como mostrado na Figura 3.

Figura 3. Selecionando as configurações do artefato do Maven
Captura de tela da caixa de diálogo Novo Projeto para selecionar as configurações do arquétipo Maven.
Captura de tela da caixa de diálogo Novo Projeto para selecionar as configurações do arquétipo Maven.

Estou usando as configurações a seguir para o aplicativo HelloSpringBoot:

  • ID do grupo: com.makotojava.learn
  • ID do artefato: HelloSpringBoot
  • Versão: 1.0-SNAPSHOT
  • Pacote: com.makotojava.learn.hellospringboot

Clique em Finish para criar o projeto.

Agora abra App.java no Eclipse e substitua o conteúdo inteiro pelo seguinte:

        package com.makotojava.learn.hellospringboot;

        import java.util.Arrays;

        import org.slf4j.Logger;
        import org.slf4j.LoggerFactory;
        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 App {

          private static final Logger log = LoggerFactory.getLogger(App.class);

          public static void main(String[] args) {
            SpringApplication.run(App.class, args);
          }

          @Bean
          public CommandLineRunner commandLineRunner(ApplicationContext ctx) {
            return args -> {

              log.debug("Let's inspect the beans provided by Spring Boot:");

              String[] beanNames = ctx.getBeanDefinitionNames();
              Arrays.sort(beanNames);
              for (String beanName : beanNames) {
                log.debug(beanName);
              }

            };
          }
        }

A seguir, crie uma nova classe chamada HelloRestController no mesmo pacote que App que seja semelhante a isto:

        package com.makotojava.learn.hellospringboot;

        import org.springframework.web.bind.annotation.RequestMapping;
        import org.springframework.web.bind.annotation.RestController;

        @RestController
        public class HelloRestController {

          @RequestMapping("/hello")
          public String hello() {
            return "Hello. All your base are belong to us.";
          }
        }
2

Crie o POM

Modifique o POM criado pelo assistente New Project para que se pareça com a Listagem 1.

Lista 1. O arquivo POM para HelloSpringBoot
                <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>com.makotojava.learn</groupId>
                    <artifactId>HelloSpringBoot</artifactId>
                    <version>1.0-SNAPSHOT</version>
                    <packaging>jar</packaging>
                    <name>HelloSpringBoot</name>
                    <url>http://maven.apache.org</url>
                    <parent>
                    	<groupId>org.springframework.boot</groupId>
                    	<artifactId>spring-boot-starter-parent</artifactId>
                    	<version>1.5.2.RELEASE</version>
                    </parent>
                    <dependencies>
                    	<dependency>
                    		<groupId>org.springframework.boot</groupId>
                    		<artifactId>spring-boot-starter-web</artifactId>
                    	</dependency>
                    </dependencies>
                    <properties>
                    	<java.version>1.8</java.version>
                    </properties>
                    <build>
                    	<plugins>
                    		<plugin>
                    			<groupId>org.springframework.boot</groupId>
                    			<artifactId>spring-boot-maven-plugin</artifactId>
                    		</plugin>
                    	</plugins>
                    </build>
                </project>

Observe as linhas destacadas na Listagem 1:

As linhas de 10 a 14 mostram o elemento <parent> , que especifica o POM primário do Spring Boot e contém definições para componentes comuns. Não é necessário configurar manualmente.

As linhas 16 a 19 mostram a <dependency> no inicializador spring-boot-starter-web do Spring Boot. Isso informa ao Spring Boot que o aplicativo é um aplicativo da web. O Spring Boot formará suas opiniões adequadamente.

As linhas 25 a 30 instruem o Maven a usar o plug-in spring-boot-maven-plugin para gerar o aplicativo Spring Boot.

Não é configuração demais, certo? Repare que não há XML. Utilizaremos anotações de Java para o restante da configuração.

Mais sobre as opiniões do Spring Boot

Antes de prosseguirmos, quero falar um pouco mais sobre o Spring Boot e suas opiniões. Sobretudo, acho que é importante explicar como o Spring Boot utiliza um inicializador como spring-boot-starter-web para formar suas opiniões sobre configuração.

O aplicativo de exemplo, HelloSpringBoot, usa o inicializador de aplicativo da web do Spring Boot, o spring-boot-starter-web. Com base nesse inicializador, o Spring Boot formou as seguintes opiniões sobre o aplicativo:

  • Contêiner de servidor da web integrado do Tomcat
  • Hibernação para mapeamento de objeto relacional (ORM)
  • Apache Jackson para ligação de JSON
  • Spring MVC para a estrutura REST

Ele tem muitas opiniões! Porém, em defesa do Spring Boot, esses são os padrões mais populares de aplicativos da web—pelo menos, sei que eu os utilizo o tempo todo.

Lembra-se de que eu disse que o Spring Boot é customizável? Para utilizar um grupo de tecnologias diferentes, é possível substituir facilmente os padrões do Spring Boot.

Veremos como funciona uma customização simples em seguida.

Esqueça o <parent>

E se você já tivesse um elemento <parent> no seu POM ou se simplesmente não quisesse utilizá-lo? O Spring Boot ainda funcionará?

Sim, ele funcionará, mas será preciso fazer duas coisas:

  1. Incluir as dependências manualmente (incluindo as versões)
  2. Incluir um fragmento de configuração no spring-boot-maven-plugin, como mostrado na Listagem 2:
    Lista 2. Especificando o objetivo repackage quando o elemento POM <parent> não é utilizado
                	<build>
                		<plugins>
                			<plugin>
                				<groupId>org.springframework.boot</groupId>
                				<artifactId>spring-boot-maven-plugin</artifactId>
                				<version>1.5.2.RELEASE</version>
                				<executions>
                					<execution>
                						<goals>
                							<goal>repackage</goal>
                						</goals>
                					</execution>
                				</executions>
                			</plugin>
                		</plugins>
                	</build>

É importante ressaltar que o elemento <parent> é responsável por grande parte da magia do Maven; se tiver um bom motivo para não usá-lo, prossiga com cuidado. Certifique-se de incluir uma execução de objetivo de reempacotamento no spring-boot-maven-pluginconforme explicado aqui.

O projeto foi configurado e customizado. Agora, é hora de desenvolver o executável.

3

Desenvolva o JAR executável

Há duas opções para desenvolver o JAR executável com o Maven:

  1. Executar a construção do Maven no Eclipse
  2. Executar a construção do Maven na linha de comando

Mostrarei como fazer ambas.

Desenvolva no Eclipse

Para executar a construção do Maven no Eclipse, clique com o botão direito no arquivo POM e escolha Run As > Maven Build. No campo de texto Goals, insira clean e package; depois, clique no botão Run.

Figura 4. Desenvolva o JAR executável no Eclipse
Construa o executável JAR no Eclipse
Construa o executável JAR no Eclipse

A visualização do console deve conter uma mensagem que indica que a construção foi concluída com sucesso:

.
.
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 2.440 s
[INFO] Finished at: 2017-04-16T10:17:21-05:00
[INFO] Final Memory: 30M/331M
[INFO] ------------------------------------------------------------------------

Desenvolva na linha de comando

Para executar a construção do Maven na linha de comando, abra uma janela de terminal do Mac ou um prompt de comando do Windows, navegue até o diretório do projeto HelloSpringBoot e execute o comando:

mvn clean package

A janela do terminal ou prompt de comando deve conter uma mensagem que indica que a construção foi concluída com sucesso.

                $ cd HelloSpringBoot
                $ pwd
                /Users/sperry/home/HelloSpringBoot
                $ mvn clean package
                .
                .
                [INFO] ------------------------------------------------------------------------
                [INFO] BUILD SUCCESS
                [INFO] ------------------------------------------------------------------------
                [INFO] Total time: 2.440 s
                [INFO] Finished at: 2017-04-16T10:17:21-05:00
                [INFO] Final Memory: 30M/331M
                [INFO] ------------------------------------------------------------------------
                $

Agora, você está pronto para rodar o JAR executável.

4

Execute o JAR executável

Para executar o JAR executável que acabou de ser criado, abra uma janela de terminal do Mac ou um prompt de comando do Windows, navegue até a pasta do projeto HelloSpringBoot e execute:

java -jar target/HelloSpringBoot-1.0-SNAPSHOT.jar

em que target é o diretório de saída padrão da construção. Caso tenha configurado de maneira diferente, faça a substituição adequada no comando acima.

A saída do Spring Boot contém uma "tela de abertura" baseada em texto (linhas 2 a 7), juntamente com outra saída, semelhante à listagem abaixo. Mostrei apenas algumas linhas, para dar uma ideia do que você deve ver quando executar o aplicativo:

$ java -jar target/HelloSpringBoot-1.0-SNAPSHOT.jar
  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/
 :: Spring Boot ::        (v1.5.2.RELEASE)
2017-04-15 17:46:12.919  INFO 20096 --- [           main] c.makotojava.learn.hellospringboot.App   : Starting App v1.0-SNAPSHOT on Ix.local with PID 20096 (/Users/sperry/home/projects/learn/HelloSpringBoot/target/HelloSpringBoot-1.0-SNAPSHOT.jar started by sperry in /Users/sperry/home/projects/learn/HelloSpringBoot)
2017-04-15 17:46:12.924 DEBUG 20096 --- [           main] c.makotojava.learn.hellospringboot.App   : Running with Spring Boot v1.5.2.RELEASE, Spring v4.3.7.RELEASE
.
.
2017-04-15 17:46:15.221  INFO 20096 --- [           main] c.makotojava.learn.hellospringboot.App   : Started App in 17.677 seconds (JVM running for 18.555)

Se o aplicativo for iniciado com êxito, a última linha da saída do Spring Boot conterá as palavras "Started App" (linha 13). Agora, você está pronto para usar seu aplicativo, o que fará a seguir.

5

Exercite o aplicativo

Para executar o método REST simples do HelloSpringBoot, abra um navegador e acesse esta URL:

http://localhost:8080/hello
Figura 5. Olá, Spring Boot!
Uma captura de tela do aplicativo da web HelloSpringBoot.
Uma captura de tela do aplicativo da web HelloSpringBoot.

Se vir o texto "Hello, All your base are belong to us" (uma homenagem ao videogame Zero Wing), saberá que o aplicativo funciona!

Mudando as opiniões do Spring Boot

As opiniões do Spring Boot baseiam-se no conteúdo do POM, inclusive no inicializador do Spring Boot especificado quando o aplicativo foi configurado inicialmente. Após formar uma opinião sobre o tipo de aplicativo que você pretende desenvolver, o Spring Boot fornece um conjunto de dependências do Maven. A Figura 4 mostra algumas das dependências do Maven que o Spring Boot definiu no Eclipse, com base no conteúdo do POM e no inicializador especificado para o aplicativo HelloSpringBoot:

Figura 6. Dependências iniciais para HelloSpringBoot
Configuração de dependência padrão para HelloSpringBoot.
Configuração de dependência padrão para HelloSpringBoot.

Observe que o Tomcat é o contêiner de servidor da web integrado padrão. Agora, suponhamos que, em vez do Tomcat, você deseja usar o Jetty. Basta alterar a seção <dependencies> no POM (cole somente as linhas 5 a 15 a partir da Listagem 3 acima da linha 19 a partir de Lista 1):

Lista 3. Alteração no POM para usar Jetty em vez de Tomcat
            	<dependencies>
            		<dependency>
            			<groupId>org.springframework.boot</groupId>
            			<artifactId>spring-boot-starter-web</artifactId>
            			<exclusions>
            				<exclusion>
            					<groupId>org.springframework.boot</groupId>
            					<artifactId>spring-boot-starter-tomcat</artifactId>
            				</exclusion>
            			</exclusions>
            		</dependency>
            		<dependency>
            			<groupId>org.springframework.boot</groupId>
            			<artifactId>spring-boot-starter-jetty</artifactId>
            		</dependency>
            	</dependencies>

Observe, abaixo, que as dependências do Maven para o Tomcat sumiram (graças às linhas 5 a 10 na Listagem 3), substituídas por dependências para o Jetty (linhas 12 a 15).

Figura 7. Dependências customizadas para HelloSpringBoot
Configuração de dependência customizada para o HelloSpringBoot.
Configuração de dependência customizada para o HelloSpringBoot.

Na verdade, as dependências do Jetty são muitas e não caberiam em uma única captura de tela, mas todas estão presentes e as dependências do Tomcat se foram. Experimente e veja você mesmo!

Diga "Olá, Galáxia!"

Exemplos simples são ótimos, mas o Spring Boot pode fazer muito mais! Nesta seção, mostrarei como descobrir do que o Spring Boot é capaz com um aplicativo da web Spring MVC RESTful. A primeira coisa a fazer é estabelecer o novo aplicativo de exemplo, o SpringBootDemo.

SpringBootDemo

O SpringBootDemo é um wrapper do Spring Boot em torno de um aplicativo POJO simples baseado em Spring, que se chama oDoT. (ToDo [tarefas] ao contrário, entendeu?) A ideia é acompanhar o processo de desenvolvimento de um aplicativo mais complexo do que um simples Hello, World. Também ensinarei a agrupar um aplicativo existente com o Spring Boot.

Três coisas precisam ser feitas para configurar e executar o SpringBootDemo:

  1. Obter o código do GitHub.
  2. Desenvolver e executar o JAR executável.
  3. Acessar o aplicativo por meio do SoapUI.

Criei um vídeo para guiar você em cada etapa do processo. Fique à vontade para reproduzi-lo agora.

1

Obtenha o código

Para começar, você precisará clonar dois projetos dos repositórios do GitHub. O primeiro, chamado odotCore, contém a lógica de negócios do aplicativo, que foi escrita como um aplicativo POJO baseado em Spring. O outro, chamado SpringBootDemo, é um wrapper de aplicativo Spring Boot em torno do odotCore.

Para clonar o repositório do odotCore, abra uma janela de terminal do Mac ou um prompt de comando do Windows, navegue até o diretório-raiz em que deseja que o código resida e execute o comando:

git clone https://github.com/makotogo/odotCore

Para clonar o repositório do SpringBootDemo, execute o comando:

git clone https://github.com/makotogo/SpringBootDemo

Observe que os dois projetos são imediatamente subordinados ao diretório-raiz do aplicativo. A seguir, o código será importado para sua área de trabalho.

2

Importe o código para o Eclipse

Acesse File > Import... e escolha Maven > Existing Maven Projects.

Na próxima caixa de diálogo, utilize o botão Browse para navegar até o diretório-raiz. Os dois projetos clonados na etapa anterior devem aparecer na caixa de diálogo, conforme mostrado aqui:

Figura 8. Importe projetos do Maven
Captura de tela da caixa de diálogo: Import Maven Projects.
Captura de tela da caixa de diálogo: Import Maven Projects.

Clique em Finish para importar os projetos para sua área de trabalho do Eclipse. Em seguida, você desenvolverá o JAR executável.

3

Desenvolva o JAR executável

Para desenvolver o SpringBootDemo, é necessário desenvolver os projetos odotCore e SpringBootDemo. É possível desenvolver os projetos na linha de comando, como foi visto com o aplicativo HelloSpringBoot. Neste caso, farei o passo a passo usando o Eclipse.

No Eclipse, clique com o botão direito no projeto odotCore. Escolha Run As > Maven Build e especifique os objetivos clean e install . O objetivo install instalará o arquivo JAR odotCore-1.0-SNAPSHOT.jar no repositório Maven local. Agora, ele estará disponível para coleta como dependência quando a construção Maven do SpringBootDemo for executada.

Após a execução bem-sucedida da construção Maven do odotCore , clique com o botão direito do mouse no projeto SpringBootDemo, escolha Run As > Maven Build e especifique os objetivos clean e pacote .

Após a execução bem-sucedida da construção do SpringBootDemo, é possível executar o über JAR do SpringBootDemo na linha de comando.

4

Execute o JAR executável

Em uma janela de terminal do MAC ou prompt de comando do Windows, navegue até o diretório do SpringBootDemo. Supondo que o diretório de saída da construção se chama target (que é o padrão), execute este comando:

java -jar target/SpringBootDemo-1.0-SNAPSHOT.jar

Agora, veja o Spring Boot executar o aplicativo. Quando o texto "App Started" for exibido, você estará pronto para usar o aplicativo.

5

Exercite o aplicativo

Para testar rapidamente se seu aplicativo está funcionando da maneira correta, abra uma janela do navegador e insira esta URL:

http://localhost:8080/CategoryRestService/FindAll

Ela acessa o método FindAll do CategoryRestService e informa todos os objetos Category no banco de dados no formato JSON.

Figura 9. Acessando o SpringBootDemo por um navegador
Acessando o aplicativo SpringBootDemo através de um navegador.
Acessando o aplicativo SpringBootDemo através de um navegador.

Também é possível usar o aplicativo por meio do SoapUI. Não demonstrarei como fazer isso aqui, mas explico o processo no vídeo associado a este tutorial.

A Tabela 1 mostra os serviços e métodos dentro de cada serviço para o SpringBootDemo.

Tablela 1. Serviços e métodos do oDoT (SpringBootDemo)
ServiçoMétodoMétodo HTTPPor exemplo, URL @ http://localhost:8080
CategoriaFindAllGET/CategoryRestService/FindAllLocaliza todos os objetos da categoria no banco de dados.
CategoriaFindByIdGET/CategoryRestService/FindbyId/1Localiza a categoria pelo valor do ID 1.
CategoriaFindByIdGET/CategoryRestService/FindbyName/MY_CATEGORYLocaliza a categoria pelo valor do nome "MY_CATEGORY".
CategoriaIncluirPUT/CategoryRestService/AddInclui a categoria especificada (como carga útil do JSON no corpo da solicitação) no banco de dados. Gera: objeto da categoria que foi incluído (como JSON no corpo da solicitação).
CategoriaAtualizarPOST/CategoryRestService/UpdateAtualiza a categoria especificada (como carga útil do JSON no corpo da solicitação) no banco de dados. Gera: a mensagem de cadeia de caractere que indica o status da atualização.
CategoriaExcluirDELETE/CategoryRestService/DeleteExclui a categoria especificada (como carga útil do JSON no corpo da solicitação) do banco de dados. Gera: a mensagem de cadeia de caractere que indica o status da exclusão.
ItemFindAllGET/ItemRestService/FindAllLocaliza todos os objetos da categoria no banco de dados.
ItemFindByIdGET/ItemRestService/FindbyId/1Localiza a categoria pelo valor do ID 1.
ItemFindByIdGET/ItemRestService/FindbyName/TODO_ITEM_1Localiza o item pelo nome do valor "TODO_ITEM_1".
ItemIncluirPUT/ItemRestService/AddInclui o item especificado (como carga útil do JSON no corpo da solicitação) no banco de dados. Gera: Objeto do item que foi incluído (como JSON no corpo da resposta).
ItemAtualizarPOST/ItemRestService/UpdateAtualiza o item especificado (como carga útil do JSON no corpo da solicitação) no banco de dados. Gera: a mensagem de cadeia de caractere que indica o status da atualização.
ItemExcluirDELETE/ItemRestService/DeleteExclui o item especificado (como carga útil do JSON no corpo da solicitação) do banco de dados. Gera: a mensagem de cadeia de caractere que indica o status da exclusão.

Sugiro que você estude o código, brinque com ele e entenda melhor como o Spring Boot funciona.

Conclusão

Neste tutorial, apresentei a você os problemas que o Spring Boot resolve e falei um pouco sobre como ele funciona. Depois, expliquei como configurar e executar um aplicativo Spring Boot simples chamado HelloSpringBoot. Por fim, mostrei como desenvolver e usar um aplicativo de serviços da web Spring MVC RESTful usando o Spring Boot.

O que acontece agora?


Recursos para download


Temas relacionados

static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Tecnologia Java, Software livre
ArticleID=1062719
ArticleTitle=Informações básicas sobre o Spring Boot
publish-date=05112017