Spring Boot - Guia Rápido

Spring Boot é uma estrutura baseada em Java de código aberto usada para criar um microServiço. Ele é desenvolvido pela Pivotal Team e é usado para construir aplicações de mola independentes e prontas para produção. Este capítulo lhe dará uma introdução ao Spring Boot e o familiarizará com seus conceitos básicos.

O que é Micro Service?

Micro Service é uma arquitetura que permite aos desenvolvedores desenvolver e implantar serviços de forma independente. Cada serviço em execução tem seu próprio processo e isso atinge o modelo leve para suportar aplicativos de negócios.

Vantagens

Os microsserviços oferecem as seguintes vantagens para seus desenvolvedores -

• Fácil implantação
• Escalabilidade simples
• Compatível com Containers
• Configuração mínima
• Menor tempo de produção

O que é Spring Boot?

Spring Boot fornece uma boa plataforma para desenvolvedores Java desenvolverem um aplicativo Spring autônomo e de produção que você pode just run. Você pode começar com configurações mínimas sem a necessidade de uma configuração inteira do Spring.

Vantagens

Spring Boot oferece as seguintes vantagens para seus desenvolvedores -

• Fácil de entender e desenvolver aplicações de molas
• Aumenta a produtividade
• Reduz o tempo de desenvolvimento

Metas

Spring Boot é projetado com os seguintes objetivos -

• Para evitar configuração XML complexa no Spring
• Para desenvolver aplicativos Spring prontos para produção de uma maneira mais fácil
• Para reduzir o tempo de desenvolvimento e executar o aplicativo de forma independente
• Oferece uma maneira mais fácil de começar a usar o aplicativo

Por que Spring Boot?

Você pode escolher o Spring Boot por causa dos recursos e benefícios que ele oferece, conforme fornecido aqui -

• Ele fornece uma maneira flexível de configurar Java Beans, configurações XML e transações de banco de dados.

• Ele fornece um processamento em lote poderoso e gerencia terminais REST.

• No Spring Boot, tudo é configurado automaticamente; nenhuma configuração manual é necessária.

• Ele oferece um aplicativo de mola baseado em anotação

• Facilita o gerenciamento de dependências

• Inclui Embedded Servlet Container

Como funciona?

Spring Boot configura automaticamente seu aplicativo com base nas dependências que você adicionou ao projeto usando @EnableAutoConfigurationanotação. Por exemplo, se o banco de dados MySQL estiver em seu caminho de classe, mas você não configurou nenhuma conexão de banco de dados, o Spring Boot configura automaticamente um banco de dados na memória.

O ponto de entrada do aplicativo Spring Boot é a classe contém @SpringBootApplication anotação e o método principal.

Spring Boot verifica automaticamente todos os componentes incluídos no projeto usando @ComponentScan anotação.

Spring Boot Starters

Lidar com o gerenciamento de dependências é uma tarefa difícil para grandes projetos. Spring Boot resolve esse problema fornecendo um conjunto de dependências para conveniência dos desenvolvedores.

Por exemplo, se você deseja usar Spring e JPA para acesso ao banco de dados, é suficiente se você incluir spring-boot-starter-data-jpa dependência em seu projeto.

Observe que todos os iniciadores Spring Boot seguem o mesmo padrão de nomenclatura spring-boot-starter- *, onde * indica que é um tipo de aplicativo.

Exemplos

Veja os seguintes iniciadores do Spring Boot explicados abaixo para uma melhor compreensão -

Spring Boot Starter Actuator dependencyé usado para monitorar e gerenciar seu aplicativo. Seu código é mostrado abaixo -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Spring Boot Starter Security dependencyé usado para Spring Security. Seu código é mostrado abaixo -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Spring Boot Starter web dependencyé usado para escrever um Rest Endpoints. Seu código é mostrado abaixo -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Spring Boot Starter Thyme Leaf dependencyé usado para criar um aplicativo da web. Seu código é mostrado abaixo -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Spring Boot Starter Test dependencyé usado para escrever casos de teste. Seu código é mostrado abaixo -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
</dependency>

Configuração Automática

O Spring Boot Auto Configuration configura automaticamente seu aplicativo Spring com base nas dependências JAR adicionadas ao projeto. Por exemplo, se o banco de dados MySQL estiver em seu caminho de classe, mas você não configurou nenhuma conexão de banco de dados, o Spring Boot configura automaticamente um banco de dados na memória.

Para este propósito, você precisa adicionar @EnableAutoConfiguration anotação ou @SpringBootApplicationanotação em seu arquivo de classe principal. Em seguida, seu aplicativo Spring Boot será configurado automaticamente.

Observe o seguinte código para um melhor entendimento -

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;

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

Aplicativo Spring Boot

O ponto de entrada do aplicativo Spring Boot é a classe que contém @SpringBootApplicationanotação. Esta classe deve ter o método principal para executar o aplicativo Spring Boot.@SpringBootApplication a anotação inclui configuração automática, varredura de componentes e configuração do Spring Boot.

Se você adicionou @SpringBootApplication anotação para a classe, você não precisa adicionar o @EnableAutoConfiguration, @ComponentScan e @SpringBootConfigurationanotação. o@SpringBootApplication a anotação inclui todas as outras anotações.

Observe o seguinte código para um melhor entendimento -

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Varredura de componente

O aplicativo Spring Boot verifica todos os beans e declarações de pacote quando o aplicativo é inicializado. Você precisa adicionar o@ComponentScan anotação para seu arquivo de classe para varrer seus componentes adicionados em seu projeto.

Observe o seguinte código para um melhor entendimento -

import org.springframework.boot.SpringApplication;
import org.springframework.context.annotation.ComponentScan;

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

Este capítulo ensinará a criar um aplicativo Spring Boot usando Maven e Gradle.

Pré-requisitos

Seu sistema precisa ter os seguintes requisitos mínimos para criar um aplicativo Spring Boot -

• Java 7
• Maven 3.2
• Gradle 2.5

Spring Boot CLI

O Spring Boot CLI é uma ferramenta de linha de comando e nos permite executar os scripts do Groovy. Esta é a maneira mais fácil de criar um aplicativo Spring Boot usando a Interface de linha de comando Spring Boot. Você pode criar, executar e testar o aplicativo no próprio prompt de comando.

Esta seção explica as etapas envolvidas na instalação manual do Spring Boot CLI. Para obter mais ajuda, você pode usar o seguinte link:https://docs.spring.io/springboot/ docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-installing-springboot

Você também pode baixar a distribuição Spring CLI do repositório Spring Software em: https://docs.spring.io/spring-boot/docs/current-SNAPSHOT/reference/htmlsingle/#getting-started-manual-cli-installation

Para instalação manual, você precisa usar as duas pastas a seguir -

• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.zip

• spring-boot-cli-2.0.0.BUILD-SNAPSHOT-bin.tar.gz

Após o download, descompacte o arquivo compactado e siga as etapas fornecidas no arquivo install.txt. Não que não exija nenhuma configuração de ambiente.

No Windows, vá para Spring Boot CLI bin diretório no prompt de comando e execute o comando spring –-versionpara ter certeza de que o Spring CLI está instalado corretamente. Depois de executar o comando, você pode ver a versão CLI da primavera conforme mostrado abaixo -

Execute Hello World com Groovy

Crie um arquivo groovy simples que contém o script Rest Endpoint e execute o arquivo groovy com Spring boot CLI. Observe o código mostrado aqui para este propósito -

@Controller
class Example {
   @RequestMapping("/")
   @ResponseBody
   public String hello() {
      "Hello Spring Boot"
   }
}

Agora, salve o arquivo bacana com o nome hello.groovy. Observe que, neste exemplo, salvamos o arquivo bacana dentro do Spring Boot CLIbindiretório. Agora execute o aplicativo usando o comandospring run hello.groovy como mostrado na imagem abaixo -

Depois de executar o arquivo groovy, as dependências necessárias serão baixadas automaticamente e o aplicativo será iniciado na porta Tomcat 8080, conforme mostrado na captura de tela abaixo -

Assim que o Tomcat iniciar, vá para o navegador da web e acesse o URL http://localhost:8080/ e você pode ver a saída conforme mostrado.

Este capítulo irá explicar como executar a inicialização em um aplicativo Spring Boot.

Spring Initializer

Uma das maneiras de inicializar um aplicativo Spring Boot é usando Spring Initializer. Para fazer isso, você terá que visitar a página da web do Spring Initializer www.start.spring.io e escolher sua Build, versão do Spring Boot e plataforma. Além disso, você precisa fornecer um Grupo, Artefato e dependências necessárias para executar o aplicativo.

Observe a imagem a seguir que mostra um exemplo onde adicionamos o spring-boot-starter-web dependência para escrever Endpoints REST.

Depois de fornecer o grupo, artefato, dependências, projeto de construção, plataforma e versão, clique em Generate Projectbotão. O arquivo zip será baixado e os arquivos extraídos.

Esta seção explica os exemplos usando Maven e Gradle.

Maven

Depois de baixar o projeto, descompacte o arquivo. Agora seupom.xml arquivo parece como mostrado abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

Gradle

Depois de baixar o projeto, descompacte o arquivo. Agora seubuild.gradle arquivo parece como mostrado abaixo -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Dependências de caminho de classe

Spring Boot oferece uma série de Starterspara adicionar os jars em nosso caminho de classe. Por exemplo, para escrever um Endpoint Rest, precisamos adicionar ospring-boot-starter-webdependência em nosso caminho de classe. Observe os códigos mostrados abaixo para um melhor entendimento -

Dependência Maven

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

Dependência do Gradle

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Método Principal

O método principal deve ser escrever a classe Spring Boot Application. Esta classe deve ser anotada com@SpringBootApplication. Este é o ponto de entrada do aplicativo Spring Boot para iniciar. Você pode encontrar o arquivo da classe principal emsrc/java/main diretórios com o pacote padrão.

Neste exemplo, o arquivo de classe principal está localizado no src/java/main diretórios com o pacote padrão com.tutorialspoint.demo. Observe o código mostrado aqui para um melhor entendimento -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Escreva um endpoint de descanso

Para escrever um ponto de extremidade Hello World Rest simples no próprio arquivo de classe principal do Spring Boot Application, siga as etapas mostradas abaixo -

• Em primeiro lugar, adicione o @RestController anotação no topo da classe.

• Agora, escreva um método Request URI com @RequestMapping anotação.

• Então, o método Request URI deve retornar o Hello World corda.

Agora, o arquivo principal da classe do aplicativo Spring Boot será semelhante ao mostrado no código abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController

public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

Crie um JAR executável

Vamos criar um arquivo JAR executável para executar o aplicativo Spring Boot usando os comandos Maven e Gradle no prompt de comando, conforme mostrado abaixo -

Use o comando Maven mvn clean install como mostrado abaixo -

Depois de executar o comando, você pode ver o BUILD SUCCESS mensagem no prompt de comando conforme mostrado abaixo -

Use o comando Gradle gradle clean build como mostrado abaixo -

Depois de executar o comando, você pode ver o BUILD SUCCESSFUL mensagem no prompt de comando conforme mostrado abaixo -

Execute Hello World com Java

Depois de criar um arquivo JAR executável, você pode localizá-lo nos seguintes diretórios.

Para Maven, você pode encontrar o arquivo JAR no diretório de destino, conforme mostrado abaixo -

Para Gradle, você pode encontrar o arquivo JAR no build/libs diretório como mostrado abaixo -

Agora, execute o arquivo JAR usando o comando java –jar <JARFILE>. Observe que no exemplo acima, o arquivo JAR é nomeadodemo-0.0.1-SNAPSHOT.jar

Depois de executar o arquivo jar, você pode ver a saída na janela do console, conforme mostrado abaixo -

Agora, olhe para o console, o Tomcat começou na porta 8080 (http). Agora, vá para o navegador da web e acesse o URLhttp://localhost:8080/ e você pode ver a saída conforme mostrado abaixo -

Usando o aplicativo Spring Boot, podemos criar um arquivo war para implantar no servidor web. Neste capítulo, você aprenderá como criar um arquivo WAR e implantar o aplicativo Spring Boot no servidor da web Tomcat.

Spring Boot Servlet Initializer

A maneira tradicional de implantação é tornar o aplicativo Spring Boot @SpringBootApplication classe estender o SpringBootServletInitializerclasse. O arquivo de classe Spring Boot Servlet Initializer permite que você configure o aplicativo quando ele é iniciado usando o Servlet Container.

O código para o arquivo de classe Spring Boot Application para a implantação do arquivo JAR é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Precisamos estender a aula SpringBootServletInitializerpara suportar a implementação do arquivo WAR. O código do arquivo de classe do Spring Boot Application é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;

@SpringBootApplication
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
}

Configurando a classe principal

No Spring Boot, precisamos mencionar a classe principal que deve iniciar no arquivo de construção. Para este propósito, você pode usar os seguintes trechos de código -

Para Maven, adicione a classe inicial em pom.xml propriedades conforme mostrado abaixo -

<start-class>com.tutorialspoint.demo.DemoApplication</start-class>

Para Gradle, adicione o nome da classe principal em build.gradle conforme mostrado abaixo -

mainClassName="com.tutorialspoint.demo.DemoApplication"

Atualizar o pacote JAR para o WAR

Temos que atualizar o pacote JAR no WAR usando os seguintes pedaços de código -

Para Maven, adicione o pacote como WAR em pom.xml como mostrado abaixo -

<packaging>war</packaging>

Para Gradle, adicione o plug-in do aplicativo e o plug-in war no build.gradle como mostrado abaixo -

apply plugin: ‘war’
apply plugin: ‘application’

Agora, vamos escrever um Endpoint de descanso simples para retornar a string “Hello World from Tomcat”. Para escrever um Rest Endpoint, precisamos adicionar a dependência web starter Spring Boot em nosso arquivo de construção.

Para Maven, adicione a dependência inicial do Spring Boot em pom.xml usando o código mostrado abaixo -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Para Gradle, adicione a dependência inicial do Spring Boot em build.gradle usando o código conforme mostrado abaixo -

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Agora, escreva um Rest Endpoint simples no arquivo de classe do Spring Boot Application usando o código mostrado abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

Empacotando seu aplicativo

Agora, crie um arquivo WAR para implantar no servidor Tomcat usando os comandos Maven e Gradle para empacotar seu aplicativo conforme fornecido abaixo -

Para Maven, use o comando mvn packagepara empacotar seu aplicativo. Em seguida, o arquivo WAR será criado e você pode encontrá-lo no diretório de destino, conforme mostrado nas capturas de tela fornecidas abaixo -

Para Gradle, use o comando gradle clean buildpara empacotar seu aplicativo. Então, seu arquivo WAR será criado e você pode encontrá-lo embuild/libsdiretório. Observe as imagens fornecidas aqui para uma melhor compreensão -

Implantar no Tomcat

Agora, execute o servidor Tomcat e implante o arquivo WAR no webappsdiretório. Observe as capturas de tela mostradas aqui para uma melhor compreensão -

Após a implantação bem-sucedida, acesse a URL em seu navegador da web http://localhost:8080/demo-0.0.1-SNAPSHOT/ e observe que a saída ficará como mostrado na captura de tela fornecida abaixo -

O código completo para esse propósito é fornecido abaixo.

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>

   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>war</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <start-class>com.tutorialspoint.demo.DemoApplication</start-class>
   </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>

build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'war'
apply plugin: 'application'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
mainClassName = "com.tutorialspoint.demo.DemoApplication"

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

O código para o arquivo de classe do aplicativo Spring Boot principal é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.web.servlet.support.SpringBootServletInitializer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication  extends SpringBootServletInitializer {
   @Override
   protected SpringApplicationBuilder configure(SpringApplicationBuilder application) {
      return application.sources(DemoApplication.class);
   }
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World from Tomcat";
   }
}

No Spring Boot, escolher um sistema de construção é uma tarefa importante. Recomendamos Maven ou Gradle, pois eles fornecem um bom suporte para gerenciamento de dependências. O Spring não suporta bem outros sistemas de construção.

Gestão de Dependências

A equipe do Spring Boot fornece uma lista de dependências para suportar a versão do Spring Boot para cada lançamento. Você não precisa fornecer uma versão para dependências no arquivo de configuração de construção. O Spring Boot configura automaticamente a versão das dependências com base no lançamento. Lembre-se de que ao atualizar a versão do Spring Boot, as dependências também serão atualizadas automaticamente.

Note- Se você deseja especificar a versão para dependência, pode especificá-la em seu arquivo de configuração. No entanto, a equipe do Spring Boot recomenda enfaticamente que não seja necessário especificar a versão para dependência.

Dependência Maven

Para a configuração do Maven, devemos herdar o projeto pai Spring Boot Starter para gerenciar as dependências do Spring Boot Starter. Para isso, simplesmente podemos herdar o pai inicial em nossopom.xml arquivo como mostrado abaixo.

<parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>1.5.8.RELEASE</version>
</parent>

Devemos especificar o número da versão para a dependência do Spring Boot Parent Starter. Então, para outras dependências iniciais, não precisamos especificar o número da versão do Spring Boot. Observe o código fornecido abaixo -

<dependencies>
   <dependency>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-web</artifactId>
   </dependency>
</dependencies>

Dependência do Gradle

Podemos importar as dependências do Spring Boot Starters diretamente para o build.gradleArquivo. Não precisamos da dependência do pai do Spring Boot start, como o Maven para Gradle. Observe o código fornecido abaixo -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

Da mesma forma, no Gradle, não precisamos especificar o número da versão do Spring Boot para dependências. Spring Boot configura automaticamente a dependência com base na versão.

dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
}

Spring Boot não tem nenhum layout de código para trabalhar. No entanto, existem algumas práticas recomendadas que nos ajudarão. Este capítulo fala sobre eles em detalhes.

Pacote padrão

Uma classe que não tem nenhuma declaração de pacote é considerada como um default package. Observe que geralmente uma declaração de pacote padrão não é recomendada. Spring Boot irá causar problemas como mau funcionamento da configuração automática ou varredura de componentes, quando você usa o pacote padrão.

Note- A convenção de nomenclatura recomendada do Java para declaração de pacote é o nome de domínio invertido. Por exemplo -com.tutorialspoint.myproject

Layout Típico

O layout típico do aplicativo Spring Boot é mostrado na imagem abaixo -

O arquivo Application.java deve declarar o método principal junto com @SpringBootApplication. Observe o código fornecido abaixo para um melhor entendimento -

package com.tutorialspoint.myproject;

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);}
}

No Spring Boot, podemos usar o Spring Framework para definir nossos beans e sua injeção de dependência. o@ComponentScan anotação é usada para encontrar beans e o correspondente injetado com @Autowired anotação.

Se você seguiu o layout típico do Spring Boot, não há necessidade de especificar nenhum argumento para @ComponentScananotação. Todos os arquivos de classe de componente são registrados automaticamente com Spring Beans.

O exemplo a seguir fornece uma ideia sobre a fiação automática do objeto Rest Template e a criação de um Bean para o mesmo -

@Bean
public RestTemplate getRestTemplate() {
   return new RestTemplate();
}

O código a seguir mostra o código para o objeto Rest Template com fiação automática e o objeto de criação Bean no arquivo de classe principal do Spring Boot Application -

package com.tutorialspoint.demo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
@Autowired
   RestTemplate restTemplate;
   
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();   
   }
}

As interfaces Application Runner e Command Line Runner permitem que você execute o código após o aplicativo Spring Boot ser iniciado. Você pode usar essas interfaces para realizar qualquer ação imediatamente após o início do aplicativo. Este capítulo fala sobre eles em detalhes.

Application Runner

Application Runner é uma interface usada para executar o código depois que o aplicativo Spring Boot foi iniciado. O exemplo fornecido a seguir mostra como implementar a interface do Application Runner no arquivo de classe principal.

package com.tutorialspoint.demo;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements ApplicationRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      System.out.println("Hello World from Application Runner");
   }
}

Agora, se você observar a janela do console abaixo Hello World from Application Runner, a instrução println é executada após o Tomcat ser iniciado. A captura de tela a seguir é relevante?

Executor de linha de comando

Command Line Runner é uma interface. É usado para executar o código depois que o aplicativo Spring Boot foi iniciado. O exemplo fornecido a seguir mostra como implementar a interface Command Line Runner no arquivo de classe principal.

package com.tutorialspoint.demo;

import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication implements CommandLineRunner {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Override
   public void run(String... arg0) throws Exception {
      System.out.println("Hello world from Command Line Runner");
   }
}

Observe a janela do console abaixo de “Hello world from Command Line Runner”. A instrução println é executada depois que o Tomcat foi iniciado.

As propriedades do aplicativo nos ajudam a trabalhar em diferentes ambientes. Neste capítulo, você aprenderá como configurar e especificar as propriedades para um aplicativo Spring Boot.

Propriedades da linha de comando

O aplicativo Spring Boot converte as propriedades da linha de comando em propriedades Spring Boot Environment. As propriedades da linha de comando têm precedência sobre as outras fontes de propriedade. Por padrão, o Spring Boot usa o número da porta 8080 para iniciar o Tomcat. Vamos aprender como alterar o número da porta usando as propriedades da linha de comando.

Step 1 - Depois de criar um arquivo JAR executável, execute-o usando o comando java –jar <JARFILE>.

Step 2 - Use o comando fornecido na captura de tela abaixo para alterar o número da porta para o aplicativo Spring Boot usando as propriedades da linha de comando.

Note - Você pode fornecer mais de uma propriedade de aplicativo usando o delimitador -.

Arquivo de Propriedades

Os arquivos de propriedades são usados ​​para manter o número 'N' de propriedades em um único arquivo para executar o aplicativo em um ambiente diferente. No Spring Boot, as propriedades são mantidas noapplication.properties arquivo sob o classpath.

O arquivo application.properties está localizado no src/main/resourcesdiretório. O código da amostraapplication.properties arquivo é fornecido abaixo -

server.port = 9090
spring.application.name = demoservice

Observe que, no código mostrado acima, o demoservice do aplicativo Spring Boot começa na porta 9090.

Arquivo YAML

Spring Boot oferece suporte a configurações de propriedades baseadas em YAML para executar o aplicativo. Ao invés deapplication.properties, podemos usar application.ymlArquivo. Este arquivo YAML também deve ser mantido dentro do classpath. A amostraapplication.yml arquivo é fornecido abaixo -

spring:
   application:
      name: demoservice
   server:
port: 9090

Propriedades Externalizadas

Em vez de manter o arquivo de propriedades no caminho de classe, podemos manter as propriedades em locais ou caminhos diferentes. Ao executar o arquivo JAR, podemos especificar o caminho do arquivo de propriedades. Você pode usar o seguinte comando para especificar a localização do arquivo de propriedades ao executar o JAR -

-Dspring.config.location = C:\application.properties

Uso da anotação @Value

A anotação @Value é usada para ler o ambiente ou o valor da propriedade do aplicativo no código Java. A sintaxe para ler o valor da propriedade é mostrada abaixo -

@Value("${property_key_name}")

Veja o seguinte exemplo que mostra a sintaxe para ler o spring.application.name valor da propriedade na variável Java usando a anotação @Value.

@Value("${spring.application.name}")

Observe o código fornecido abaixo para um melhor entendimento -

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
   @Value("${spring.application.name}")
   private String name;
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String name() {
      return name;
   }
}

Note - Se a propriedade não for encontrada durante a execução do aplicativo, Spring Boot lança a exceção de argumento ilegal como Could not resolve placeholder 'spring.application.name' in value "${spring.application.name}".

Para resolver o problema do espaço reservado, podemos definir o valor padrão para a propriedade usando a sintaxe fornecida abaixo -

@Value("${property_key_name:default_value}")

@Value("${spring.application.name:demoservice}")

Perfil ativo do Spring Boot

Spring Boot oferece suporte a diferentes propriedades com base no perfil ativo Spring. Por exemplo, podemos manter dois arquivos separados para desenvolvimento e produção para executar o aplicativo Spring Boot.

Perfil ativo do Spring em application.properties

Vamos entender como ter o perfil ativo do Spring em application.properties. Por padrão, aplicativo. propriedades serão usadas para executar o aplicativo Spring Boot. Se você quiser usar propriedades baseadas em perfil, podemos manter arquivos de propriedades separados para cada perfil, conforme mostrado abaixo -

application.properties

server.port = 8080
spring.application.name = demoservice

application-dev.properties

server.port = 9090
spring.application.name = demoservice

application-prod.properties

server.port = 4431
spring.application.name = demoservice

Ao executar o arquivo JAR, precisamos especificar o perfil ativo da mola com base em cada arquivo de propriedades. Por padrão, o aplicativo Spring Boot usa o arquivo application.properties. O comando para definir o perfil ativo da mola é mostrado abaixo -

Você pode ver o nome do perfil ativo no log do console, conforme mostrado abaixo -

2017-11-26 08:13:16.322  INFO 14028 --- [           
   main] com.tutorialspoint.demo.DemoApplication  :
   The following profiles are active: dev

Agora, o Tomcat foi iniciado na porta 9090 (http) conforme mostrado abaixo -

2017-11-26 08:13:20.185  INFO 14028 --- [           
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 9090 (http)

Você pode definir o perfil ativo de produção conforme mostrado abaixo -

Você pode ver o nome do perfil ativo no log do console, conforme mostrado abaixo -

2017-11-26 08:13:16.322  INFO 14028 --- [           
   main] com.tutorialspoint.demo.DemoApplication  :
   The following profiles are active: prod

Agora, o Tomcat começou na porta 4431 (http) conforme mostrado abaixo -

2017-11-26 08:13:20.185  INFO 14028 --- [          
   main] s.b.c.e.t.TomcatEmbeddedServletContainer :
   Tomcat started on port(s): 4431 (http)

Perfil ativo Spring para application.yml

Vamos entender como manter o perfil ativo do Spring para application.yml. Podemos manter as propriedades do perfil ativo do Spring no únicoapplication.ymlArquivo. Não há necessidade de usar o arquivo separado, como application.properties.

A seguir está um exemplo de código para manter os perfis ativos do Spring no arquivo application.yml. Observe que o delimitador (---) é usado para separar cada perfil no arquivo application.yml.

spring:
   application:
      name: demoservice
server:
   port: 8080

---
spring:
   profiles: dev
   application:
      name: demoservice
server:
   port: 9090

---
spring: 
   profiles: prod
   application:
      name: demoservice
server: 
   port: 4431

O comando para definir o perfil ativo de desenvolvimento é fornecido abaixo -

Você pode ver o nome do perfil ativo no log do console, conforme mostrado abaixo -

2017-11-26 08:41:37.202  INFO 14104 --- [           
   main] com.tutorialspoint.demo.DemoApplication  : 
   The following profiles are active: dev

Agora, o Tomcat começou na porta 9090 (http) conforme mostrado abaixo -

2017-11-26 08:41:46.650  INFO 14104 --- [           
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 9090 (http)

O comando para definir o perfil ativo de produção é fornecido abaixo -

Você pode ver o nome do perfil ativo no log do console, conforme mostrado abaixo -

2017-11-26 08:43:10.743  INFO 13400 --- [    
   main] com.tutorialspoint.demo.DemoApplication  : 
   The following profiles are active: prod

Isso iniciará o Tomcat na porta 4431 (http) conforme mostrado abaixo:

2017-11-26 08:43:14.473  INFO 13400 --- [     
   main] s.b.c.e.t.TomcatEmbeddedServletContainer : 
   Tomcat started on port(s): 4431 (http)

Spring Boot usa o registro do Apache Commons para todos os registros internos. As configurações padrão do Spring Boot fornecem suporte para o uso de Java Util Logging, Log4j2 e Logback. Usando isso, podemos configurar o registro do console, bem como o registro do arquivo.

Se você estiver usando Spring Boot Starters, o Logback fornecerá um bom suporte para registro. Além disso, o Logback também fornece um bom suporte para Common Logging, Util Logging, Log4J e SLF4J.

Formato de Log

O formato padrão do Spring Boot Log é mostrado na captura de tela abaixo.

que fornece as seguintes informações -

• Date e Time que dá a data e hora do registro

• Log level mostra INFO, ERROR ou WARN

• Process ID

• O --- que é um separador

• Thread name está entre colchetes []

• Logger Name que mostra o nome da classe de origem

• A mensagem de registro

Saída de log do console

As mensagens de log padrão serão impressas na janela do console. Por padrão, as mensagens de log “INFO”, “ERROR” e “WARN” serão impressas no arquivo de log.

Se você tiver que habilitar o log de nível de depuração, adicione o sinalizador de depuração ao iniciar seu aplicativo usando o comando mostrado abaixo -

java –jar demo.jar --debug

Você também pode adicionar o modo de depuração ao seu arquivo application.properties conforme mostrado aqui -

debug = true

Saída de log de arquivo

Por padrão, todos os logs serão impressos na janela do console e não nos arquivos. Se você deseja imprimir os logs em um arquivo, você precisa definir a propriedadelogging.file ou logging.path no arquivo application.properties.

Você pode especificar o caminho do arquivo de log usando a propriedade mostrada abaixo. Observe que o nome do arquivo de log é spring.log.

logging.path = /var/tmp/

Você pode especificar o próprio nome do arquivo de log usando a propriedade mostrada abaixo -

logging.file = /var/tmp/mylog.log

Note - os arquivos irão girar automaticamente após atingir o tamanho de 10 MB.

Níveis de registro

Spring Boot suporta todos os níveis de logger, como “TRACE”, “DEBUG”, “INFO”, “WARN”, “ERROR”, “FATAL”, “OFF”. Você pode definir o logger Root no arquivo application.properties conforme mostrado abaixo -

logging.level.root = WARN

Note- Logback não suporta log de nível “FATAL”. Ele é mapeado para o registro de nível “ERROR”.

Configurar Logback

O Logback oferece suporte à configuração baseada em XML para lidar com as configurações do Spring Boot Log. Os detalhes de configuração de registro são configurados emlogback.xmlArquivo. O arquivo logback.xml deve ser colocado no classpath.

Você pode configurar o log do nível ROOT no arquivo Logback.xml usando o código fornecido abaixo -

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <root level = "INFO">
   </root>
</configuration>

Você pode configurar o appender do console no arquivo Logback.xml fornecido a seguir.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender"></appender>
   <root level = "INFO">
      <appender-ref ref = "STDOUT"/> 
   </root>
</configuration>

Você pode configurar o anexador de arquivo no arquivo Logback.xml usando o código fornecido a seguir. Observe que você precisa especificar o caminho do arquivo de log dentro do anexador de arquivo.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
      <File>/var/tmp/mylog.log</File>
   </appender>   
   <root level = "INFO">
      <appender-ref ref = "FILE"/>
   </root>
</configuration>

Você pode definir o padrão de Log em logback.xmlarquivo usando o código fornecido abaixo. Você também pode definir o conjunto de padrões de log suportados dentro do console ou anexador de log de arquivo usando o código fornecido abaixo -

<pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>

O código para o arquivo logback.xml completo é fornecido abaixo. Você deve colocar isso no caminho da classe.

<?xml version = "1.0" encoding = "UTF-8"?>
<configuration>
   <appender name = "STDOUT" class = "ch.qos.logback.core.ConsoleAppender">
      <encoder>
         <pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
      </encoder>
   </appender>
   
   <appender name = "FILE" class = "ch.qos.logback.core.FileAppender">
      <File>/var/tmp/mylog.log</File>
      <encoder>
         <pattern>[%d{yyyy-MM-dd'T'HH:mm:ss.sss'Z'}] [%C] [%t] [%L] [%-5p] %m%n</pattern>
      </encoder>
   </appender>
   
   <root level = "INFO">
      <appender-ref ref = "FILE"/>
      <appender-ref ref = "STDOUT"/> 
   </root>
</configuration>

O código fornecido a seguir mostra como adicionar o logger slf4j no arquivo de classe principal do Spring Boot.

package com.tutorialspoint.demo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class DemoApplication {
   private static final Logger logger = LoggerFactory.getLogger(DemoApplication.class);
   
   public static void main(String[] args) {
      logger.info("this is a info message");
      logger.warn("this is a warn message");
      logger.error("this is a error message");
      SpringApplication.run(DemoApplication.class, args);
   }
}

A saída que você pode ver na janela do console é mostrada aqui -

A saída que você pode ver no arquivo de log é mostrada aqui -

Spring Boot fornece um suporte muito bom para a construção de RESTful Web Services para aplicativos corporativos. Este capítulo irá explicar em detalhes sobre a construção de serviços da Web RESTful usando Spring Boot.

Note - Para construir um RESTful Web Services, precisamos adicionar a dependência Spring Boot Starter Web ao arquivo de configuração de construção.

Se você for um usuário Maven, use o seguinte código para adicionar a dependência abaixo em seu pom.xml arquivo -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>    
</dependency>

Se você for um usuário Gradle, use o código a seguir para adicionar a dependência abaixo em seu build.gradle Arquivo.

compile('org.springframework.boot:spring-boot-starter-web')

O código para o arquivo de configuração de compilação completo Maven build – pom.xml é dado abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>
   
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

O código para o arquivo de configuração de compilação completo Gradle Build – build.gradle é dado abaixo -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Antes de prosseguir com a construção de um serviço da web RESTful, sugere-se que você tenha conhecimento das seguintes anotações -

Controlador de descanso

A anotação @RestController é usada para definir os serviços da web RESTful. Ele serve JSON, XML e resposta personalizada. Sua sintaxe é mostrada abaixo -

@RestController
public class ProductServiceController { 
}

Solicitar Mapeamento

A anotação @RequestMapping é usada para definir o URI de solicitação para acessar os terminais REST. Podemos definir o método Request para consumir e produzir objeto. O método de solicitação padrão é GET.

@RequestMapping(value = "/products")
public ResponseEntity<Object> getProducts() { }

Corpo de Solicitação

A anotação @RequestBody é usada para definir o tipo de conteúdo do corpo da solicitação.

public ResponseEntity<Object> createProduct(@RequestBody Product product) {
}

Variável de Caminho

A anotação @PathVariable é usada para definir o URI de solicitação personalizado ou dinâmico. A variável Path no URI de solicitação é definida como chaves {} conforme mostrado abaixo -

public ResponseEntity<Object> updateProduct(@PathVariable("id") String id) {
}

Parâmetro de solicitação

A anotação @RequestParam é usada para ler os parâmetros de solicitação da URL de solicitação. Por padrão, é um parâmetro obrigatório. Também podemos definir o valor padrão para os parâmetros de solicitação, conforme mostrado aqui -

public ResponseEntity<Object> getProduct(
   @RequestParam(value = "name", required = false, defaultValue = "honey") String name) {
}

API GET

O método de solicitação HTTP padrão é GET. Este método não requer nenhum corpo de solicitação. Você pode enviar parâmetros de solicitação e variáveis ​​de caminho para definir o URL personalizado ou dinâmico.

O código de amostra para definir o método de solicitação HTTP GET é mostrado abaixo. Neste exemplo, usamos HashMap para armazenar o produto. Observe que usamos uma classe POJO como o produto a ser armazenado.

Aqui, o URI do pedido é /productse ele retornará a lista de produtos do repositório HashMap. O arquivo de classe do controlador é fornecido a seguir e contém o método GET REST Endpoint.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

POST API

A solicitação HTTP POST é usada para criar um recurso. Este método contém o corpo da solicitação. Podemos enviar parâmetros de solicitação e variáveis ​​de caminho para definir o URL personalizado ou dinâmico.

O exemplo a seguir mostra o código de amostra para definir o método de solicitação HTTP POST. Neste exemplo, usamos HashMap para armazenar o Produto, onde o produto é uma classe POJO.

Aqui, o URI do pedido é /products, e ele retornará a String após armazenar o produto no repositório HashMap.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

PUT API

A solicitação HTTP PUT é usada para atualizar o recurso existente. Este método contém um corpo de solicitação. Podemos enviar parâmetros de solicitação e variáveis ​​de caminho para definir o URL personalizado ou dinâmico.

O exemplo fornecido a seguir mostra como definir o método de solicitação HTTP PUT. Neste exemplo, usamos o HashMap para atualizar o Produto existente, onde o produto é uma classe POJO.

Aqui, o URI do pedido é /products/{id}que retornará a String após o produto em um repositório HashMap. Observe que usamos a variável Path{id} que define o ID do produto que precisa ser atualizado.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }   
}

DELETE API

A solicitação HTTP Delete é usada para excluir o recurso existente. Este método não contém nenhum corpo de solicitação. Podemos enviar parâmetros de solicitação e variáveis ​​de caminho para definir o URL personalizado ou dinâmico.

O exemplo fornecido a seguir mostra como definir o método de solicitação HTTP DELETE. Neste exemplo, usamos o HashMap para remover o produto existente, que é uma classe POJO.

O URI do pedido é /products/{id}e ele retornará a String após excluir o produto do repositório HashMap. Usamos a variável Path{id} que define o ID do produto que precisa ser excluído.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
}

Esta seção fornece o conjunto completo de código-fonte. Observe os seguintes códigos para suas respectivas funcionalidades -

The Spring Boot main application class – DemoApplication.java

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

The POJO class – Product.java

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

The Rest Controller class – ProductServiceController.java

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) { 
      productRepo.remove(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productRepo.put(product.getId(), product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
   
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle abaixo, conforme mostrado -

Para Maven, use o comando mostrado abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando mostrado abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Você pode executar o arquivo JAR usando o comando mostrado abaixo -

java –jar <JARFILE>

Isso iniciará o aplicativo na porta 8080 do Tomcat, conforme mostrado abaixo -

Agora acesse a URL mostrada abaixo no aplicativo POSTMAN e veja a saída.

O URL da API GET é: http://localhost:8080/products

O URL da POST API é: http://localhost:8080/products

O URL PUT API é: http://localhost:8080/products/3

O URL da DELETE API é: http://localhost:8080/products/3

Lidar com exceções e erros em APIs e enviar a resposta adequada ao cliente é bom para aplicativos corporativos. Neste capítulo, aprenderemos como lidar com exceções no Spring Boot.

Antes de prosseguir com o tratamento de exceções, vamos entender as anotações a seguir.

Conselhos do controlador

O @ControllerAdvice é uma anotação, para tratar as exceções globalmente.

Manipulador de exceções

O @ExceptionHandler é uma anotação usada para tratar as exceções específicas e enviar as respostas personalizadas ao cliente.

Você pode usar o seguinte código para criar a classe @ControllerAdvice para lidar com as exceções globalmente -

package com.tutorialspoint.demo.exception;

import org.springframework.web.bind.annotation.ControllerAdvice;

@ControllerAdvice
   public class ProductExceptionController {
}

Defina uma classe que estenda a classe RuntimeException.

package com.tutorialspoint.demo.exception;

public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

Você pode definir o método @ExceptionHandler para tratar as exceções conforme mostrado. Este método deve ser usado para escrever o arquivo de classe Controller Advice.

@ExceptionHandler(value = ProductNotfoundException.class)

public ResponseEntity<Object> exception(ProductNotfoundException exception) {
}

Agora, use o código fornecido a seguir para lançar a exceção da API.

@RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
public ResponseEntity<Object> updateProduct() { 
   throw new ProductNotfoundException();
}

O código completo para lidar com a exceção é fornecido abaixo. Neste exemplo, usamos a API PUT para atualizar o produto. Aqui, ao atualizar o produto, se o produto não for encontrado, retorne a mensagem de erro de resposta como “Produto não encontrado”. Observe que oProductNotFoundException classe de exceção deve estender o RuntimeException.

package com.tutorialspoint.demo.exception;
public class ProductNotfoundException extends RuntimeException {
   private static final long serialVersionUID = 1L;
}

A classe Controller Advice para tratar a exceção globalmente é fornecida abaixo. Podemos definir qualquer método do Exception Handler neste arquivo de classe.

package com.tutorialspoint.demo.exception;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;

@ControllerAdvice
public class ProductExceptionController {
   @ExceptionHandler(value = ProductNotfoundException.class)
   public ResponseEntity<Object> exception(ProductNotfoundException exception) {
      return new ResponseEntity<>("Product not found", HttpStatus.NOT_FOUND);
   }
}

O arquivo controlador da API de serviço do produto é fornecido abaixo para atualizar o produto. Se o produto não for encontrado, ele lança oProductNotFoundException classe.

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);
      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> updateProduct(@PathVariable("id") String id, @RequestBody Product product) { 
      if(!productRepo.containsKey(id))throw new ProductNotfoundException();
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
      return new ResponseEntity<>("Product is updated successfully", HttpStatus.OK);
   }
}

O código para o arquivo de classe do aplicativo Spring Boot principal é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O código para POJO class para o produto é fornecido abaixo -

package com.tutorialspoint.demo.model;
public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

O código para Maven build – pom.xml é mostrado abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

O código para Gradle Build – build.gradle é dado abaixo -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle -

Para Maven, você pode usar o seguinte comando -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o seguinte comando -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Você pode executar o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Isso iniciará o aplicativo na porta 8080 do Tomcat, conforme mostrado abaixo -

Agora acesse a URL abaixo no aplicativo POSTMAN e você pode ver a saída conforme mostrado abaixo -

URL de atualização: http: // localhost: 8080 / products / 3

Você pode usar o Interceptor no Spring Boot para realizar operações nas seguintes situações -

• Antes de enviar a solicitação ao controlador

• Antes de enviar a resposta ao cliente

Por exemplo, você pode usar um interceptor para adicionar o cabeçalho da solicitação antes de enviar a solicitação ao controlador e adicionar o cabeçalho da resposta antes de enviar a resposta ao cliente.

Para trabalhar com o interceptor, você precisa criar @Component classe que o suporta e deve implementar o HandlerInterceptor interface.

A seguir estão os três métodos que você deve conhecer ao trabalhar em Interceptores -

• preHandle()método - usado para realizar operações antes de enviar a solicitação ao controlador. Este método deve retornar true para retornar a resposta ao cliente.

• postHandle() método - usado para realizar operações antes de enviar a resposta ao cliente.

• afterCompletion() método - usado para realizar operações após concluir a solicitação e a resposta.

Observe o seguinte código para um melhor entendimento -

@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle(
      HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
      
      return true;
   }
   @Override
   public void postHandle(
      HttpServletRequest request, HttpServletResponse response, Object handler, 
      ModelAndView modelAndView) throws Exception {}
   
   @Override
   public void afterCompletion(HttpServletRequest request, HttpServletResponse response, 
      Object handler, Exception exception) throws Exception {}
}

Você terá que registrar este Interceptor com InterceptorRegistry usando WebMvcConfigurerAdapter como mostrado abaixo -

@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
   @Autowired
   ProductServiceInterceptor productServiceInterceptor;

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(productServiceInterceptor);
   }
}

No exemplo abaixo, vamos acessar a API de produtos GET, que fornece a saída conforme fornecida em -

O código para a classe Interceptor ProductServiceInterceptor.java é fornecido abaixo -

package com.tutorialspoint.demo.interceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

@Component
public class ProductServiceInterceptor implements HandlerInterceptor {
   @Override
   public boolean preHandle
      (HttpServletRequest request, HttpServletResponse response, Object handler) 
      throws Exception {
      
      System.out.println("Pre Handle method is Calling");
      return true;
   }
   @Override
   public void postHandle(HttpServletRequest request, HttpServletResponse response, 
      Object handler, ModelAndView modelAndView) throws Exception {
      
      System.out.println("Post Handle method is Calling");
   }
   @Override
   public void afterCompletion
      (HttpServletRequest request, HttpServletResponse response, Object 
      handler, Exception exception) throws Exception {
      
      System.out.println("Request and Response is completed");
   }
}

O código para o arquivo de classe de Configuração do Aplicativo para registrar o Interceptor no Registro do Interceptor - ProductServiceInterceptorAppConfig.java é fornecido abaixo -

package com.tutorialspoint.demo.interceptor;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Component
public class ProductServiceInterceptorAppConfig extends WebMvcConfigurerAdapter {
   @Autowired
   ProductServiceInterceptor productServiceInterceptor;

   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(productServiceInterceptor);
   }
}

O código para o arquivo da classe Controller ProductServiceController.java é fornecido abaixo -

package com.tutorialspoint.demo.controller;

import java.util.HashMap;
import java.util.Map;

import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import com.tutorialspoint.demo.exception.ProductNotfoundException;
import com.tutorialspoint.demo.model.Product;

@RestController
public class ProductServiceController {
   private static Map<String, Product> productRepo = new HashMap<>();   
   static {      
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);      
      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);      
   }
   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productRepo.values(), HttpStatus.OK);
   }
}

O código para a classe POJO para Product.java é fornecido abaixo -

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

O código para o arquivo de classe do aplicativo Spring Boot principal DemoApplication.java é dado abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O código para compilar Maven - pom.xml é mostrado aqui -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

O código do Gradle Build build.gradle é mostrado aqui -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle abaixo.

Para Maven, use o comando conforme mostrado abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando conforme mostrado abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Você pode executar o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta Tomcat 8080 conforme mostrado abaixo -

Agora acesse a URL abaixo no aplicativo POSTMAN e você pode ver a saída conforme mostrado em -

API GET: http://localhost:8080/products

Na janela do console, você pode ver as instruções System.out.println adicionadas no Interceptor conforme mostrado na captura de tela fornecida abaixo

Um filtro é um objeto usado para interceptar as solicitações e respostas HTTP de seu aplicativo. Usando o filtro, podemos realizar duas operações em duas instâncias -

• Antes de enviar a solicitação ao controlador
• Antes de enviar uma resposta ao cliente.

O código a seguir mostra o código de amostra para uma classe de implementação de Filtro de Servlet com a anotação @Component.

@Component
public class SimpleFilter implements Filter {
   @Override
   public void destroy() {}

   @Override
   public void doFilter
      (ServletRequest request, ServletResponse response, FilterChain filterchain) 
      throws IOException, ServletException {}

   @Override
   public void init(FilterConfig filterconfig) throws ServletException {}
}

O exemplo a seguir mostra o código para ler o host remoto e o endereço remoto do objeto ServletRequest antes de enviar a solicitação ao controlador.

No método doFilter (), adicionamos as instruções System.out.println para imprimir o host remoto e o endereço remoto.

package com.tutorialspoint.demo;

import java.io.IOException;

import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import org.springframework.stereotype.Component;

@Component
public class SimpleFilter implements Filter {
   @Override
   public void destroy() {}

   @Override
   public void doFilter(ServletRequest request, ServletResponse response, FilterChain filterchain) 
      throws IOException, ServletException {
      
      System.out.println("Remote Host:"+request.getRemoteHost());
      System.out.println("Remote Address:"+request.getRemoteAddr());
      filterchain.doFilter(request, response);
   }

   @Override
   public void init(FilterConfig filterconfig) throws ServletException {}
}

No arquivo de classe de aplicativo principal do Spring Boot, adicionamos o ponto de extremidade REST simples que retorna a string “Hello World”.

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String hello() {
      return "Hello World";
   }
}

O código para compilar Maven - pom.xml é dado abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

O código para Gradle Build - build.gradle é fornecido a seguir -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle mostrados abaixo -

Para Maven, use o comando conforme mostrado abaixo -

mvn clean install

Após BUILD SUCCESS, você pode localizar o arquivo JAR no diretório de destino.

Para Gradle, use o comando conforme mostrado abaixo -

gradle clean build

Após BUILD SUCCESSFUL, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o seguinte comando

java –jar <JARFILE>

Você pode ver que o aplicativo foi iniciado na porta 8080 do Tomcat.

Agora acesse o URL http://localhost:8080/e veja a saída Hello World. Deve ser semelhante à mostrada abaixo -

Então, você pode ver o host remoto e o endereço remoto no log do console, conforme mostrado abaixo -

O Spring Boot permite que você execute o mesmo aplicativo mais de uma vez em um número de porta diferente. Neste capítulo, você aprenderá sobre isso em detalhes. Observe que o número da porta padrão 8080.

Porto Personalizado

No application.properties arquivo, podemos definir o número da porta personalizada para a propriedade server.port

server.port = 9090

No application.yml arquivo, você pode encontrar o seguinte -

server: 
   port: 9090

Porta Aleatória

No application.properties arquivo, podemos definir um número de porta aleatório para a propriedade server.port

server.port = 0

No application.yml arquivo, você pode encontrar o seguinte -

server: 
   port: 0

Note - Se o server.port number é 0 ao iniciar o aplicativo Spring Boot, o Tomcat usa o número de porta aleatório.

O Rest Template é usado para criar aplicativos que consomem RESTful Web Services. Você pode usar oexchange()método para consumir os serviços da web para todos os métodos HTTP. O código fornecido abaixo mostra como criar Bean for Rest Template para fiação automática do objeto Rest Template.

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.client.RestTemplate;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public RestTemplate getRestTemplate() {
      return new RestTemplate();
   }
}

PEGUE

Consuming the GET API by using RestTemplate - exchange() method

Assuma este URL http://localhost:8080/products retorna o seguinte JSON e vamos consumir essa resposta da API usando o modelo Rest usando o seguinte código -

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

Você terá que seguir os pontos dados para consumir a API -

• Autowired do objeto Template Rest.
• Use HttpHeaders para definir os cabeçalhos de solicitação.
• Use HttpEntity para envolver o objeto de solicitação.
• Forneça a URL, HttpMethod e o tipo de retorno para o método Exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity <String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange("
         http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
}

POSTAR

Consuming POST API by using RestTemplate - exchange() method

Assuma este URL http://localhost:8080/products retorna a resposta mostrada abaixo, vamos consumir essa resposta da API usando o modelo Rest.

O código fornecido abaixo é o corpo da solicitação -

{
   "id":"3",
   "name":"Ginger"
}

O código fornecido abaixo é o corpo da resposta -

Product is created successfully

Você terá que seguir os pontos fornecidos abaixo para consumir a API -

• Autowired do objeto Template Rest.

• Use os HttpHeaders para definir os cabeçalhos de solicitação.

• Use o HttpEntity para envolver o objeto de solicitação. Aqui, envolvemos o objeto Product para enviá-lo ao corpo da solicitação.

• Forneça a URL, HttpMethod e o tipo de retorno para o método exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
}

COLOCAR

Consuming PUT API by using RestTemplate - exchange() method

Assuma este URL http://localhost:8080/products/3 retorna a resposta abaixo e vamos consumir essa resposta da API usando o modelo Rest.

O código fornecido a seguir é Request body -

{
   "name":"Indian Ginger"
}

O código fornecido abaixo é o corpo da resposta -

Product is updated successfully

Você terá que seguir os pontos fornecidos abaixo para consumir a API -

• Autowired do objeto Template Rest.

• Use HttpHeaders para definir os cabeçalhos de solicitação.

• Use HttpEntity para envolver o objeto de solicitação. Aqui, envolvemos o objeto Product para enviá-lo ao corpo da solicitação.

• Forneça a URL, HttpMethod e o tipo de retorno para o método exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
}

EXCLUIR

Consuming DELETE API by using RestTemplate - exchange() method

Assuma este URL http://localhost:8080/products/3 retorna a resposta fornecida abaixo e vamos consumir essa resposta da API usando o modelo Rest.

Esta linha de código mostrada abaixo é o corpo da resposta -

Product is deleted successfully

Você terá que seguir os pontos mostrados abaixo para consumir a API -

• Autowired do objeto Template Rest.

• Use HttpHeaders para definir os cabeçalhos de solicitação.

• Use HttpEntity para envolver o objeto de solicitação.

• Forneça a URL, HttpMethod e o tipo de retorno para o método exchange ().

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

O arquivo de classe Rest Template Controller completo é fornecido abaixo -

package com.tutorialspoint.demo.controller;

import java.util.Arrays;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

import com.tutorialspoint.demo.model.Product;

@RestController
public class ConsumeWebService {
   @Autowired
   RestTemplate restTemplate;

   @RequestMapping(value = "/template/products")
   public String getProductList() {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<String> entity = new HttpEntity<String>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.GET, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products", method = RequestMethod.POST)
   public String createProducts(@RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products", HttpMethod.POST, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.PUT)
   public String updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(product,headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.PUT, entity, String.class).getBody();
   }
   @RequestMapping(value = "/template/products/{id}", method = RequestMethod.DELETE)
   public String deleteProduct(@PathVariable("id") String id) {
      HttpHeaders headers = new HttpHeaders();
      headers.setAccept(Arrays.asList(MediaType.APPLICATION_JSON));
      HttpEntity<Product> entity = new HttpEntity<Product>(headers);
      
      return restTemplate.exchange(
         "http://localhost:8080/products/"+id, HttpMethod.DELETE, entity, String.class).getBody();
   }
}

O código para Spring Boot Application Class - DemoApplication.java é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O código para a construção do Maven - pom.xml é fornecido abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

O código para Gradle Build - build.gradle é fornecido a seguir -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle -

Para Maven, você pode usar o comando fornecido abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando mostrado abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta 8080 do Tomcat.

Agora acesse as URLs abaixo no aplicativo POSTMAN e você poderá ver a saída.

OBTER produtos por modelo de descanso - http://localhost:8080/template/products

Criar produtos POST - http://localhost:8080/template/products

Atualizar Produto PUT - http://localhost:8080/template/products/3

Excluir produto - http://localhost:8080/template/products/3

Neste capítulo, você aprenderá como fazer upload e download do arquivo usando o serviço da web.

Upload de arquivo

Para enviar um arquivo, você pode usar MultipartFilecomo um parâmetro de solicitação e esta API deve consumir o valor de dados do formulário de várias partes. Observe o código fornecido abaixo -

@RequestMapping(value = "/upload", method = RequestMethod.POST, consumes = MediaType.MULTIPART_FORM_DATA_VALUE)

public String fileUpload(@RequestParam("file") MultipartFile file) {
   return null;
}

O código completo para o mesmo é fornecido abaixo -

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.multipart.MultipartFile;

@RestController
public class FileUploadController {
   @RequestMapping(value = "/upload", method = RequestMethod.POST, 
      consumes = MediaType.MULTIPART_FORM_DATA_VALUE)
   
   public String fileUpload(@RequestParam("file") MultipartFile file) throws IOException {
      File convertFile = new File("/var/tmp/"+file.getOriginalFilename());
      convertFile.createNewFile();
      FileOutputStream fout = new FileOutputStream(convertFile);
      fout.write(file.getBytes());
      fout.close();
      return "File is upload successfully";
   }
}

Download do arquivo

Para baixar o arquivo, você deve usar InputStreamResource para baixar um arquivo. Precisamos definir o HttpHeaderContent-Disposition em Resposta e precisa especificar o tipo de mídia de resposta do aplicativo.

Note - No exemplo a seguir, o arquivo deve estar disponível no caminho especificado onde o aplicativo está sendo executado.

@RequestMapping(value = "/download", method = RequestMethod.GET) 
public ResponseEntity<Object> downloadFile() throws IOException  {
   String filename = "/var/tmp/mysql.png";
   File file = new File(filename);
   InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
   HttpHeaders headers = new HttpHeaders();
      
   headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
   headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
   headers.add("Pragma", "no-cache");
   headers.add("Expires", "0");
      
   ResponseEntity<Object> 
   responseEntity = ResponseEntity.ok().headers(headers).contentLength(file.length()).contentType(
      MediaType.parseMediaType("application/txt")).body(resource);
      
   return responseEntity;
}

O código completo para o mesmo é fornecido abaixo -

package com.tutorialspoint.demo.controller;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;

import org.springframework.core.io.InputStreamResource;
import org.springframework.http.HttpHeaders;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class FileDownloadController {
   @RequestMapping(value = "/download", method = RequestMethod.GET) 
   public ResponseEntity<Object> downloadFile() throws IOException  {
      String filename = "/var/tmp/mysql.png";
      File file = new File(filename);
      InputStreamResource resource = new InputStreamResource(new FileInputStream(file));
      HttpHeaders headers = new HttpHeaders();
      
      headers.add("Content-Disposition", String.format("attachment; filename=\"%s\"", file.getName()));
      headers.add("Cache-Control", "no-cache, no-store, must-revalidate");
      headers.add("Pragma", "no-cache");
      headers.add("Expires", "0");
      
      ResponseEntity<Object> 
      responseEntity = ResponseEntity.ok().headers(headers).contentLength(
         file.length()).contentType(MediaType.parseMediaType("application/txt")).body(resource);
      
      return responseEntity;
   }
}

O aplicativo Spring Boot principal é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O código para a construção do Maven - pom.xml é fornecido abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

O código para Gradle Build - build.gradle é fornecido a seguir -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Agora você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle fornecidos abaixo -

Para Maven, use o comando fornecido abaixo -

mvn clean install

Depois de “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando mostrado abaixo -

sgradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Isso iniciará o aplicativo na porta 8080 do Tomcat, conforme mostrado abaixo -

Agora acesse os URLs abaixo no aplicativo POSTMAN e você pode ver a saída conforme mostrado abaixo -

Upload de arquivo - http://localhost:8080/upload

Download de arquivo - http://localhost:8080/upload

Componentes de serviço são o arquivo de classe que contém a anotação @Service. Esses arquivos de classe são usados ​​para escrever a lógica de negócios em uma camada diferente, separada do arquivo de classe @RestController. A lógica para criar um arquivo de classe de componente de serviço é mostrada aqui -

public interface ProductService {
}

A classe que implementa a interface com a anotação @Service é mostrada -

@Service
public class ProductServiceImpl implements ProductService {
}

Observe que neste tutorial, estamos usando Product Service API(s)para armazenar, recuperar, atualizar e excluir os produtos. Escrevemos a lógica de negócios no próprio arquivo de classe @RestController. Agora, vamos mover o código da lógica de negócios do controlador para o componente de serviço.

Você pode criar uma interface que contém métodos de adição, edição, obtenção e exclusão usando o código conforme mostrado abaixo -

package com.tutorialspoint.demo.service;

import java.util.Collection;
import com.tutorialspoint.demo.model.Product;

public interface ProductService {
   public abstract void createProduct(Product product);
   public abstract void updateProduct(String id, Product product);
   public abstract void deleteProduct(String id);
   public abstract Collection<Product> getProducts();
}

O código a seguir permitirá que você crie uma classe que implementa a interface ProductService com a anotação @Service e escreva a lógica de negócios para armazenar, recuperar, excluir e atualizar o produto.

package com.tutorialspoint.demo.service;

import java.util.Collection;
import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.tutorialspoint.demo.model.Product;

@Service
public class ProductServiceImpl implements ProductService {
   private static Map<String, Product> productRepo = new HashMap<>();
   static {
      Product honey = new Product();
      honey.setId("1");
      honey.setName("Honey");
      productRepo.put(honey.getId(), honey);

      Product almond = new Product();
      almond.setId("2");
      almond.setName("Almond");
      productRepo.put(almond.getId(), almond);
   }
   @Override
   public void createProduct(Product product) {
      productRepo.put(product.getId(), product);
   }
   @Override
   public void updateProduct(String id, Product product) {
      productRepo.remove(id);
      product.setId(id);
      productRepo.put(id, product);
   }
   @Override
   public void deleteProduct(String id) {
      productRepo.remove(id);

   }
   @Override
   public Collection<Product> getProducts() {
      return productRepo.values();
   }
}

O código aqui mostra o arquivo de classe Rest Controller, aqui nós @Autowired a interface ProductService e chamamos os métodos.

package com.tutorialspoint.demo.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.RestController;

import com.tutorialspoint.demo.model.Product;
import com.tutorialspoint.demo.service.ProductService;

@RestController
public class ProductServiceController {
   @Autowired
   ProductService productService;

   @RequestMapping(value = "/products")
   public ResponseEntity<Object> getProduct() {
      return new ResponseEntity<>(productService.getProducts(), HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.PUT)
   public ResponseEntity<Object> 
      updateProduct(@PathVariable("id") String id, @RequestBody Product product) {
      
      productService.updateProduct(id, product);
      return new ResponseEntity<>("Product is updated successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products/{id}", method = RequestMethod.DELETE)
   public ResponseEntity<Object> delete(@PathVariable("id") String id) {
      productService.deleteProduct(id);
      return new ResponseEntity<>("Product is deleted successsfully", HttpStatus.OK);
   }
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public ResponseEntity<Object> createProduct(@RequestBody Product product) {
      productService.createProduct(product);
      return new ResponseEntity<>("Product is created successfully", HttpStatus.CREATED);
   }
}

O código para a classe POJO - Product.java é mostrado aqui -

package com.tutorialspoint.demo.model;

public class Product {
   private String id;
   private String name;

   public String getId() {
      return id;
   }
   public void setId(String id) {
      this.id = id;
   }
   public String getName() {
      return name;
   }
   public void setName(String name) {
      this.name = name;
   }
}

Um aplicativo principal do Spring Boot é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O código para compilar Maven - pom.xml é mostrado abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath/> 
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

O código para Gradle Build - build.gradle é mostrado abaixo -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle fornecidos abaixo -

Para Maven, use o comando conforme mostrado abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando conforme mostrado abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o comando fornecido abaixo -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta 8080 do Tomcat, conforme mostrado na imagem abaixo -

Agora acesse os URLs abaixo no aplicativo POSTMAN e você pode ver a saída conforme mostrado abaixo -

O URL da API GET é - http://localhost:8080/products

URL POST API é - http://localhost:8080/products

PUT API URL é - http://localhost:8080/products/3

URL DELETE API é - http://localhost:8080/products/3

Thymeleaf é uma biblioteca baseada em Java usada para criar um aplicativo da web. Ele fornece um bom suporte para servir um XHTML / HTML5 em aplicativos da web. Neste capítulo, você aprenderá em detalhes sobre o Thymeleaf.

Modelos de Thymeleaf

Thymeleaf converte seus arquivos em arquivos XML bem formados. Ele contém 6 tipos de modelos, conforme abaixo -

• XML
• XML válido
• XHTML
• XHTML válido
• HTML5
• HTML5 legado

Todos os modelos, exceto HTML5 legado, referem-se a arquivos XML válidos bem formados. O HTML5 legado nos permite renderizar as tags HTML5 na página da web, incluindo as tags não fechadas.

Aplicativo da Web

Você pode usar os modelos do Thymeleaf para criar um aplicativo da web no Spring Boot. Você terá que seguir as etapas abaixo para criar um aplicativo da web no Spring Boot usando o Thymeleaf.

Use o seguinte código para criar um arquivo de classe @Controller para redirecionar o URI de solicitação para o arquivo HTML -

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class WebController {
   @RequestMapping(value = "/index")
   public String index() {
      return "index";
   }
}

No exemplo acima, o URI do pedido é /index, e o controle é redirecionado para o arquivo index.html. Observe que o arquivo index.html deve ser colocado no diretório de modelos e todos os arquivos JS e CSS devem ser colocados no diretório estático no classpath. No exemplo mostrado, usamos o arquivo CSS para alterar a cor do texto.

Você pode usar o seguinte código e criar um arquivo CSS em uma pasta separada css e nomeie o arquivo como styles.css -

h4 {
   color: red;
}

O código do arquivo index.html é fornecido abaixo -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <link href = "css/styles.css" rel = "stylesheet"/>
      <title>Spring Boot Application</title>
   </head>
   <body>
      <h4>Welcome to Thymeleaf Spring Boot web application</h4>
   </body>
</html>

O explorador do projeto é mostrado na imagem abaixo -

Agora, precisamos adicionar a dependência Thymeleaf do Spring Boot Starter em nosso arquivo de configuração de compilação.

Os usuários do Maven podem adicionar a seguinte dependência ao arquivo pom.xml -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência no arquivo build.gradle -

compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

O código para o arquivo de classe do aplicativo Spring Boot principal é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O código para Maven - pom.xml é fornecido abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

O código para Gradle - build.gradle é fornecido abaixo -

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle -

Para Maven, use o comando conforme mostrado abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando conforme mostrado abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o comando fornecido aqui -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta Tomcat 8080 conforme mostrado abaixo -

Agora acesse a URL em seu navegador da web e você poderá ver a saída conforme mostrado -

http://localhost:8080/index

Este capítulo discutirá em detalhes sobre como consumir um RESTful Web Services usando jQuery AJAX.

Crie um aplicativo da web Spring Boot simples e escreva arquivos de classe de controlador que são usados ​​para redirecionar para o arquivo HTML para consumir os serviços da web RESTful.

Precisamos adicionar a dependência Thymeleaf e Web inicial do Spring Boot em nosso arquivo de configuração de compilação.

Para usuários Maven, adicione as dependências abaixo em seu arquivo pom.xml.

<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>

Para usuários do Gradle, adicione as dependências abaixo em seu arquivo build.gradle -

compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
compile(‘org.springframework.boot:spring-boot-starter-web’)

O código para o arquivo de classe @Controller é fornecido abaixo -

@Controller
public class ViewController {
}

Você pode definir os métodos de solicitação de URI para redirecionar para o arquivo HTML, conforme mostrado abaixo -

@RequestMapping(“/view-products”)
public String viewProducts() {
   return “view-products”;
}
@RequestMapping(“/add-products”)
public String addProducts() {
   return “add-products”;
}

Esta API http://localhost:9090/products deve retornar o JSON abaixo em resposta conforme mostrado abaixo -

[
   {
      "id": "1",
      "name": "Honey"
   },
   {
      "id": "2",
      "name": "Almond"
   }
]

Agora, crie um arquivo view-products.html no diretório de templates no classpath.

No arquivo HTML, adicionamos a biblioteca jQuery e escrevemos o código para consumir o serviço da Web RESTful no carregamento da página.

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>

<script>
$(document).ready(function(){
   $.getJSON("http://localhost:9090/products", function(result){ $.each(result, function(key,value) {
         $("#productsJson").append(value.id+" "+value.name+" ");
      }); 
   });
});
</script>

O método POST e este URL http://localhost:9090/products deve conter o corpo da solicitação e o corpo da resposta abaixo.

O código para o corpo da solicitação é fornecido abaixo -

{
   "id":"3",
   "name":"Ginger"
}

O código para o corpo da resposta é fornecido abaixo -

Product is created successfully

Agora, crie o arquivo add-products.html no diretório de modelos no classpath.

No arquivo HTML, adicionamos a biblioteca jQuery e escrevemos o código que envia o formulário ao serviço da web RESTful ao clicar no botão.

<script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
<script>
   $(document).ready(function() {
      $("button").click(function() { var productmodel = { id : "3", name : "Ginger" }; var requestJSON = JSON.stringify(productmodel); $.ajax({
            type : "POST",
            url : "http://localhost:9090/products",
            headers : {
               "Content-Type" : "application/json"
            },
            data : requestJSON,
            success : function(data) {
               alert(data);
            },
            error : function(data) {
            }
         });
      });
   });
</script>

O código completo é fornecido abaixo.

Maven - arquivo 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

O código para Gradle - build.gradle é fornecido abaixo -

buildscript {
   ext {
      springBootVersion = ‘1.5.8.RELEASE’
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: ‘java’
apply plugin: ‘eclipse’
apply plugin: ‘org.springframework.boot’

group = ‘com.tutorialspoint’
version = ‘0.0.1-SNAPSHOT’
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}

dependencies {
   compile(‘org.springframework.boot:spring-boot-starter-web’)
   compile group: ‘org.springframework.boot’, name: ‘spring-boot-starter-thymeleaf’
   testCompile(‘org.springframework.boot:spring-boot-starter-test’)
}

O arquivo de classe do controlador fornecido abaixo - ViewController.java é fornecido abaixo -

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping(“/view-products”)
   public String viewProducts() {
      return “view-products”;
   }
   @RequestMapping(“/add-products”)
   public String addProducts() {
      return “add-products”;   
   }   
}

O arquivo view-products.html é fornecido abaixo -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>View Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
      
      <script>
         $(document).ready(function(){
            $.getJSON("http://localhost:9090/products", function(result){ $.each(result, function(key,value) {
                  $("#productsJson").append(value.id+" "+value.name+" ");
               }); 
            });
         });
      </script>
   </head>
   
   <body>
      <div id = "productsJson"> </div>
   </body>
</html>

O arquivo add-products.html é fornecido abaixo -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1" />
      <title>Add Products</title>
      <script src = "https://ajax.googleapis.com/ajax/libs/jquery/3.2.1/jquery.min.js"></script>
      
      <script>
         $(document).ready(function() {
            $("button").click(function() { var productmodel = { id : "3", name : "Ginger" }; var requestJSON = JSON.stringify(productmodel); $.ajax({
                  type : "POST",
                  url : "http://localhost:9090/products",
                  headers : {
                     "Content-Type" : "application/json"
                  },
                  data : requestJSON,
                  success : function(data) {
                     alert(data);
                  },
                  error : function(data) {
                  }
               });
            });
         });
      </script>
   </head>
   
   <body>
      <button>Click here to submit the form</button>
   </body>
</html>

O arquivo principal da classe do aplicativo Spring Boot é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Agora, você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Para Maven, use o comando conforme fornecido abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando conforme fornecido abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta 8080 do Tomcat.

Agora acesse a URL em seu navegador da web e você poderá ver a saída conforme mostrado -

http: // localhost: 8080 / view-products

http: // localhost: 8080 / add-products

Agora, clique no botão Click here to submit the form e você pode ver o resultado conforme mostrado -

Agora, acesse a URL ver produtos e veja o produto criado.

http://localhost:8080/view-products

Angular JS

Para consumir as APIs usando Angular JS, você pode usar os exemplos fornecidos abaixo -

Use o seguinte código para criar o Angular JS Controller para consumir a API GET - http://localhost:9090/products -

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.get('http://localhost:9090/products'). then(function(response) { $scope.products = response.data;
   });
});

Use o seguinte código para criar o Angular JS Controller para consumir a API POST - http://localhost:9090/products -

angular.module('demo', [])
.controller('Hello', function($scope, $http) {
   $http.post('http://localhost:9090/products',data).
   then(function(response) {
      console.log("Product created successfully");
   });
});

Note - Os dados do método Post representam o corpo da solicitação no formato JSON para criar um produto.

Cross-Origin Resource Sharing (CORS) é um conceito de segurança que permite restringir os recursos implementados em navegadores web. Isso evita que o código JavaScript produza ou consuma as solicitações em origens diferentes.

Por exemplo, seu aplicativo da web está sendo executado na porta 8080 e, usando JavaScript, você está tentando consumir serviços da web RESTful da porta 9090. Em tais situações, você enfrentará o problema de segurança do Compartilhamento de recursos entre origens em seus navegadores da web.

Dois requisitos são necessários para lidar com este problema -

• Os serviços da Web RESTful devem oferecer suporte ao compartilhamento de recursos entre origens.

• O aplicativo de serviço da web RESTful deve permitir o acesso à (s) API (s) da porta 8080.

Neste capítulo, aprenderemos em detalhes sobre como habilitar solicitações de origem cruzada para um aplicativo de serviço da Web RESTful.

Habilitar CORS no método do controlador

Precisamos definir as origens do serviço da web RESTful usando @CrossOriginanotação para o método do controlador. Esta anotação @CrossOrigin suporta API REST específica, e não para todo o aplicativo.

@RequestMapping(value = "/products")
@CrossOrigin(origins = "http://localhost:8080")

public ResponseEntity<Object> getProduct() {
   return null;
}

Configuração CORS Global

Precisamos definir a configuração @Bean mostrada para definir o suporte de configuração CORS globalmente para seu aplicativo Spring Boot.

@Bean
public WebMvcConfigurer corsConfigurer() {
   return new WebMvcConfigurerAdapter() {
      @Override
      public void addCorsMappings(CorsRegistry registry) {
         registry.addMapping("/products").allowedOrigins("http://localhost:9000");
      }    
   };
}

O código para definir a configuração CORS globalmente no aplicativo Spring Boot principal é fornecido abaixo.

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@SpringBootApplication
public class DemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(DemoApplication.class, args);
   }
   @Bean
   public WebMvcConfigurer corsConfigurer() {
      return new WebMvcConfigurerAdapter() {
         @Override
         public void addCorsMappings(CorsRegistry registry) {
            registry.addMapping("/products").allowedOrigins("http://localhost:8080");
         }
      };
   }
}

Agora, você pode criar um aplicativo da web Spring Boot que execute na porta 8080 e seu aplicativo de serviço da web RESTful que pode ser executado na porta 9090. Para obter mais detalhes sobre a implementação do RESTful Web Service, você pode consultar o capítulo intituladoConsuming RESTful Web Services deste tutorial.

A internacionalização é um processo que torna seu aplicativo adaptável a diferentes idiomas e regiões sem alterações de engenharia no código-fonte. Em qualquer uma das palavras, internacionalização é uma prontidão de localização.

Neste capítulo, vamos aprender em detalhes sobre como implementar a Internacionalização no Spring Boot.

Dependências

Precisamos da dependência Spring Boot Starter Web e Spring Boot Starter Thymeleaf para desenvolver um aplicativo da web no Spring Boot.

Maven

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>

Gradle

compile('org.springframework.boot:spring-boot-starter-web')
compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'

LocaleResolver

Precisamos determinar a localidade padrão de seu aplicativo. Precisamos adicionar o bean LocaleResolver em nosso aplicativo Spring Boot.

@Bean
public LocaleResolver localeResolver() {
   SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
   sessionLocaleResolver.setDefaultLocale(Locale.US);
   return sessionLocaleResolver;
}

LocaleChangeInterceptor

LocaleChangeInterceptor é usado para alterar o novo Locale com base no valor do parâmetro de idioma adicionado a uma solicitação.

@Bean
public LocaleChangeInterceptor localeChangeInterceptor() {
   LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
   localeChangeInterceptor.setParamName("language");
   return localeChangeInterceptor;
}

Para fazer isso, precisamos adicionar LocaleChangeInterceptor ao interceptor de registro do aplicativo. A classe de configuração deve estender a classe WebMvcConfigurerAdapter e substituir o método addInterceptors ().

@Override
public void addInterceptors(InterceptorRegistry registry) {
   registry.addInterceptor(localeChangeInterceptor());
}

Fontes de mensagens

O aplicativo Spring Boot por padrão pega as fontes de mensagens de src/main/resourcespasta sob o classpath. O nome do arquivo de mensagem local padrão deve sermessage.properties e os arquivos para cada localidade devem ser nomeados como messages_XX.properties. O “XX” representa o código local.

Todas as propriedades da mensagem devem ser usadas como valores de pares de chaves. Se alguma propriedade não for localizada no código do idioma, o aplicativo usará a propriedade padrão do arquivo messages.properties.

O messages.properties padrão será como mostrado -

welcome.text=Hi Welcome to Everyone

As mensagens de idioma francês_fr.properties serão as mostradas -

welcome.text=Salut Bienvenue à tous

Note - O arquivo de origem das mensagens deve ser salvo no formato de arquivo “UTF-8”.

Arquivo HTML

No arquivo HTML, use a sintaxe #{key} para exibir as mensagens do arquivo de propriedades.

<h1 th:text = "#{welcome.text}"></h1>

O código completo é fornecido abaixo

Maven - 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.8.RELEASE</version>
      <relativePath />
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-thymeleaf</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

Gradle - build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

O arquivo principal da classe do aplicativo Spring Boot é fornecido abaixo -

package com.tutorialspoint.demo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O arquivo de classe do controlador é fornecido abaixo -

package com.tutorialspoint.demo.controller;

import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;

@Controller
public class ViewController {
   @RequestMapping("/locale")
   public String locale() {
      return "locale";
   }
}

Classe de configuração para apoiar a internacionalização

package com.tutorialspoint.demo;

import java.util.Locale;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.LocaleResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;
import org.springframework.web.servlet.i18n.LocaleChangeInterceptor;
import org.springframework.web.servlet.i18n.SessionLocaleResolver;

@Configuration
public class Internationalization extends WebMvcConfigurerAdapter {
   @Bean
   public LocaleResolver localeResolver() {
      SessionLocaleResolver sessionLocaleResolver = new SessionLocaleResolver();
      sessionLocaleResolver.setDefaultLocale(Locale.US);
      return sessionLocaleResolver;
   }
   @Bean
   public LocaleChangeInterceptor localeChangeInterceptor() {
      LocaleChangeInterceptor localeChangeInterceptor = new LocaleChangeInterceptor();
      localeChangeInterceptor.setParamName("language");
      return localeChangeInterceptor;
   }
   @Override
   public void addInterceptors(InterceptorRegistry registry) {
      registry.addInterceptor(localeChangeInterceptor());
   }
}

As fontes de mensagens - messages.properties são mostradas -

welcome.text = Hi Welcome to Everyone

As fontes de mensagens - message_fr.properties são as mostradas -

welcome.text = Salut Bienvenue à tous

O arquivo HTML locale.html deve ser colocado no diretório de modelos no caminho de classe, conforme mostrado -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1"/>
      <title>Internationalization</title>
   </head>
   <body>
      <h1 th:text = "#{welcome.text}"></h1>
   </body>
</html>

Você pode criar um arquivo JAR executável e executar o aplicativo Spring boot usando os seguintes comandos Maven ou Gradle -

Para Maven, use o seguinte comando -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o seguinte comando -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando conforme mostrado -

java –jar <JARFILE>

Você verá que o aplicativo foi iniciado na porta 8080 do Tomcat.

Agora acesse o URL http://localhost:8080/locale no seu navegador e você pode ver o seguinte resultado -

O URL http://localhost:8080/locale?language=fr fornecerá a saída conforme mostrado -

A programação é um processo de execução de tarefas para um período de tempo específico. Spring Boot fornece um bom suporte para escrever um agendador nos aplicativos Spring.

Expressão Java Cron

As expressões Java Cron são usadas para configurar as instâncias de CronTrigger, uma subclasse de org.quartz.Trigger. Para obter mais informações sobre a expressão cron Java, você pode consultar este link -

https://docs.oracle.com/cd/E12058_01/doc/doc.1014/e12030/cron_expressions.htm

A anotação @EnableScheduling é usada para habilitar o planejador para seu aplicativo. Esta anotação deve ser adicionada ao arquivo de classe do aplicativo Spring Boot principal.

@SpringBootApplication
@EnableScheduling

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

A anotação @Scheduled é usada para acionar o planejador para um período de tempo específico.

@Scheduled(cron = "0 * 9 * * ?")
public void cronJobSch() throws Exception {
}

A seguir está um exemplo de código que mostra como executar a tarefa a cada minuto, começando às 9h e terminando às 9h59, todos os dias

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(cron = "0 * 9 * * ?")
   public void cronJobSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Java cron job expression:: " + strDate);
   }
}

A captura de tela a seguir mostra como o aplicativo foi iniciado às 09:03:23 e a cada minuto a partir desse momento a tarefa do agendador de cron job foi executada.

Taxa fixa

O agendador de taxa fixa é usado para executar as tarefas em um horário específico. Ele não espera pela conclusão da tarefa anterior. Os valores devem estar em milissegundos. O código de amostra é mostrado aqui -

@Scheduled(fixedRate = 1000)
public void fixedRateSch() { 
}

Um exemplo de código para executar uma tarefa a cada segundo desde a inicialização do aplicativo é mostrado aqui -

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedRate = 1000)
   public void fixedRateSch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Rate scheduler:: " + strDate);
   }
}

Observe a seguinte captura de tela que mostra o aplicativo que foi iniciado às 09:12:00 e depois disso cada segunda tarefa do agendador de taxa fixa foi executada.

Atraso fixo

Agendador de atraso fixo é usado para executar as tarefas em um horário específico. Deve aguardar a conclusão da tarefa anterior. Os valores devem estar em milissegundos. Um exemplo de código é mostrado aqui -

@Scheduled(fixedDelay = 1000, initialDelay = 1000)
public void fixedDelaySch() {
}

Aqui, o initialDelay é o tempo após o qual a tarefa será executada pela primeira vez após o valor de atraso inicial.

Um exemplo para executar a tarefa a cada segundo após 3 segundos da inicialização do aplicativo foi concluído é mostrado abaixo -

package com.tutorialspoint.demo.scheduler;

import java.text.SimpleDateFormat;
import java.util.Date;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

@Component
public class Scheduler {
   @Scheduled(fixedDelay = 1000, initialDelay = 3000)
   public void fixedDelaySch() {
      SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");
      Date now = new Date();
      String strDate = sdf.format(now);
      System.out.println("Fixed Delay scheduler:: " + strDate);
   }
}

Observe a imagem a seguir que mostra o aplicativo que foi iniciado às 09:18:39 e a cada 3 segundos, a tarefa do agendador de atraso fixo foi executada a cada segundo.

Por padrão, o aplicativo Spring Boot usa a porta HTTP 8080 quando o aplicativo é inicializado.

Você precisa seguir as etapas abaixo para configurar o HTTPS e a porta 443 no aplicativo Spring Boot -

• Obtenha o certificado SSL - crie um certificado autoassinado ou obtenha um de uma autoridade de certificação

• Habilitar porta HTTPS e 443

Certificado Autoassinado

Para criar um certificado autoassinado, o Java Run Time Environment vem com a ferramenta de chave do utilitário de gerenciamento de certificados. Esta ferramenta utilitária é usada para criar um certificado autoassinado. É mostrado no código fornecido aqui -

keytool -genkey -alias tomcat -storetype PKCS12 -keyalg RSA -keysize 2048 -keystore keystore.p12 -validity 3650
Enter keystore password:
   Re-enter new password:
   What is your first and last name?
   [Unknown]:
   What is the name of your organizational unit?
   [Unknown]:
   What is the name of your organization?
   [Unknown]:
   What is the name of your City or Locality?
   [Unknown]:
   What is the name of your State or Province?
   [Unknown]:
   What is the two-letter country code for this unit?
   [Unknown]:
   Is CN = Unknown, OU=Unknown, O = Unknown, L = Unknown, ST = Unknown, C = Unknown correct?
   [no]: yes

Este código irá gerar um arquivo de armazenamento de chaves PKCS12 denominado keystore.p12 e o nome do alias do certificado é tomcat.

Configurar HTTPS

Precisamos fornecer a porta do servidor como 443, caminho do arquivo de armazenamento de chave, senha de armazenamento de chave, tipo de armazenamento de chave e nome de alias de chave no arquivo application.properties. Observe o código fornecido aqui -

server.port: 443
server.ssl.key-store: keystore.p12
server.ssl.key-store-password: springboot
server.ssl.keyStoreType: PKCS12
server.ssl.keyAlias: tomcat

Você pode usar o código a seguir se estiver usando as propriedades YAML, use abaixo application.yml -

server:
   port: 443
   ssl:
      key-store: keystore.p12
      key-store-password: springboot
      keyStoreType: PKCS12
      keyAlias: tomcat

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Para Maven, você pode usar o seguinte comando -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta Tomcat 443 com https como mostrado -

Eureka Server é um aplicativo que contém as informações sobre todos os aplicativos de serviço ao cliente. Cada serviço Micro será registrado no servidor Eureka e o servidor Eureka conhece todos os aplicativos cliente em execução em cada porta e endereço IP. O Eureka Server também é conhecido como Discovery Server.

Neste capítulo, aprenderemos em detalhes sobre como construir um servidor Eureka.

Construindo um Servidor Eureka

O Eureka Server vem com o pacote Spring Cloud. Para isso, precisamos desenvolver o servidor Eureka e executá-lo na porta padrão 8761.

Visite a página inicial do Spring Initializer https://start.spring.io/e baixe o projeto Spring Boot com dependência do servidor Eureka. É mostrado na imagem abaixo -

Depois de baixar o projeto no arquivo de classe principal do aplicativo Spring Boot, precisamos adicionar a anotação @EnableEurekaServer. A anotação @EnableEurekaServer é usada para fazer seu aplicativo Spring Boot atuar como um servidor Eureka.

O código para o arquivo de classe do aplicativo Spring Boot principal é mostrado abaixo -

package com.tutorialspoint.eurekaserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

@SpringBootApplication
@EnableEurekaServer
public class EurekaserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaserverApplication.class, args);
   }
}

Certifique-se de que a dependência do servidor Spring cloud Eureka seja adicionada ao arquivo de configuração de construção

O código para a dependência do usuário Maven é mostrado abaixo -

<dependency>
<groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka-server</artifactId>
</dependency>

O código para dependência de usuário do Gradle é fornecido abaixo -

compile('org.springframework.cloud:spring-cloud-starter-eureka-server')

O arquivo de configuração de compilação completo é fornecido abaixo -

Maven 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>eurekaserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>eurekaserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka-server</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-eureka-server')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Por padrão, o servidor Eureka se registra na descoberta. Você deve adicionar a configuração fornecida abaixo em seu arquivo application.properties ou arquivo application.yml.

O arquivo application.properties é fornecido abaixo -

eureka.client.registerWithEureka = false
eureka.client.fetchRegistry = false
server.port = 8761

O arquivo application.yml é fornecido abaixo -

eureka:
   client:
      registerWithEureka: false
      fetchRegistry: false
server:
   port: 8761

Agora, você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle mostrados abaixo -

Para Maven, use o comando conforme mostrado abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando mostrado abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Você pode descobrir que o aplicativo foi iniciado na porta Tomcat 8761 conforme mostrado abaixo -

Agora, acesse o URL http://localhost:8761/ em seu navegador da web e você pode encontrar o servidor Eureka em execução na porta 8761 conforme mostrado abaixo -

Neste capítulo, você aprenderá em detalhes sobre como registrar o aplicativo de serviço Spring Boot Micro no servidor Eureka. Antes de registrar o aplicativo, certifique-se de que o servidor Eureka esteja rodando na porta 8761 ou primeiro crie o servidor Eureka e execute-o. Para obter mais informações sobre a construção do servidor Eureka, você pode consultar o capítulo anterior.

Primeiro, você precisa adicionar as seguintes dependências em nosso arquivo de configuração de compilação para registrar o microsserviço com o servidor Eureka.

Os usuários do Maven podem adicionar as seguintes dependências ao pom.xml arquivo -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>

Os usuários do Gradle podem adicionar as seguintes dependências ao build.gradle arquivo -

compile('org.springframework.cloud:spring-cloud-starter-eureka')

Agora, precisamos adicionar a anotação @EnableEurekaClient no arquivo de classe do aplicativo Spring Boot principal. A anotação @EnableEurekaClient faz seu aplicativo Spring Boot atuar como um cliente Eureka.

O aplicativo principal do Spring Boot é mostrado abaixo -

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;

@SpringBootApplication
@EnableEurekaClient
public class EurekaclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaclientApplication.class, args);
   }
}

Para registrar o aplicativo Spring Boot no servidor Eureka, precisamos adicionar a seguinte configuração em nosso arquivo application.properties ou arquivo application.yml e especificar a URL do servidor Eureka em nossa configuração.

O código para o arquivo application.yml é fornecido abaixo -

eureka:
   client:
      serviceUrl:
         defaultZone: http://localhost:8761/eureka
      instance:
      preferIpAddress: true
spring:
   application:
      name: eurekaclient

O código do arquivo application.properties é fornecido abaixo -

eureka.client.serviceUrl.defaultZone  = http://localhost:8761/eureka
eureka.client.instance.preferIpAddress = true
spring.application.name = eurekaclient

Agora, adicione o Rest Endpoint para retornar String no aplicativo Spring Boot principal e a dependência da web Spring Boot Starter no arquivo de configuração de compilação. Observe o código fornecido abaixo -

package com.tutorialspoint.eurekaclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.EnableEurekaClient;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableEurekaClient
@RestController
public class EurekaclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(EurekaclientApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String home() {
      return "Eureka Client application";
   }
}

Todo o arquivo de configuração é fornecido abaixo.

For Maven user - 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>eurekaclient</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>eurekaclient</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-eureka</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>
      </dependency>
   </dependencies>
   
   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>
   
   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>   
   </build>
   
</projecta>

For Gradle user – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('org.springframework.cloud:spring-cloud-starter-eureka') testCompile('org.springframework.boot:spring-boot-starter-test') compile('org.springframework.boot:spring-boot-starter-web') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle -

Para Maven, você pode usar o seguinte comando -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o seguinte comando -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando conforme mostrado -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta Tomcat 8080 e o aplicativo Eureka Client está registrado no servidor Eureka conforme mostrado abaixo -

Acesse a URL http: // localhost: 8761 / em seu navegador da web e você verá que o aplicativo cliente Eureka está registrado no servidor Eureka.

Agora acesse o URL http://localhost:8080/ no seu navegador da web e veja a saída do Rest Endpoint.

Zuul Server é um aplicativo de gateway que trata de todas as solicitações e faz o roteamento dinâmico de aplicativos de microsserviço. O Zuul Server também é conhecido como Edge Server.

Por exemplo, /api/user é mapeado para o serviço do usuário e / api / products é mapeado para o serviço do produto e o Zuul Server roteia dinamicamente as solicitações para o respectivo aplicativo backend.

Neste capítulo, veremos em detalhes como criar a aplicação Zuul Server no Spring Boot.

Criando Aplicativo de Servidor Zuul

O Zuul Server é fornecido com a dependência Spring Cloud. Você pode baixar o projeto Spring Boot na página Spring Initializerhttps://start.spring.io/ e escolha a dependência do Zuul Server.

Adicione a anotação @EnableZuulProxy em seu aplicativo Spring Boot principal. A anotação @EnableZuulProxy é usada para fazer seu aplicativo Spring Boot atuar como um servidor Zuul Proxy.

package com.tutorialspoint.zuulserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@SpringBootApplication
@EnableZuulProxy
public class ZuulserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(ZuulserverApplication.class, args);
   }
}

Você terá que adicionar a dependência Spring Cloud Starter Zuul em nosso arquivo de configuração de compilação.

Os usuários do Maven terão que adicionar a seguinte dependência em seu pom.xml arquivo -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>

Para usuários do Gradle, adicione a dependência abaixo em seu arquivo build.gradle

compile('org.springframework.cloud:spring-cloud-starter-zuul')

Para roteamento Zuul, adicione as propriedades abaixo em seu arquivo application.properties ou arquivo application.yml.

spring.application.name = zuulserver
zuul.routes.products.path = /api/demo/**
zuul.routes.products.url = http://localhost:8080/
server.port = 8111

Isso significa que http chama para /api/demo/ser encaminhado para o serviço de produtos. Por exemplo,/api/demo/products é encaminhado para /products.

Os usuários do arquivo yaml podem usar o arquivo application.yml mostrado abaixo -

server:
   port: 8111
spring:
   application:  
      name: zuulserver
zuul:

routes:
   products:
      path: /api/demo/**
      url: http://localhost:8080/

Note - o http://localhost:8080/ O aplicativo já deve estar em execução antes do roteamento via Zuul Proxy.

O arquivo de configuração de compilação completo é fornecido abaixo.

Os usuários do Maven podem usar o arquivo pom.xml fornecido abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>zuulserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>zuulserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-zuul</artifactId>
      </dependency>

      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
</project>

Os usuários do Gradle podem usar o arquivo build.gradle fornecido abaixo -

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-zuul')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle fornecidos abaixo -

Para Maven, você pode usar o comando fornecido abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando fornecido abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando mostrado abaixo -

java –jar <JARFILE>

Você pode descobrir que o aplicativo foi iniciado na porta 8111 do Tomcat, conforme mostrado aqui.

Agora, acesse o URL http://localhost:8111/api/demo/products em seu navegador da web e você pode ver a saída de /products Endpoint REST conforme mostrado abaixo -

Spring Cloud Configuration Server é um aplicativo centralizado que gerencia todas as propriedades de configuração relacionadas ao aplicativo. Neste capítulo, você aprenderá em detalhes sobre como criar o servidor Spring Cloud Configuration.

Criação do servidor de configuração Spring Cloud

Primeiro, baixe o projeto Spring Boot da página Spring Initializer e escolha a dependência Spring Cloud Config Server. Observe a imagem abaixo -

Agora, adicione a dependência do servidor Spring Cloud Config em seu arquivo de configuração de compilação, conforme explicado abaixo -

Os usuários do Maven podem adicionar a dependência abaixo ao arquivo pom.xml.

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-config-server</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a dependência abaixo em seu arquivo build.gradle.

compile('org.springframework.cloud:spring-cloud-config-server')

Agora, adicione a anotação @EnableConfigServer em seu arquivo de classe do aplicativo Spring Boot principal. A anotação @EnableConfigServer faz com que seu aplicativo Spring Boot atue como um servidor de configuração.

O arquivo principal da classe do aplicativo Spring Boot é fornecido abaixo -

package com.tutorialspoint.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

@SpringBootApplication
@EnableConfigServer
public class ConfigserverApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConfigserverApplication.class, args);
   }
}

Agora, inclua a configuração abaixo em seu arquivo de propriedades e substitua o arquivo application.properties no arquivo bootstrap.properties. Observe o código fornecido abaixo -

server.port = 8888
spring.cloud.config.server.native.searchLocations=file:///C:/configprop/
SPRING_PROFILES_ACTIVE=native

O servidor de configuração é executado na porta Tomcat 8888 e as propriedades de configuração do aplicativo são carregadas de locais de pesquisa nativos.

Agora em file:///C:/configprop/, coloque seu aplicativo cliente - arquivo application.properties. Por exemplo, o nome do seu aplicativo cliente éconfig-client, então renomeie seu arquivo application.properties como config-client.properties e coloque o arquivo de propriedades no caminho file:///C:/configprop/.

O código para o arquivo de propriedades do cliente de configuração é fornecido abaixo -

welcome.message = Welcome to Spring cloud config server

O arquivo de configuração de compilação completo é fornecido abaixo -

Os usuários Maven podem usar pom.xml dado abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>configserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>configserver</name>
   <description>Demo project for Spring Boot</description>
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-config-server</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Os usuários do Gradle podem usar o arquivo build.gradle fornecido abaixo -

<scope>import</scope>
</dependency>
</dependencies>
buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('org.springframework.cloud:spring-cloud-config-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Agora, crie um arquivo JAR executável e execute o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle -

Para Maven, use o comando fornecido abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando fornecido abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta Tomcat 8888, conforme mostrado aqui -

Agora acesse o URL http://localhost:8888/config-client/default/master no navegador da web e você pode ver as propriedades de configuração do aplicativo config-client, conforme mostrado aqui.

Alguns aplicativos podem precisar de propriedades de configuração que podem precisar de uma mudança e os desenvolvedores podem precisar desativá-los ou reiniciar o aplicativo para fazer isso. No entanto, isso pode levar a um tempo de inatividade na produção e à necessidade de reiniciar o aplicativo. O Spring Cloud Configuration Server permite que os desenvolvedores carreguem as novas propriedades de configuração sem reiniciar o aplicativo e sem qualquer tempo de inatividade.

Trabalhando com Spring Cloud Configuration Server

Primeiro, baixe o projeto Spring Boot em https://start.spring.io/e escolha a dependência do cliente Spring Cloud Config. Agora, adicione a dependência Spring Cloud Starter Config em seu arquivo de configuração de compilação.

Os usuários do Maven podem adicionar a seguinte dependência ao arquivo pom.xml.

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência ao build.gradle Arquivo.

compile('org.springframework.cloud:spring-cloud-starter-config')

Agora, você precisa adicionar a anotação @RefreshScope ao seu aplicativo Spring Boot principal. A anotação @RefreshScope é usada para carregar o valor das propriedades de configuração do servidor de configuração.

package com.example.configclient;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;

@SpringBootApplication
@RefreshScope
public class ConfigclientApplication {
   public static void main(String[] args) {
      SpringApplication.run(ConfigclientApplication.class, args);
   }
}

Agora, inclua a URL do servidor de configuração em seu arquivo application.properties e forneça o nome de seu aplicativo.

Note - http: // localhost: 8888 config server deve ser executado antes de iniciar o aplicativo cliente de configuração.

spring.application.name = config-client
spring.cloud.config.uri = http://localhost:8888

O código para escrever um endpoint REST simples para ler a mensagem de boas-vindas do servidor de configuração é fornecido abaixo -

package com.example.configclient;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RefreshScope
@RestController
public class ConfigclientApplication {
   @Value("${welcome.message}")
   String welcomeText;
   
   public static void main(String[] args) {
      SpringApplication.run(ConfigclientApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String welcomeText() {
      return welcomeText;
   }
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle -

Para Maven, você pode usar o comando mostrado abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando mostrado abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando mostrado aqui:

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta 8080 do Tomcat, conforme mostrado aqui -

Você pode ver a janela do console de login; aplicativo cliente de configuração está buscando a configuração dohttps://localhost:8888

2017-12-08 12:41:57.682  INFO 1104 --- [           
   main] c.c.c.ConfigServicePropertySourceLocator : 
   Fetching config from server at: http://localhost:8888

Agora acesse o URL, http://localhost:8080/ A mensagem de boas-vindas é carregada do servidor de configuração.

Agora, vá e altere o valor da propriedade no servidor de configuração e acesse a URL de POST do endpoint do atuador http://localhost:8080/refresh e veja o novo valor da propriedade de configuração no URL http://localhost:8080/

O Spring Boot Actuator fornece pontos de extremidade protegidos para monitorar e gerenciar seu aplicativo Spring Boot. Por padrão, todos os terminais do atuador são protegidos. Neste capítulo, você aprenderá em detalhes sobre como habilitar o atuador Spring Boot para seu aplicativo.

Ativando Spring Boot Actuator

Para habilitar pontos de extremidade do atuador Spring Boot para seu aplicativo Spring Boot, precisamos adicionar a dependência do atuador Spring Boot Starter em nosso arquivo de configuração de compilação.

Os usuários do Maven podem adicionar a dependência abaixo em seu arquivo pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a dependência abaixo em seu arquivo build.gradle.

compile group: 'org.springframework.boot', name: 'spring-boot-starter-actuator'

No arquivo application.properties, precisamos desabilitar a segurança para terminais do atuador.

management.security.enabled = false

Os usuários do arquivo YAML podem adicionar a seguinte propriedade em seu arquivo application.yml.

management:
   security:
      enabled: false

Se desejar usar o número da porta separada para acessar os terminais do atuador de inicialização Spring, inclua o número da porta de gerenciamento no arquivo application.properties.

management.port = 9000

Os usuários do arquivo YAML podem adicionar a seguinte propriedade em seu arquivo application.yml.

management:
   port: 9000

Agora, você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Para Maven, você pode usar o seguinte comando -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o seguinte comando -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, você pode executar o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta 8080 do Tomcat. Observe que se você especificou o número da porta de gerenciamento, o mesmo aplicativo está sendo executado em dois números de porta diferentes.

Alguns endpoints importantes do Spring Boot Actuator são fornecidos abaixo. Você pode inseri-los no navegador da web e monitorar o comportamento do aplicativo.

ENDPOINTS	USO
/Métricas	Para visualizar as métricas do aplicativo, como memória usada, memória livre, threads, classes, tempo de atividade do sistema etc.
/ env	Para visualizar a lista de variáveis ​​de ambiente usadas no aplicativo.
/feijões	Para visualizar os beans Spring e seus tipos, escopos e dependências.
/saúde	Para ver a saúde do aplicativo
/ info	Para visualizar as informações sobre o aplicativo Spring Boot.
/vestígio	Para visualizar a lista de rastros de seus pontos de extremidade de descanso.

Monitorar seu aplicativo usando Spring Boot Actuator Endpoint é um pouco difícil. Porque, se você tiver 'n' número de aplicativos, cada aplicativo terá terminais de atuador separados, tornando o monitoramento difícil. Spring Boot Admin Server é um aplicativo usado para gerenciar e monitorar seu aplicativo Microservice.

Para lidar com tais situações, CodeCentric Team fornece um Spring Boot Admin UI para gerenciar e monitorar todos os endpoints do seu aplicativo Spring Boot Actuator em um só lugar.

Para construir um Spring Boot Admin Server, precisamos adicionar as dependências abaixo em seu arquivo de configuração de construção.

Os usuários do Maven podem adicionar as dependências abaixo em seu arquivo pom.xml -

<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-server</artifactId>
   <version>1.5.5</version>
</dependency>
<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-server-ui</artifactId>
   <version>1.5.5</version>
</dependency>

Os usuários do Gradle podem adicionar as dependências abaixo em seu arquivo build.gradle -

compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'

Adicione a anotação @EnableAdminServer em seu arquivo de classe do aplicativo Spring Boot principal. A anotação @EnableAdminServer é usada para torná-lo um servidor de administração para monitorar todos os outros microsserviços.

package com.tutorialspoint.adminserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import de.codecentric.boot.admin.config.EnableAdminServer;

@SpringBootApplication
@EnableAdminServer
public class AdminserverApplication {   
   public static void main(String[] args) {
      SpringApplication.run(AdminserverApplication.class, args);
   }
}

Agora, defina o server.port e o nome do aplicativo no arquivo application.properties mostrado -

server.port = 9090
spring.application.name = adminserver

Para usuários YAML, use as seguintes propriedades para definir o número da porta e o nome do aplicativo no arquivo application.yml.

server:
   port: 9090
spring:
   application:
      name: adminserver

O arquivo de configuração da construção é fornecido abaixo.

For Maven users – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>adminserver</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>adminserver</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>

      <dependency>
         <groupId>de.codecentric</groupId>
         <artifactId>spring-boot-admin-server</artifactId>
         <version>1.5.5</version>
      </dependency>
      
      <dependency>
         <groupId>de.codecentric</groupId>
         <artifactId>spring-boot-admin-server-ui</artifactId>
         <version>1.5.5</version>
      </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>

For Gradle users – build.gradle file

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
repositories {   
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'de.codecentric', name: 'spring-boot-admin-server', version: '1.5.5'
   compile group: 'de.codecentric', name: 'spring-boot-admin-server-ui', version: '1.5.5'   
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle -

Para Maven, use o comando mostrado aqui -

mvn clean install

Depois de “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando mostrado aqui -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando fornecido abaixo -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta Tomcat 9090, conforme mostrado aqui -

Agora acesse a URL abaixo no seu navegador e veja a interface do usuário do Admin Server.

http://localhost:9090/

Para monitorar e gerenciar seu aplicativo de microsserviço por meio do Spring Boot Admin Server, você deve adicionar a dependência do cliente inicial Spring Boot Admin e apontar o URI do Admin Server no arquivo de propriedades do aplicativo.

Note - Para monitorar um aplicativo, você deve habilitar o Spring Boot Actuator Endpoints para seu aplicativo de microsserviço.

Primeiro, adicione a seguinte dependência do cliente inicial Spring Boot Admin e a dependência do atuador inicial Spring Boot em seu arquivo de configuração de compilação.

Os usuários Maven podem adicionar as seguintes dependências em seu arquivo pom.xml -

<dependency>
   <groupId>de.codecentric</groupId>
   <artifactId>spring-boot-admin-starter-client</artifactId>
   <version>1.5.5</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

Os usuários do Gradle podem adicionar as seguintes dependências em seu arquivo build.gradle.

compile group: 'de.codecentric', name: 'spring-boot-admin-starter-client', version: '1.5.5'
compile('org.springframework.boot:spring-boot-starter-actuator')

Agora, adicione a URL do Spring Boot Admin Server ao arquivo de propriedades do aplicativo.

Para usuários do arquivo de propriedades, inclua as propriedades a seguir no arquivo application.properties.

spring.boot.admin.url = http://localhost:9090/

Para usuários YAML, adicione a seguinte propriedade no arquivo application.yml.

spring:
   boot:
      admin:
         url: http://localhost:9000/

Agora, crie um arquivo JAR executável e execute o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Para Maven, você pode usar o comando conforme mostrado -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando mostrado -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta Tomcat 9090 conforme mostrado -

Agora acesse a seguinte URL em seu navegador e veja que seu aplicativo Spring Boot está registrado no Spring Boot Admin Server.

http://localhost:9090/

Agora, clique no Details botão e ver os endpoints do atuador na interface do usuário do Admin Server.

Swagger2 é um projeto de código aberto usado para gerar os documentos da API REST para serviços da web RESTful. Ele fornece uma interface de usuário para acessar nossos serviços da Web RESTful por meio do navegador.

Para habilitar o Swagger2 no aplicativo Spring Boot, você precisa adicionar as seguintes dependências em nosso arquivo de configurações de construção.

<dependency>
   <groupId>io.springfox</groupId>
   <artifactId>springfox-swagger2</artifactId>
   <version>2.7.0</version>
</dependency>
<dependency>
   <groupId>io.springfox</groupId>
   <artifactId>springfox-swagger-ui</artifactId>
   <version>2.7.0</version>
</dependency>

Para usuários do Gradle, adicione as seguintes dependências em seu arquivo build.gradle.

compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'

Agora, adicione a anotação @ EnableSwagger2 em seu aplicativo Spring Boot principal. A anotação @ EnableSwagger2 é usada para habilitar o Swagger2 para seu aplicativo Spring Boot.

O código do aplicativo Spring Boot principal é mostrado abaixo -

package com.tutorialspoint.swaggerdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SwaggerDemoApplication.class, args);
   }
}

Em seguida, crie Docket Bean para configurar o Swagger2 para seu aplicativo Spring Boot. Precisamos definir o pacote base para configurar API (s) REST para Swagger2.

@Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }

Agora, adicione este bean no próprio arquivo de classe do aplicativo Spring Boot principal e sua classe de aplicativo Spring Boot principal terá a aparência mostrada abaixo -

package com.tutorialspoint.swaggerdemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;

import springfox.documentation.builders.RequestHandlerSelectors;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

@SpringBootApplication
@EnableSwagger2
public class SwaggerDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(SwaggerDemoApplication.class, args);
   }
   @Bean
   public Docket productApi() {
      return new Docket(DocumentationType.SWAGGER_2).select()
         .apis(RequestHandlerSelectors.basePackage("com.tutorialspoint.swaggerdemo")).build();
   }
}

Agora, adicione a dependência Spring Boot Starter Web abaixo em seu arquivo de configuração de compilação para escrever Endpoints REST conforme mostrado abaixo -

Os usuários Maven podem adicionar a seguinte dependência em seu arquivo pom.xml -

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência no arquivo build.gradle -

compile('org.springframework.boot:spring-boot-starter-web')

Agora, o código para construir dois serviços web RESTful simples GET e POST no arquivo Rest Controller é mostrado aqui -

package com.tutorialspoint.swaggerdemo;

import java.util.ArrayList;
import java.util.List;

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

@RestController
public class SwaggerAPIController {
   @RequestMapping(value = "/products", method = RequestMethod.GET)
   public List<String> getProducts() {
      List<String> productsList = new ArrayList<>();
      productsList.add("Honey");
      productsList.add("Almond");
      return productsList;
   }
   @RequestMapping(value = "/products", method = RequestMethod.POST)
   public String createProduct() {
      return "Product is saved successfully";
   }
}

O arquivo de configuração de compilação completo é fornecido abaixo -

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com.tutorialspoint</groupId>
   <artifactId>swagger-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>swagger-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <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>
      
      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger2</artifactId>
         <version>2.7.0</version>
      </dependency>

      <dependency>
         <groupId>io.springfox</groupId>
         <artifactId>springfox-swagger-ui</artifactId>
         <version>2.7.0</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
} dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: 'io.springfox', name: 'springfox-swagger2', version: '2.7.0'
   compile group: 'io.springfox', name: 'springfox-swagger-ui', version: '2.7.0'
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Para Maven, você pode usar o comando mostrado aqui -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando conforme mostrado aqui -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando mostrado aqui -

java –jar <JARFILE>

Agora, o aplicativo será iniciado na porta 8080 do Tomcat, conforme mostrado -

Agora, acesse a URL em seu navegador da web e veja as funcionalidades da API Swagger.

http://localhost:8080/swagger-ui.html

Docker é um serviço de gerenciamento de contêineres que facilita a construção e implantação. Se você é um iniciante no Docker, você pode aprender mais sobre ele neste link -https://www.tutorialspoint.com/docker/index.htm

Neste capítulo, veremos Como criar uma imagem Docker usando dependências Maven e Gradle para seu aplicativo Spring Boot.

Criar Dockerfile

Primeiro, crie um arquivo com o nome Dockerfile sob os diretórios src/main/dockercom o conteúdo mostrado abaixo. Observe que esse arquivo é importante para criar uma imagem Docker.

FROM java:8
VOLUME /tmp
ADD dockerapp-0.0.1-SNAPSHOT.jar app.jar
RUN bash -c 'touch /app.jar'
ENTRYPOINT ["java","-Djava.security.egd=file:/dev/./urandom","-jar","/app.jar"]

Maven

Para Maven, adicione o plugin Docker Maven em seu arquivo de configuração de compilação pom.xml

<properties>
   <docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
</properties>

<build>
   <plugins>
      <plugin>
         <groupId>com.spotify</groupId>
         <artifactId>docker-maven-plugin</artifactId>
         <version>1.0.0</version>
         
         <configuration>
            <imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
                  <include>${project.build.finalName}.jar</include>
               </resource>
            </resources>
         </configuration>
      </plugin>
      
      <plugin>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
   </plugins>
   
</build>

O arquivo pom.xml completo é fornecido abaixo -

<?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>com.tutorialspoint</groupId>
   <artifactId>dockerapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>dockerapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <docker.image.prefix>spring-boot-tutorialspoint</docker.image.prefix>
   </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>com.spotify</groupId>
            <artifactId>docker-maven-plugin</artifactId>
            <version>1.0.0</version>
            
            <configuration>
               <imageName>${docker.image.prefix}/${project.artifactId}</imageName> <dockerDirectory>src/main/docker</dockerDirectory> <resources> <resource> <directory>${project.build.directory}</directory>
                     <include>${project.build.finalName}.jar</include>
                  </resource>
               </resources>
            </configuration>
         </plugin>
         
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Agora, você pode executar seu aplicativo usando o comando Maven mvn package docker:build

Note - Habilite o daemon Expose em tcp://localhost:2375 sem TLS.

Após o sucesso da construção, você pode ver a saída no console, conforme mostrado abaixo -

Agora, veja as imagens do Docker pelo comando usando imagens do docker e veja as informações da imagem no console.

Gradle

Para construir uma imagem Docker usando a configuração de compilação do Gradle, precisamos adicionar o docker plugin e precisa escrever uma tarefa buildDocker para criar uma imagem Docker.

O código para a configuração do Gradle Docker é fornecido abaixo.

buildscript {
   .....
   dependencies {
      .....
      classpath('se.transmode.gradle:gradle-docker:1.2')
   }
}

group = 'spring-boot-tutorialspoint'

.....
apply plugin: 'docker'

task buildDocker(type: Docker, dependsOn: build) {
   applicationName = jar.baseName
   dockerfile = file('src/main/docker/Dockerfile')
   doFirst {
      copy {
         from jar
         into stageDir
      }
   }
}

O arquivo build.gradle completo é fornecido abaixo.

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
      classpath('se.transmode.gradle:gradle-docker:1.2')
   }
}

group = 'spring-boot-tutorialspoint'

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'docker'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
task buildDocker(type: Docker, dependsOn: build) {
   applicationName = jar.baseName
   dockerfile = file('src/main/docker/Dockerfile')
   doFirst {
      copy {
         from jar
         into stageDir
      }
   }
}

Agora, crie uma imagem Docker usando o comando mostrado abaixo -

gradle build buildDocker

Depois de executar o comando, você pode ver o log BUILD SUCCESSFUL na janela do console.

Agora, veja as imagens do Docker pelo comando usando docker images e veja as informações da imagem no console.

A maioria dos desenvolvedores enfrenta dificuldade para rastrear logs se ocorrer algum problema. Isso pode ser resolvido pelo servidor Spring Cloud Sleuth e ZipKin para o aplicativo Spring Boot.

Spring Cloud Sleuth

Os registros do Spring cloud Sleuth são impressos no seguinte formato -

[application-name,traceid,spanid,zipkin-export]

Onde,

• Application-name = Nome do aplicativo

• Traceid = cada traceid de solicitação e resposta é o mesmo ao chamar o mesmo serviço ou um serviço para outro serviço.

• Spanid = Span Id é impresso junto com o Trace Id. O Span Id é diferente a cada solicitação e resposta que chama um serviço para outro serviço.

• Zipkin-export = Por padrão, é falso. Se for verdade, os logs serão exportados para o servidor Zipkin.

Agora, adicione a dependência Spring Cloud Starter Sleuth em seu arquivo de configuração de compilação da seguinte maneira -

Os usuários Maven podem adicionar a seguinte dependência em seu arquivo pom.xml -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência em seu arquivo build.gradle -

compile('org.springframework.cloud:spring-cloud-starter-sleuth')

Agora, adicione os Logs em seu arquivo de classe Rest Controller do aplicativo Spring Boot, conforme mostrado aqui -

package com.tutorialspoint.sleuthapp;

import java.util.logging.Level;
import java.util.logging.Logger;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class SleuthappApplication {
   private static final Logger LOG = Logger.getLogger(SleuthappApplication.class.getName());
   public static void main(String[] args) {
      SpringApplication.run(SleuthappApplication.class, args);
   }
   @RequestMapping("/")
   public String index() {
      LOG.log(Level.INFO, "Index API is calling");
      return "Welcome Sleuth!";
   }
}

Agora, adicione o nome do aplicativo no arquivo application.properties conforme mostrado -

spring.application.name = tracinglogs

O código completo para o arquivo de configuração do build é fornecido abaixo -

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>sleuthapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>sleuthapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-sleuth</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>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-sleuth')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Para Maven, você pode usar o seguinte comando -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o seguinte comando -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando mostrado aqui -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta 8080 do Tomcat.

Agora, acesse a URL em seu navegador da web e veja a saída no log do console.

http://localhost:8080/

Você pode ver os seguintes logs na janela do console. Observe que o log é impresso no seguinte formato [application-name, traceid, spanid, zipkin-export]

Servidor Zipkin

Zipkin é um aplicativo que monitora e gerencia os logs do Spring Cloud Sleuth do seu aplicativo Spring Boot. Para construir um servidor Zipkin, precisamos adicionar as dependências da IU do Zipkin e do servidor Zipkin em nosso arquivo de configuração de construção.

Os usuários Maven podem adicionar a seguinte dependência em seu arquivo pom.xml -

<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-server</artifactId>
</dependency>
<dependency>
   <groupId>io.zipkin.java</groupId>
   <artifactId>zipkin-autoconfigure-ui</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a dependência abaixo em seu arquivo build.gradle -

compile('io.zipkin.java:zipkin-autoconfigure-ui')
compile('io.zipkin.java:zipkin-server')

Agora, configure server.port = 9411 no arquivo de propriedades do aplicativo.

Para usuários do arquivo de propriedades, inclua a propriedade abaixo no arquivo application.properties.

server.port = 9411

Para usuários YAML, adicione a propriedade abaixo no arquivo application.yml.

server:
   port: 9411

Adicione a anotação @EnableZipkinServer em seu arquivo de classe de aplicativo Spring Boot principal. A anotação @EnableZipkinServer é usada para permitir que seu aplicativo atue como um servidor Zipkin.

package com.tutorialspoint.zipkinapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import zipkin.server.EnableZipkinServer;

@SpringBootApplication
@EnableZipkinServer
public class ZipkinappApplication {
   public static void main(String[] args) {
      SpringApplication.run(ZipkinappApplication.class, args);
   }
}

O código para o arquivo de configuração de compilação completo é fornecido abaixo.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>zipkinapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>zipkinapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>io.zipkin.java</groupId>
         <artifactId>zipkin-server</artifactId>
      </dependency>
      <dependency>
         <groupId>io.zipkin.java</groupId>
         <artifactId>zipkin-autoconfigure-ui</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}") } } apply plugin: 'java' apply plugin: 'eclipse' apply plugin: 'org.springframework.boot' group = 'com.tutorialspoint' version = '0.0.1-SNAPSHOT' sourceCompatibility = 1.8 repositories { mavenCentral() } ext { springCloudVersion = 'Edgware.RELEASE' } dependencies { compile('io.zipkin.java:zipkin-autoconfigure-ui') compile('io.zipkin.java:zipkin-server') testCompile('org.springframework.boot:spring-boot-starter-test') } dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle abaixo -

Para Maven, use o comando fornecido abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando fornecido abaixo -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o comando mostrado -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta Tomcat 9411 conforme mostrado abaixo -

Agora, acesse o URL abaixo e veja a IU do servidor Zipkin.

http://localhost:9411/zipkin/

Em seguida, adicione a seguinte dependência em seu aplicativo de serviço ao cliente e aponte o URL do servidor Zipkin para rastrear os registros de microsserviço por meio da IU do Zipkin.

Agora, adicione a dependência Spring Cloud Starter Zipkin em seu arquivo de configuração de compilação, conforme mostrado -

Os usuários Maven podem adicionar a seguinte dependência no arquivo pom.xml -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a dependência abaixo no arquivo build.gradle -

compile('org.springframework.cloud:spring-cloud-sleuth-zipkin')

Agora, adicione o Always Sampler Bean em seu aplicativo Spring Boot para exportar os logs para o servidor Zipkin.

@Bean
public AlwaysSampler defaultSampler() {
   return new AlwaysSampler();
}

Se você adicionar o Feijão AlwaysSampler, a opção Exportar Spring Sleuth Zipkin automaticamente mudará de falso para verdadeiro.

Em seguida, configure o URL base do Zipkin Server no arquivo application.properties de serviço do cliente.

spring.zipkin.baseUrl = http://localhost:9411/zipkin/

Em seguida, forneça o id de rastreamento e encontre os rastreamentos na IU do Zipkin.

http://localhost:9411/zipkin/traces/{traceid}/

Flyway é um aplicativo de controle de versão para desenvolver seu esquema de banco de dados de maneira fácil e confiável em todas as suas instâncias. Para saber mais sobre a Flyway, você pode usar o link - www.flywaydb.org

Muitos projetos de software usam bancos de dados relacionais. Isso requer a manipulação de migrações de banco de dados, também frequentemente chamadas de migrações de esquema.

Neste capítulo, você aprenderá em detalhes sobre como configurar o banco de dados Flyway em seu aplicativo Spring Boot.

Configurando Banco de Dados Flyway

Primeiro, baixe o projeto Spring Boot na página do Spring Initializer www.start.spring.io e escolha as seguintes dependências -

• Spring Boot Starter Web
• Flyway
• MySQL
• JDBC

Os usuários do Maven podem adicionar as seguintes dependências no arquivo pom.xml.

<dependency>
   <groupId>org.flywaydb</groupId>
   <artifactId>flyway-core</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Os usuários do Gradle podem adicionar as seguintes dependências no arquivo build.gradle.

compile('org.flywaydb:flyway-core')
compile('org.springframework.boot:spring-boot-starter-jdbc')
compile('org.springframework.boot:spring-boot-starter-web')
compile('mysql:mysql-connector-java')

Nas propriedades do aplicativo, precisamos configurar as propriedades do banco de dados para a criação de um DataSource e também as propriedades flyway que precisamos configurar nas propriedades do aplicativo.

Para usuários do arquivo de propriedades, inclua as propriedades abaixo no arquivo application.properties.

spring.application.name = flywayapp  

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000

flyway.url = jdbc:mysql://localhost:3306/mysql
flyway.schemas = USERSERVICE
flyway.user = root
flyway.password = root

Os usuários YAML podem adicionar as seguintes propriedades no arquivo application.yml.

spring:
   application:
      name: flywayapp  
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000
flyway:
   url: jdbc:mysql://localhost:3306/mysql
   schemas: USERSERVICE
   user: "root"
   password: "root"

Agora, crie um arquivo SQL sob o src/main/resources/db/migrationdiretório. Nomeie o arquivo SQL como “V1__Initial.sql”

CREATE TABLE USERS (ID INT AUTO_INCREMENT PRIMARY KEY, USERID VARCHAR(45));
INSERT INTO USERS (ID, USERID) VALUES (1, 'tutorialspoint.com');

O código do arquivo de classe do aplicativo Spring Boot principal é fornecido abaixo -

package com.tutorialspoint.flywayapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O arquivo de configuração de compilação completo é fornecido abaixo.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>flywayapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>flywayapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.flywaydb</groupId>
         <artifactId>flyway-core</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>

      <dependency>
         <groupId>mysql</groupId>
         <artifactId>mysql-connector-java</artifactId>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.flywaydb:flyway-core')
   compile('org.springframework.boot:spring-boot-starter-jdbc')
   compile('org.springframework.boot:spring-boot-starter-web')
   compile('mysql:mysql-connector-java')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle fornecidos abaixo -

Para Maven, você pode usar o comando mostrado aqui -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando mostrado aqui -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o seguinte comando -

java –jar <JARFILE>

Agora, o Tomcat começou na porta 8080 e na janela do console você pode ver os logs do banco de dados flyway conforme mostrado aqui.

Agora você pode ir ao banco de dados e fazer as consultas selecionadas.

Usando o serviço da web Spring Boot RESTful, você pode enviar um e-mail com o Gmail Transport Layer Security. Neste capítulo, vamos entender em detalhes como usar esse recurso.

Primeiro, precisamos adicionar a dependência Spring Boot Starter Mail em seu arquivo de configuração de compilação.

Os usuários do Maven podem adicionar a seguinte dependência ao arquivo pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-mail</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência ao seu arquivo build.gradle.

compile('org.springframework.boot:spring-boot-starter-mail')

O código do arquivo de classe do aplicativo Spring Boot principal é fornecido abaixo -

package com.tutorialspoint.emailapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Você pode escrever uma API Rest simples para enviar por e-mail no arquivo de classe Rest Controller, conforme mostrado.

package com.tutorialspoint.emailapp;

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

@RestController
public class EmailController {
   @RequestMapping(value = "/sendemail")
   public String sendEmail() {
      return "Email sent successfully";
   }   
}

Você pode escrever um método para enviar o e-mail com anexo. Defina as propriedades mail.smtp e use PasswordAuthentication.

private void sendmail() throws AddressException, MessagingException, IOException {
   Properties props = new Properties();
   props.put("mail.smtp.auth", "true");
   props.put("mail.smtp.starttls.enable", "true");
   props.put("mail.smtp.host", "smtp.gmail.com");
   props.put("mail.smtp.port", "587");
   
   Session session = Session.getInstance(props, new javax.mail.Authenticator() {
      protected PasswordAuthentication getPasswordAuthentication() {
         return new PasswordAuthentication("[email protected]", "<your password>");
      }
   });
   Message msg = new MimeMessage(session);
   msg.setFrom(new InternetAddress("[email protected]", false));

   msg.setRecipients(Message.RecipientType.TO, InternetAddress.parse("[email protected]"));
   msg.setSubject("Tutorials point email");
   msg.setContent("Tutorials point email", "text/html");
   msg.setSentDate(new Date());

   MimeBodyPart messageBodyPart = new MimeBodyPart();
   messageBodyPart.setContent("Tutorials point email", "text/html");

   Multipart multipart = new MimeMultipart();
   multipart.addBodyPart(messageBodyPart);
   MimeBodyPart attachPart = new MimeBodyPart();

   attachPart.attachFile("/var/tmp/image19.png");
   multipart.addBodyPart(attachPart);
   msg.setContent(multipart);
   Transport.send(msg);   
}

Agora, chame o método sendmail () acima da API Rest como mostrado -

@RequestMapping(value = "/sendemail")
public String sendEmail() throws AddressException, MessagingException, IOException {
   sendmail();
   return "Email sent successfully";   
}

Note - LIGUE para permitir aplicativos menos seguros nas configurações da sua conta do Gmail antes de enviar um e-mail.

O arquivo de configuração de compilação completo é fornecido abaixo.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>emailapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>emailapp</name>
   <description>Demo project for Spring Boot</description>
   
   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>
   
   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
   <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-mail</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</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>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   compile('org.springframework.boot:spring-boot-starter-mail')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Agora, você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle mostrados abaixo -

Para Maven, você pode usar o comando conforme mostrado -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando fornecido abaixo -

java –jar <JARFILE>

Você pode ver que o aplicativo foi iniciado na porta 8080 do Tomcat.

Agora acesse a seguinte URL em seu navegador da web e você receberá um e-mail.

http://localhost:8080/sendemail

Hystrix é uma biblioteca da Netflix. Hystrix isola os pontos de acesso entre os serviços, interrompe as falhas em cascata entre eles e fornece as opções de fallback.

Por exemplo, quando você está chamando a 3 ^rd aplicativo partido, é preciso mais tempo para enviar a resposta. Então, nesse momento, o controle vai para o método de fallback e retorna a resposta customizada para seu aplicativo.

Neste capítulo, você verá como implementar o Hystrix em um aplicativo Spring Boot.

Primeiro, precisamos adicionar a dependência Spring Cloud Starter Hystrix em nosso arquivo de configuração de compilação.

Os usuários do Maven podem adicionar a seguinte dependência no arquivo pom.xml -

<dependency>
   <groupId>org.springframework.cloud</groupId>
   <artifactId>spring-cloud-starter-hystrix</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência no arquivo build.gradle -

compile('org.springframework.cloud:spring-cloud-starter-hystrix')

Agora, adicione a anotação @EnableHystrix em seu arquivo de classe de aplicativo Spring Boot principal. A anotação @EnableHystrix é usada para habilitar as funcionalidades Hystrix em seu aplicativo Spring Boot.

O código do arquivo de classe do aplicativo Spring Boot principal é fornecido abaixo -

package com.tutorialspoint.hystrixapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;

@SpringBootApplication
@EnableHystrix
public class HystrixappApplication {
   public static void main(String[] args) {
      SpringApplication.run(HystrixappApplication.class, args);
   }
}

Agora escreva um Controlador de Rest simples de forma que ele retorne a String após 3 segundos do tempo solicitado.

@RequestMapping(value = "/")
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}

Agora, adicione o comando @Hystrix e @HystrixProperty para a API Rest e defina o valor de tempo limite em milissegundos.

@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})

Em seguida, defina o método fallback fallback_hello () se a solicitação demorar para responder.

private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

O arquivo de classe Rest Controller completo que contém propriedades REST API e Hystrix é mostrado aqui -

@RequestMapping(value = "/")
@HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
   @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
})
public String hello() throws InterruptedException {
   Thread.sleep(3000);
   return "Welcome Hystrix";
}
private String fallback_hello() {
   return "Request fails. It takes long time to response";
}

Neste exemplo, a API REST escrita no próprio arquivo de classe do aplicativo Spring Boot principal.

package com.tutorialspoint.hystrixapp;

import org.springframework.boot.SpringApplication;
import com.netflix.hystrix.contrib.javanica.annotation.HystrixProperty;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.hystrix.EnableHystrix;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand;

@SpringBootApplication
@EnableHystrix
@RestController
public class HystrixappApplication {
   public static void main(String[] args) {
      SpringApplication.run(HystrixappApplication.class, args);
   }
   @RequestMapping(value = "/")
   @HystrixCommand(fallbackMethod = "fallback_hello", commandProperties = {
      @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "1000")
   })
   public String hello() throws InterruptedException {
      Thread.sleep(3000);
      return "Welcome Hystrix";
   }
   private String fallback_hello() {
      return "Request fails. It takes long time to response";
   }
}

O arquivo de configuração de compilação completo é fornecido abaixo.

Maven – pom.xml file

<?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>com.tutorialspoint</groupId>
   <artifactId>hystrixapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>hystrixapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
      <spring-cloud.version>Edgware.RELEASE</spring-cloud.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.cloud</groupId>
         <artifactId>spring-cloud-starter-hystrix</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>
      </dependency>
   </dependencies>

   <dependencyManagement>
      <dependencies>
         <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
         </dependency>
      </dependencies>
   </dependencyManagement>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
ext {
   springCloudVersion = 'Edgware.RELEASE'
}
dependencies {
   compile('org.springframework.cloud:spring-cloud-starter-hystrix')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}
dependencyManagement {
   imports {
      mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
   }
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle -

Para Maven, use o comando conforme mostrado -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando fornecido abaixo -

java –jar <JARFILE>

Isso iniciará o aplicativo na porta 8080 do Tomcat, conforme mostrado abaixo -

Agora, acesse o URL http://localhost:8080/em seu navegador da web e veja a resposta do Hystrix. A API leva 3 segundos para responder, mas o tempo limite do Hystrix é de 1 segundo.

Neste capítulo, vamos entender como construir uma aplicação web interativa usando Spring Boot com Web sockets.

Para construir um aplicativo da web interativo no Spring Boot com Web socket, você precisa adicionar as seguintes dependências.

Os usuários do Maven devem adicionar as seguintes dependências no arquivo pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>webjars-locator</artifactId>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>sockjs-client</artifactId>
   <version>1.0.2</version>
</dependency>

<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>stomp-websocket</artifactId>
   <version>2.3.3</version>
</dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>bootstrap</artifactId>
   <version>3.3.7</version>        </dependency>
<dependency>
   <groupId>org.webjars</groupId>
   <artifactId>jquery</artifactId>
   <version>3.1.0</version>
</dependency>

Os usuários do Gradle podem adicionar as seguintes dependências em seu arquivo build.gradle -

compile("org.springframework.boot:spring-boot-starter-websocket")
compile("org.webjars:webjars-locator")
compile("org.webjars:sockjs-client:1.0.2")
compile("org.webjars:stomp-websocket:2.3.3")
compile("org.webjars:bootstrap:3.3.7")
compile("org.webjars:jquery:3.1.0")

Vamos criar um controlador de tratamento de mensagens para trabalhar com mensagens STOMP. As mensagens STOMP podem ser roteadas para o arquivo de classe @Controller. Por exemplo, GreetingController é mapeado para lidar com as mensagens para o destino “/ hello”.

package com.tutorialspoint.websocketapp;

import org.springframework.messaging.handler.annotation.MessageMapping;
import org.springframework.messaging.handler.annotation.SendTo;
import org.springframework.stereotype.Controller;

@Controller
public class GreetingController {
   @MessageMapping("/hello")
   @SendTo("/topic/greetings")
   public Greeting greeting(HelloMessage message) throws Exception {
      Thread.sleep(1000); // simulated delay
      return new Greeting("Hello, " + message.getName() + "!");
   }
}

Agora, configure o Spring para mensagens STOMP. Grave um arquivo de classe WebSocketConfig que estenda a classe AbstractWebSocketMessageBrokerConfigurer conforme mostrado abaixo.

package com.tutorialspoint.websocketapp;

import org.springframework.context.annotation.Configuration;
import org.springframework.messaging.simp.config.MessageBrokerRegistry;
import org.springframework.web.socket.config.annotation.AbstractWebSocketMessageBrokerConfigurer;
import org.springframework.web.socket.config.annotation.EnableWebSocketMessageBroker;
import org.springframework.web.socket.config.annotation.StompEndpointRegistry;

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig extends AbstractWebSocketMessageBrokerConfigurer {
   @Override
   public void configureMessageBroker(MessageBrokerRegistry config) {
      config.enableSimpleBroker("/topic");
      config.setApplicationDestinationPrefixes("/app");
   }
   @Override
   public void registerStompEndpoints(StompEndpointRegistry registry) {
      registry.addEndpoint("/tutorialspoint-websocket").withSockJS();
   }
}

A anotação @EnableWebSocketMessageBroker é usada para configurar o Web socket message broker para criar terminais STOMP.

Você pode criar um arquivo cliente do navegador em src / main / resources / static / index.html como mostrado -

<!DOCTYPE html>
<html>
   <head>
      <title>Hello WebSocket</title>
      <link href = "/webjars/bootstrap/css/bootstrap.min.css" rel = "stylesheet">
      <link href = "/main.css" rel = "stylesheet">
      <script src = "/webjars/jquery/jquery.min.js"></script>
      <script src = "/webjars/sockjs-client/sockjs.min.js"></script>
      <script src = "/webjars/stomp-websocket/stomp.min.js"></script>
      <script src = "/app.js"></script>
   </head>
   
   <body>
      <noscript>
         <h2 style = "color: #ff0000">
            Seems your browser doesn't support Javascript! Websocket relies on Javascript being
            enabled. Please enable Javascript and reload this page!
         </h2>
      </noscript>
      <div id = "main-content" class = "container">
         <div class = "row">
            <div class = "col-md-6">
               <form class = "form-inline">
                  <div class = "form-group">
                     <label for = "connect">WebSocket connection:</label>
                     <button id = "connect" class = "btn btn-default" type = "submit">Connect</button>
                     <button id = "disconnect" class = "btn btn-default" type = "submit" disabled = "disabled">Disconnect
                     </button>
                  </div>
               </form>
            </div>
            
            <div class = "col-md-6">
               <form class = "form-inline">
                  <div class = "form-group">
                     <label for = "name">What is your name?</label>
                     <input type = "text" id = "name" class = "form-control" placeholder = "Your name here...">
                  </div>
                  <button id = "send" class = "btn btn-default" type = "submit">Send</button>
               </form>
            </div>
         </div>
         
         <div class  =  "row">
            <div class  =  "col-md-12">
               <table id  =  "conversation" class = "table table-striped">
                  <thead>
                     <tr>
                        <th>Greetings</th>
                     </tr>
                  </thead>
                  <tbody id  =  "greetings"></tbody>
               </table>
            </div>
         </div>
      </div>
   </body>
</html>

Vamos criar um arquivo app.js para consumir e produzir as mensagens usando STOMP.

var stompClient = null;

function setConnected(connected) {
   $("#connect").prop("disabled", connected);
   $("#disconnect").prop("disabled", !connected); if (connected) { $("#conversation").show();
   } else {
      $("#conversation").hide(); } $("#greetings").html("");
}

function connect() {
   var socket = new SockJS('/tutorialspoint-websocket');
   stompClient = Stomp.over(socket);
   stompClient.connect({}, function (frame) {
      setConnected(true);
      console.log('Connected: ' + frame);
      stompClient.subscribe('/topic/greetings', function (greeting) {
         showGreeting(JSON.parse(greeting.body).content);
      });
   });
}
function disconnect() {
   if (stompClient !== null) {
      stompClient.disconnect();
   }
   setConnected(false);
   console.log("Disconnected");
}
function sendName() {
   stompClient.send("/app/hello", {}, JSON.stringify({'name': $("#name").val()})); } function showGreeting(message) { $("#greetings").append("<tr><td>" + message + "</td></tr>");
}
$(function () { $( "form" ).on('submit', function (e) {e.preventDefault();});
   $( "#connect" ).click(function() { connect(); }); $( "#disconnect" ).click(function() { disconnect(); });
   $( "#send" ).click(function() { sendName(); });
});

O código do aplicativo Spring Boot principal é mostrado abaixo.

package com.tutorialspoint.websocketapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O arquivo de configuração de compilação completo é fornecido abaixo.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>websocketapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websocketapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
   </parent>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-websocket</artifactId>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>webjars-locator</artifactId>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>sockjs-client</artifactId>
         <version>1.0.2</version>
      </dependency>
      
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>stomp-websocket</artifactId>
         <version>2.3.3</version>
      </dependency>
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>bootstrap</artifactId>
         <version>3.3.7</version>
      </dependency>
      
      <dependency>
         <groupId>org.webjars</groupId>
         <artifactId>jquery</artifactId>
         <version>3.1.0</version>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </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>

Gradle – build.gradle

buildscript {
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:1.5.9.RELEASE")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

jar {
   baseName = 'websocketapp'
   version =  '0.1.0'
}
sourceCompatibility = 1.8
targetCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile("org.springframework.boot:spring-boot-starter-websocket")
   compile("org.webjars:webjars-locator")
   compile("org.webjars:sockjs-client:1.0.2")
   compile("org.webjars:stomp-websocket:2.3.3")
   compile("org.webjars:bootstrap:3.3.7")
   compile("org.webjars:jquery:3.1.0")

   testCompile("org.springframework.boot:spring-boot-starter-test")
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle conforme mostrado abaixo -

Para Maven, você pode usar o comando fornecido abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o comando fornecido aqui -

java –jar <JARFILE>

Agora, o aplicativo foi iniciado na porta 8080 do Tomcat, conforme mostrado.

Agora, acesse o URL http://localhost:8080/ no seu navegador da web e conecte o soquete da web e envie a saudação e receba a mensagem.

O Batch Service é um processo para executar mais de um comando em uma única tarefa. Neste capítulo, você aprenderá como criar serviço em lote em um aplicativo Spring Boot.

Vamos considerar um exemplo em que vamos salvar o conteúdo do arquivo CSV no HSQLDB.

Para criar um programa Batch Service, precisamos adicionar a dependência Spring Boot Starter Batch e a dependência HSQLDB em nosso arquivo de configuração de construção.

Os usuários do Maven podem adicionar as seguintes dependências no arquivo pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-batch</artifactId>
</dependency>
<dependency>
   <groupId>org.hsqldb</groupId>
   <artifactId>hsqldb</artifactId>
</dependency>

Os usuários do Gradle podem adicionar as seguintes dependências no arquivo build.gradle.

compile("org.springframework.boot:spring-boot-starter-batch")
compile("org.hsqldb:hsqldb")

Agora, adicione o arquivo de dados CSV simples em recursos de caminho de classe - src / main / resources e nomeie o arquivo como file.csv conforme mostrado -

William,John
Mike, Sebastian
Lawarance, Lime

Em seguida, escreva um script SQL para HSQLDB - no diretório de recursos do classpath - request_fail_hystrix_timeout

DROP TABLE USERS IF EXISTS;
CREATE TABLE USERS  (
   user_id BIGINT IDENTITY NOT NULL PRIMARY KEY,
   first_name VARCHAR(20),
   last_name VARCHAR(20)
);

Crie uma classe POJO para o modelo USERS conforme mostrado -

package com.tutorialspoint.batchservicedemo;
public class User {
   private String lastName;
   private String firstName;

   public User() {
   }
   public User(String firstName, String lastName) {
      this.firstName = firstName;
      this.lastName = lastName;
   }
   public void setFirstName(String firstName) {
      this.firstName = firstName;
   }
   public String getFirstName() {
      return firstName;
   }
   public String getLastName() {
      return lastName;
   }
   public void setLastName(String lastName) {
      this.lastName = lastName;
   }

   @Override
   public String toString() {
      return "firstName: " + firstName + ", lastName: " + lastName;
   }   
}

Agora, crie um processador intermediário para fazer as operações após a leitura dos dados do arquivo CSV e antes de gravar os dados no SQL.

package com.tutorialspoint.batchservicedemo;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.batch.item.ItemProcessor;

public class UserItemProcessor implements ItemProcessor<User, User> {
   private static final Logger log = LoggerFactory.getLogger(UserItemProcessor.class);

   @Override
   public User process(final User user) throws Exception {
      final String firstName = user.getFirstName().toUpperCase();
      final String lastName = user.getLastName().toUpperCase();
      final User transformedPerson = new User(firstName, lastName);

      log.info("Converting (" + user + ") into (" + transformedPerson + ")");
      return transformedPerson;
   }
}

Vamos criar um arquivo de configuração em lote, para ler os dados do CSV e gravar no arquivo SQL conforme mostrado abaixo. Precisamos adicionar a anotação @EnableBatchProcessing no arquivo de classe de configuração. A anotação @EnableBatchProcessing é usada para habilitar as operações em lote para seu aplicativo Spring Boot.

package com.tutorialspoint.batchservicedemo;

import javax.sql.DataSource;
import org.springframework.batch.core.Job;
import org.springframework.batch.core.Step;

import org.springframework.batch.core.configuration.annotation.EnableBatchProcessing;
import org.springframework.batch.core.configuration.annotation.JobBuilderFactory;
import org.springframework.batch.core.configuration.annotation.StepBuilderFactory;
import org.springframework.batch.core.launch.support.RunIdIncrementer;
import org.springframework.batch.item.database.BeanPropertyItemSqlParameterSourceProvider;
import org.springframework.batch.item.database.JdbcBatchItemWriter;
import org.springframework.batch.item.file.FlatFileItemReader;
import org.springframework.batch.item.file.mapping.BeanWrapperFieldSetMapper;
import org.springframework.batch.item.file.mapping.DefaultLineMapper;
import org.springframework.batch.item.file.transform.DelimitedLineTokenizer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.core.io.ClassPathResource;

@Configuration
@EnableBatchProcessing
public class BatchConfiguration {
   @Autowired
   public JobBuilderFactory jobBuilderFactory;

   @Autowired
   public StepBuilderFactory stepBuilderFactory;

   @Autowired
   public DataSource dataSource;

   @Bean
   public FlatFileItemReader<User> reader() {
      FlatFileItemReader<User> reader = new FlatFileItemReader<User>();
      reader.setResource(new ClassPathResource("file.csv"));
      reader.setLineMapper(new DefaultLineMapper<User>() {
         {
            setLineTokenizer(new DelimitedLineTokenizer() {
               {
                  setNames(new String[] { "firstName", "lastName" });
               }
            });
            setFieldSetMapper(new BeanWrapperFieldSetMapper<User>() {
               {
                  setTargetType(User.class);
               }
            });
         }
      });
      return reader;
   }
   @Bean
   public UserItemProcessor processor() {
      return new UserItemProcessor();
   }
   @Bean
   public JdbcBatchItemWriter<User> writer() {
      JdbcBatchItemWriter<User> writer = new JdbcBatchItemWriter<User>();
      writer.setItemSqlParameterSourceProvider(new BeanPropertyItemSqlParameterSourceProvider<User>());
      writer.setSql("INSERT INTO USERS (first_name, last_name) VALUES (:firstName, :lastName)");
      writer.setDataSource(dataSource);
      return writer;
   }
   @Bean
   public Job importUserJob(JobCompletionNotificationListener listener) {
      return jobBuilderFactory.get("importUserJob").incrementer(
         new RunIdIncrementer()).listener(listener).flow(step1()).end().build();
   }
   @Bean
   public Step step1() {
      return stepBuilderFactory.get("step1").<User, User>chunk(10).reader(reader()).processor(processor()).writer(writer()).build();
   }
}

o reader() O método é usado para ler os dados do arquivo CSV e o método writer () é usado para escrever os dados no SQL.

Em seguida, teremos que escrever uma classe de Listener de notificação de conclusão de trabalho - usada para notificar após a conclusão do trabalho.

package com.tutorialspoint.batchservicedemo;

import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import org.springframework.batch.core.BatchStatus;
import org.springframework.batch.core.JobExecution;
import org.springframework.batch.core.listener.JobExecutionListenerSupport;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.stereotype.Component;

@Component
public class JobCompletionNotificationListener extends JobExecutionListenerSupport {
   private static final Logger log = LoggerFactory.getLogger(JobCompletionNotificationListener.class);
   private final JdbcTemplate jdbcTemplate;

   @Autowired
   public JobCompletionNotificationListener(JdbcTemplate jdbcTemplate) {
      this.jdbcTemplate = jdbcTemplate;
   }
   @Override
   public void afterJob(JobExecution jobExecution) {
      if (jobExecution.getStatus() == BatchStatus.COMPLETED) {
         log.info("!!! JOB FINISHED !! It's time to verify the results!!");

         List<User> results = jdbcTemplate.query(
            "SELECT first_name, last_name FROM USERS", new RowMapper<User>() {
            
            @Override
            public User mapRow(ResultSet rs, int row) throws SQLException {
               return new User(rs.getString(1), rs.getString(2));
            }
         });

         for (User person : results) {
            log.info("Found <" + person + "> in the database.");
         }
      }
   }
}

Agora, crie um arquivo JAR executável e execute o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Para Maven, use o comando conforme mostrado -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o comando fornecido aqui -

java –jar <JARFILE>

Você pode ver a saída na janela do console como mostrado -

Apache Kafka é um projeto de código aberto usado para publicar e assinar as mensagens com base no sistema de mensagens tolerante a falhas. É rápido, escalonável e distribuído por design. Se você é um iniciante no Kafka, ou deseja obter um melhor entendimento sobre ele, consulte este link - www.tutorialspoint.com/apache_kafka/

Neste capítulo, veremos como implementar o Apache Kafka no aplicativo Spring Boot.

Primeiro, precisamos adicionar a dependência Spring Kafka em nosso arquivo de configuração de construção.

Os usuários do Maven podem adicionar a seguinte dependência no arquivo pom.xml.

<dependency>
   <groupId>org.springframework.kafka</groupId>
   <artifactId>spring-kafka</artifactId>
   <version>2.1.0.RELEASE</version>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência no arquivo build.gradle.

compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'

Produzindo Mensagens

Para produzir mensagens no Apache Kafka, precisamos definir a classe de configuração para a configuração do produtor, conforme mostrado -

package com.tutorialspoint.kafkademo;

import java.util.HashMap;
import java.util.Map;

import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.serialization.StringSerializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.core.DefaultKafkaProducerFactory;
import org.springframework.kafka.core.KafkaTemplate;
import org.springframework.kafka.core.ProducerFactory;

@Configuration
public class KafkaProducerConfig {
   @Bean
   public ProducerFactory<String, String> producerFactory() {
      Map<String, Object> configProps = new HashMap<>();
      configProps.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
      configProps.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
      configProps.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class);
      return new DefaultKafkaProducerFactory<>(configProps);
   }
   @Bean
   public KafkaTemplate<String, String> kafkaTemplate() {
      return new KafkaTemplate<>(producerFactory());
   }
}

Para publicar uma mensagem, conecte automaticamente o objeto Kafka Template e produza a mensagem conforme mostrado.

@Autowired
private KafkaTemplate<String, String> kafkaTemplate;
 
public void sendMessage(String msg) {
   kafkaTemplate.send(topicName, msg);
}

Consumindo uma Mensagem

Para consumir mensagens, precisamos escrever um arquivo de classe de configuração do Consumidor conforme mostrado abaixo.

package com.tutorialspoint.kafkademo;

import java.util.HashMap;
import java.util.Map;

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.common.serialization.StringDeserializer;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.kafka.annotation.EnableKafka;
import org.springframework.kafka.config.ConcurrentKafkaListenerContainerFactory;
import org.springframework.kafka.core.ConsumerFactory;
import org.springframework.kafka.core.DefaultKafkaConsumerFactory;

@EnableKafka
@Configuration
public class KafkaConsumerConfig {
   @Bean
   public ConsumerFactory<String, String> consumerFactory() {
      Map<String, Object> props = new HashMap<>();
      props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:2181");
      props.put(ConsumerConfig.GROUP_ID_CONFIG, "group-id");
      props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
      props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class);
      return new DefaultKafkaConsumerFactory<>(props);
   }
   @Bean
   public ConcurrentKafkaListenerContainerFactory<String, String> kafkaListenerContainerFactory() {
      ConcurrentKafkaListenerContainerFactory<String, String> 
      factory = new ConcurrentKafkaListenerContainerFactory<>();
      factory.setConsumerFactory(consumerFactory());
      return factory;
   }
}

Em seguida, escreva um Ouvinte para ouvir as mensagens.

@KafkaListener(topics = "tutorialspoint", groupId = "group-id")
public void listen(String message) {
   System.out.println("Received Messasge in group - group-id: " + message);
}

Vamos chamar o método sendMessage () do método de execução da classe ApplicationRunner do arquivo de classe do aplicativo Spring Boot principal e consumir a mensagem do mesmo arquivo de classe.

O código do arquivo da classe do aplicativo Spring Boot principal é fornecido abaixo -

package com.tutorialspoint.kafkademo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.kafka.annotation.KafkaListener;
import org.springframework.kafka.core.KafkaTemplate;

@SpringBootApplication
public class KafkaDemoApplication implements ApplicationRunner {
   @Autowired
   private KafkaTemplate<String, String> kafkaTemplate;

   public void sendMessage(String msg) {
      kafkaTemplate.send("tutorialspoint", msg);
   }
   public static void main(String[] args) {
      SpringApplication.run(KafkaDemoApplication.class, args);
   }
   @KafkaListener(topics = "tutorialspoint", groupId = "group-id")
   public void listen(String message) {
      System.out.println("Received Messasge in group - group-id: " + message);
   }
   @Override
   public void run(ApplicationArguments args) throws Exception {
      sendMessage("Hi Welcome to Spring For Apache Kafka");
   }
}

O código para o arquivo de configuração de compilação completo é fornecido abaixo.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>kafka-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>kafka-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.kafka</groupId>
         <artifactId>spring-kafka</artifactId>
         <version>2.1.0.RELEASE</version>
      </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>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'org.springframework.kafka', name: 'spring-kafka', version: '2.1.0.RELEASE'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Agora, crie um arquivo JAR executável e execute o aplicativo Spring Boot usando os comandos Maven ou Gradle abaixo, conforme mostrado -

Para Maven, use o comando conforme mostrado -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o comando fornecido aqui -

java –jar <JARFILE>

Você pode ver a saída na janela do console.

Twilio é um 3 ^rd aplicativo partido usado para enviar SMS e fazer chamadas de voz a partir da nossa aplicação. Permite-nos enviar SMS e fazer chamadas de voz de forma programática.

Neste capítulo, você aprenderá a implementar o envio de SMS e a realização de chamadas de voz usando Spring Boot com Twilio.

Note- Usamos a conta Trail no Twilio para enviar SMS e fazer chamadas de voz. Você pode aprender mais sobre Twilio em www.twilio.com .

Primeiro, precisamos adicionar a dependência Twilio em nosso arquivo de configuração de compilação.

Os usuários do Maven podem adicionar a seguinte dependência no arquivo pom.xml.

<dependency>
   <groupId>com.twilio.sdk</groupId>
   <artifactId>twilio</artifactId>
   <version>7.16.1</version>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência no arquivo build.gradle.

compile group: "com.twilio.sdk", name:"twilio", version: "7.16.1"

Agora, inicialize a conta Twilio com ACCOUNT_SID e AUTH_ID em bloco estático, conforme mostrado -

static {
   Twilio.init(ACCOUNT_SID, AUTH_ID);
}

Enviando SMS

Para enviar o SMS, precisamos fornecer um número de e um número para o método Message.create (). O conteúdo do corpo da mensagem também precisamos fornecer para o método Message.creator () como mostrado -

Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
   "Message from Spring Boot Application").create();

O arquivo principal da classe do aplicativo Spring Boot é mostrado abaixo.

package com.tutorialspoint.smsdemo;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Message;
import com.twilio.type.PhoneNumber;

@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
   private final static String ACCOUNT_SID = "<your-account-sid>";
   private final static String AUTH_ID = "<your-auth-id>";

   static {
      Twilio.init(ACCOUNT_SID, AUTH_ID);
   }
   public static void main(String[] args) {
      SpringApplication.run(SmsdemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      Message.creator(new PhoneNumber("to-number"), new PhoneNumber("from-number"),
         "Message from Spring Boot Application").create();
   }
}

O código completo para construir o arquivo de configuração é fornecido abaixo -

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>smsdemo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>smsdemo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>com.twilio.sdk</groupId>
         <artifactId>twilio</artifactId>
         <version>7.16.1</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"   
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle -

Para Maven, use o comando conforme mostrado -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o comando conforme fornecido abaixo -

java –jar <JARFILE>

Agora, você receberá o SMS no seu “para-número”.

Mensagem recebida para “to-number”.

Sent from your Twilio trail account
- Message from Spring Boot Application

Note- Neste exemplo, usamos a conta Trail. Portanto, você deve verificar os números antes de enviar o SMS.

Chamadas de voz

Para fazer chamadas de voz usando Twilio, precisamos chamar o método Call.creator (). Para este método, precisamos fornecer um número para, número de e nota de voz, conforme mostrado aqui.

Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
   new URI("http://demo.twilio.com/docs/voice.xml")).create();

O código do arquivo de classe do aplicativo Spring Boot principal é fornecido abaixo.

package com.tutorialspoint.smsdemo; 

import java.net.URI;

import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

import com.twilio.Twilio;
import com.twilio.rest.api.v2010.account.Call;
import com.twilio.type.PhoneNumber;

@SpringBootApplication
public class SmsdemoApplication implements ApplicationRunner {
   private final static String ACCOUNT_SID = "<ACCOUNT-SID>";
   private final static String AUTH_ID = "AUTH-ID";

   static {
      Twilio.init(ACCOUNT_SID, AUTH_ID);
   }
   public static void main(String[] args) {
      SpringApplication.run(SmsdemoApplication.class, args);
   }
   @Override
   public void run(ApplicationArguments arg0) throws Exception {
      Call.creator(new PhoneNumber("<to-number>"), new PhoneNumber("<from-number>"),
         new URI("http://demo.twilio.com/docs/voice.xml")).create();
   }
}

O código para o arquivo de configuração de compilação completo é fornecido abaixo -

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>smsdemo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>smsdemo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      <dependency>
         <groupId>com.twilio.sdk</groupId>
         <artifactId>twilio</artifactId>
         <version>7.16.1</version>
      </dependency>
   </dependencies>

   <build>
      <plugins>
         <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
         </plugin>
      </plugins>
   </build>
   
</project>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile group: "com.twilio.sdk", name:"twilio", version: "7.11.+"   
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Para Maven, use o comando conforme mostrado -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, use o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando fornecido aqui -

java –jar <JARFILE>

Agora, você receberá uma chamada para seu “número para” do Twilio.

Pressione qualquer tecla depois de atender a chamada, você ouvirá a nota de voz de https://demo.twilio.com/docs/voice.xml

Note- Neste exemplo, usamos a conta Trail. Portanto, você deve verificar os números antes de fazer chamadas.

O Teste de Unidade é um dos testes feitos pelos desenvolvedores para garantir que as unidades individuais ou as funcionalidades dos componentes estejam funcionando bem.

Neste tutorial, veremos como escrever um caso de teste de unidade usando Mockito e Web Controller.

Mockito

Para injetar Mockito Mocks em Spring Beans, precisamos adicionar a dependência do núcleo Mockito em nosso arquivo de configuração de compilação.

Os usuários do Maven podem adicionar a seguinte dependência em seu arquivo pom.xml.

<dependency>
   <groupId>org.mockito</groupId>
   <artifactId>mockito-core</artifactId>
   <version>2.13.0</version>
</dependency>
<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência no arquivo build.gradle.

compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
testCompile('org.springframework.boot:spring-boot-starter-test')

O código para escrever uma classe de serviço que contém um método que retorna o valor String é fornecido aqui.

package com.tutorialspoint.mockitodemo;

import org.springframework.stereotype.Service;

@Service
public class ProductService {
   public String getProductName() {
      return "Honey";
   } 
}

Agora, injete a classe ProductService em outro arquivo de classe de serviço, conforme mostrado.

package com.tutorialspoint.mockitodemo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
   @Autowired
   ProductService productService;

   public OrderService(ProductService productService) {
      this.productService = productService;
   }
   public String getProductName() {
      return productService.getProductName();
   }
}

O arquivo principal da classe do aplicativo Spring Boot é fornecido abaixo -

package com.tutorialspoint.mockitodemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

Em seguida, configure o contexto do aplicativo para os testes. A anotação @Profile (“teste”) é usada para configurar a classe quando os casos de teste estão em execução.

package com.tutorialspoint.mockitodemo;

import org.mockito.Mockito;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Profile;

@Profile("test")
@Configuration
public class ProductServiceTestConfiguration {
   @Bean
   @Primary
   public ProductService productService() {
      return Mockito.mock(ProductService.class);
   }
}

Agora, você pode escrever um caso de Teste de Unidade para Serviço de Pedidos sob o src/test/resources pacote.

package com.tutorialspoint.mockitodemo;

import org.junit.Assert;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mockito;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.ActiveProfiles;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@SpringBootTest
@ActiveProfiles("test")
@RunWith(SpringJUnit4ClassRunner.class)
public class MockitoDemoApplicationTests {
   @Autowired
   private OrderService orderService;
   
   @Autowired
   private ProductService productService;

   @Test
   public void whenUserIdIsProvided_thenRetrievedNameIsCorrect() {
      Mockito.when(productService.getProductName()).thenReturn("Mock Product Name");
      String testName = orderService.getProductName();
      Assert.assertEquals("Mock Product Name", testName);
   }
}

O código completo para o arquivo de configuração do build é fornecido abaixo.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>mockito-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>mockito-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter</artifactId>
      </dependency>
      <dependency>
         <groupId>org.mockito</groupId>
         <artifactId>mockito-core</artifactId>
         <version>2.13.0</version>
      </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>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   compile group: 'org.mockito', name: 'mockito-core', version: '2.13.0'
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle1.

Para Maven, você pode usar o comando conforme mostrado -

mvn clean install

Você pode ver os resultados do teste na janela do console.

Para Gradle, você pode usar o comando conforme mostrado -

gradle clean build

Você pode ver os resultados restantes na janela do console.

Spring Boot fornece uma maneira fácil de escrever um teste de unidade para arquivo Rest Controller. Com a ajuda de SpringJUnit4ClassRunner e MockMvc, podemos criar um contexto de aplicativo da web para escrever o teste de unidade para o arquivo Rest Controller.

Os testes de unidade devem ser escritos sob o src/test/java recursos de diretório e caminho de classe para escrever um teste devem ser colocados sob o src/test/resources diretório.

Para escrever um teste de unidade, precisamos adicionar a dependência Spring Boot Starter Test em seu arquivo de configuração de compilação, conforme mostrado abaixo.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência ao seu arquivo build.gradle.

testCompile('org.springframework.boot:spring-boot-starter-test')

Antes de escrever um caso de teste, devemos primeiro construir serviços da web RESTful. Para obter mais informações sobre a construção de serviços da Web RESTful, consulte o capítulo sobre o mesmo dado neste tutorial.

Escrevendo um teste de unidade para o controlador REST

Nesta seção, vamos ver como escrever um Teste de Unidade para o Controlador REST.

Primeiro, precisamos criar o arquivo da classe Abstract usado para criar o contexto do aplicativo da web usando MockMvc e definir os métodos mapToJson () e mapFromJson () para converter o objeto Java em string JSON e converter a string JSON em objeto Java.

package com.tutorialspoint.demo;

import java.io.IOException;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;

import com.fasterxml.jackson.core.JsonParseException;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = DemoApplication.class)
@WebAppConfiguration
public abstract class AbstractTest {
   protected MockMvc mvc;
   @Autowired
   WebApplicationContext webApplicationContext;

   protected void setUp() {
      mvc = MockMvcBuilders.webAppContextSetup(webApplicationContext).build();
   }
   protected String mapToJson(Object obj) throws JsonProcessingException {
      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.writeValueAsString(obj);
   }
   protected <T> T mapFromJson(String json, Class<T> clazz)
      throws JsonParseException, JsonMappingException, IOException {
      
      ObjectMapper objectMapper = new ObjectMapper();
      return objectMapper.readValue(json, clazz);
   }
}

Em seguida, escreva um arquivo de classe que estenda a classe AbstractTest e escreva um Teste de Unidade para cada método, como GET, POST, PUT e DELETE.

O código para o caso de teste GET API é fornecido abaixo. Esta API serve para visualizar a lista de produtos.

@Test
public void getProductsList() throws Exception {
   String uri = "/products";
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
      .accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   Product[] productlist = super.mapFromJson(content, Product[].class);
   assertTrue(productlist.length > 0);
}

O código para o caso de teste POST API é fornecido abaixo. Esta API serve para criar um produto.

@Test
public void createProduct() throws Exception {
   String uri = "/products";
   Product product = new Product();
   product.setId("3");
   product.setName("Ginger");
   
   String inputJson = super.mapToJson(product);
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
      .contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(201, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is created successfully");
}

O código para o caso de teste PUT API é fornecido abaixo. Esta API é para atualizar o produto existente.

@Test
public void updateProduct() throws Exception {
   String uri = "/products/2";
   Product product = new Product();
   product.setName("Lemon");
   
   String inputJson = super.mapToJson(product);
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
      .contentType(MediaType.APPLICATION_JSON_VALUE).content(inputJson)).andReturn();
   
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is updated successsfully");
}

O código para o caso de teste Delete API é fornecido abaixo. Esta API excluirá o produto existente.

@Test
public void deleteProduct() throws Exception {
   String uri = "/products/2";
   MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
   int status = mvcResult.getResponse().getStatus();
   assertEquals(200, status);
   String content = mvcResult.getResponse().getContentAsString();
   assertEquals(content, "Product is deleted successsfully");
}

O arquivo completo da classe de teste do controlador é fornecido abaixo -

package com.tutorialspoint.demo;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import org.junit.Before;
import org.junit.Test;
import org.springframework.http.MediaType;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.test.web.servlet.request.MockMvcRequestBuilders;

import com.tutorialspoint.demo.model.Product;

public class ProductServiceControllerTest extends AbstractTest {
   @Override
   @Before
   public void setUp() {
      super.setUp();
   }
   @Test
   public void getProductsList() throws Exception {
      String uri = "/products";
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.get(uri)
         .accept(MediaType.APPLICATION_JSON_VALUE)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      Product[] productlist = super.mapFromJson(content, Product[].class);
      assertTrue(productlist.length > 0);
   }
   @Test
   public void createProduct() throws Exception {
      String uri = "/products";
      Product product = new Product();
      product.setId("3");
      product.setName("Ginger");
      String inputJson = super.mapToJson(product);
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.post(uri)
         .contentType(MediaType.APPLICATION_JSON_VALUE)
         .content(inputJson)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(201, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is created successfully");
   }
   @Test
   public void updateProduct() throws Exception {
      String uri = "/products/2";
      Product product = new Product();
      product.setName("Lemon");
      String inputJson = super.mapToJson(product);
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.put(uri)
         .contentType(MediaType.APPLICATION_JSON_VALUE)
         .content(inputJson)).andReturn();
      
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is updated successsfully");
   }
   @Test
   public void deleteProduct() throws Exception {
      String uri = "/products/2";
      MvcResult mvcResult = mvc.perform(MockMvcRequestBuilders.delete(uri)).andReturn();
      int status = mvcResult.getResponse().getStatus();
      assertEquals(200, status);
      String content = mvcResult.getResponse().getContentAsString();
      assertEquals(content, "Product is deleted successsfully");
   }
}

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os comandos Maven ou Gradle fornecidos abaixo -

Para Maven, você pode usar o comando fornecido abaixo -

mvn clean install

Agora, você pode ver os resultados do teste na janela do console.

Para Gradle, você pode usar o comando conforme mostrado abaixo -

gradle clean build

Você pode ver os resultados restantes na janela do console, conforme mostrado abaixo.

Spring Boot fornece um suporte muito bom para criar uma fonte de dados para banco de dados. Não precisamos escrever nenhum código extra para criar um DataSource no Spring Boot. Basta adicionar as dependências e fazer os detalhes da configuração para criar um DataSource e conectar o Banco de Dados.

Neste capítulo, usaremos a conexão do driver Spring Boot JDBC para conectar o banco de dados.

Primeiro, precisamos adicionar a dependência JDBC do Spring Boot Starter em nosso arquivo de configuração de construção.

Os usuários do Maven podem adicionar as seguintes dependências no arquivo pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

Os usuários do Gradle podem adicionar as seguintes dependências no arquivo build.gradle.

compile('org.springframework.boot:spring-boot-starter-jdbc')

Conectar ao banco de dados H2

Para conectar o banco de dados H2, precisamos adicionar a dependência do banco de dados H2 em nosso arquivo de configuração de construção.

Para usuários Maven, adicione a dependência abaixo em seu arquivo pom.xml.

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

Para usuários do Gradle, adicione a dependência abaixo em seu arquivo build.gradle.

compile('com.h2database:h2')

Precisamos criar o arquivo schema.sql e o arquivo data.sql no diretório classpath src / main / resources para conectar o banco de dados H2.

O arquivo schema.sql é fornecido abaixo.

CREATE TABLE PRODUCT (ID INT PRIMARY KEY, PRODUCT_NAME VARCHAR(25));

O arquivo data.sql é fornecido abaixo.

INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (1,'Honey');
INSERT INTO PRODUCT (ID,PRODUCT_NAME) VALUES (2,'Almond');

Conecte o MySQL

Para conectar o banco de dados MySQL, precisamos adicionar a dependência do MySQL em nosso arquivo de configuração de construção.

Para usuários do Maven, adicione a seguinte dependência ao arquivo pom.xml.

<dependency>
   <groupId>mysql</groupId>
   <artifactId>mysql-connector-java</artifactId>
</dependency>

Para usuários do Gradle, adicione a seguinte dependência ao arquivo build.gradle.

compile('mysql:mysql-connector-java')

Agora, crie banco de dados e tabelas em MySQL, conforme mostrado -

Para usuários do arquivo de propriedades, inclua as propriedades a seguir no arquivo application.properties.

spring.datasource.driverClassName = com.mysql.jdbc.Driver
spring.datasource.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.datasource.username = root
spring.datasource.password = root
spring.datasource.testOnBorrow = true
spring.datasource.testWhileIdle = true
spring.datasource.timeBetweenEvictionRunsMillis = 60000
spring.datasource.minEvictableIdleTimeMillis = 30000
spring.datasource.validationQuery = SELECT 1
spring.datasource.max-active = 15
spring.datasource.max-idle = 10
spring.datasource.max-wait = 8000

Para usuários YAML, adicione as seguintes propriedades no arquivo application.yml.

spring:
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      username: "root"
      password: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000

Conectar Redis

Redis é um banco de dados de código aberto usado para armazenar a estrutura de dados na memória. Para conectar o banco de dados Redis no aplicativo Spring Boot, precisamos adicionar a dependência do Redis em nosso arquivo de configuração de construção.

Os usuários do Maven devem adicionar a seguinte dependência em seu arquivo pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-redis</artifactId>
</dependency>

Os usuários do Gradle devem adicionar a seguinte dependência ao arquivo build.gradle.

compile('org.springframework.boot:spring-boot-starter-data-redis')

Para conexão Redis, precisamos usar RedisTemplate. Para RedisTemplate, precisamos fornecer os detalhes de JedisConnectionFactory.

@Bean
JedisConnectionFactory jedisConnectionFactory() {
   JedisConnectionFactory jedisConFactory = new JedisConnectionFactory();
   jedisConFactory.setHostName("localhost");
   jedisConFactory.setPort(6000);
   jedisConFactory.setUsePool(true);
   return jedisConFactory;
}
@Bean
public RedisTemplate<String, Object> redisTemplate() {
   RedisTemplate<String, Object> template = new RedisTemplate<>();
   template.setConnectionFactory(jedisConnectionFactory());
   template.setKeySerializer(new StringRedisSerializer());
   template.setHashKeySerializer(new StringRedisSerializer());
   template.setHashValueSerializer(new StringRedisSerializer());
   template.setValueSerializer(new StringRedisSerializer());
   return template;
}

Agora conecte automaticamente a classe RedisTemplate e acesse os dados do banco de dados Redis.

@Autowired

RedisTemplate<String, Object> redis;
Map<Object,Object> datalist = redis.opsForHash().entries(“Redis_code_index_key”);

JDBCTemplate

Para acessar o Banco de Dados Relacional usando JdbcTemplate no aplicativo Spring Boot, precisamos adicionar a dependência JDBC do Spring Boot Starter em nosso arquivo de configuração de construção.

Então, se você @Autowired a classe JdbcTemplate, Spring Boot conecta automaticamente o banco de dados e define a fonte de dados para o objeto JdbcTemplate.

@Autowired
JdbcTemplate jdbcTemplate;
Collection<Map<String, Object>> rows = jdbc.queryForList("SELECT QUERY");

A anotação @Repository deve ser adicionada ao arquivo de classe. A anotação @Repository é usada para criar um repositório de banco de dados para seu aplicativo Spring Boot.

@Repository
public class ProductServiceDAO {
}

Multiple DataSource

Podemos manter 'n' número de fontes de dados em um único aplicativo Spring Boot. O exemplo fornecido aqui mostra como criar mais de 1 fonte de dados no aplicativo Spring Boot. Agora, inclua os dois detalhes de configuração da origem de dados no arquivo de propriedades do aplicativo.

Para usuários do arquivo de propriedades, inclua as seguintes propriedades em seu arquivo application.properties.

spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect = true
spring.dbProductService.username = root
spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000

spring.dbUserService.driverClassName = com.mysql.jdbc.Driver
spring.dbUserService.url = jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect = true
spring.dbUserService.username = root
spring.dbUserService.password = root
spring.dbUserService.testOnBorrow = true
spring.dbUserService.testWhileIdle = true
spring.dbUserService.timeBetweenEvictionRunsMillis = 60000
spring.dbUserService.minEvictableIdleTimeMillis = 30000
spring.dbUserService.validationQuery = SELECT 1
spring.dbUserService.max-active = 15
spring.dbUserService.max-idle = 10
spring.dbUserService.max-wait = 8000

Os usuários Yaml devem adicionar as seguintes propriedades em seu arquivo application.yml.

spring:
   dbProductService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/PRODUCTSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1
      max-active: 15
      max-idle: 10
      max-wait: 8000
   dbUserService: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://localhost:3306/USERSERVICE?autoreconnect=true"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      timeBetweenEvictionRunsMillis: 60000
      minEvictableIdleTimeMillis: 30000
      validationQuery: SELECT 1    
      max-active: 15
      max-idle: 10
      max-wait: 8000

Agora, crie uma classe de configuração para criar um DataSource e JdbcTemplate para várias fontes de dados.

import javax.sql.DataSource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.jdbc.core.JdbcTemplate;

@Configuration
public class DatabaseConfig {
   @Bean(name = "dbProductService")
   @ConfigurationProperties(prefix = "spring.dbProductService")
   @Primary
   public DataSource createProductServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "dbUserService")
   @ConfigurationProperties(prefix = "spring.dbUserService")
   public DataSource createUserServiceDataSource() {
      return DataSourceBuilder.create().build();
   }
   @Bean(name = "jdbcProductService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_ProductService(@Qualifier("dbProductService") DataSource productServiceDS) {
      return new JdbcTemplate(productServiceDS);
   }
   @Bean(name = "jdbcUserService")
   @Autowired
   public JdbcTemplate createJdbcTemplate_UserService(@Qualifier("dbUserService") DataSource userServiceDS) {
      return new JdbcTemplate(userServiceDS);
   }
}

Em seguida, conecte automaticamente o objeto JDBCTemplate usando a anotação @Qualifier.

@Qualifier("jdbcProductService")
@Autowired
JdbcTemplate jdbcTemplate;

@Qualifier("jdbcUserService")
@Autowired
JdbcTemplate jdbcTemplate;

Se uma dependência Spring Boot Security for adicionada ao classpath, o aplicativo Spring Boot requer automaticamente a autenticação básica para todos os pontos de extremidade HTTP. O Endpoint “/” e “/ home” não requer autenticação. Todos os outros Endpoints exigem autenticação.

Para adicionar um Spring Boot Security ao seu aplicativo Spring Boot, precisamos adicionar a dependência Spring Boot Starter Security em nosso arquivo de configuração de construção.

Os usuários do Maven podem adicionar a seguinte dependência no arquivo pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência no arquivo build.gradle.

compile("org.springframework.boot:spring-boot-starter-security")

Protegendo um aplicativo da Web

Primeiro, crie um aplicativo da web não seguro usando modelos Thymeleaf.

Em seguida, crie um arquivo home.html em src/main/resources/templates diretório.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Spring Security Example</title>
   </head>
   <body>
      <h1>Welcome!</h1>
      <p>Click <a th:href = "@{/hello}">here</a> to see a greeting.</p>
   </body>
   
</html>

A visão simples /hello definido no arquivo HTML usando modelos Thymeleaf.

Agora, crie um hello.html sob src/main/resources/templates diretório.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" 
   xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Hello World!</title>
   </head>
   <body>
      <h1>Hello world!</h1>
   </body>
   
</html>

Agora, precisamos configurar o controlador Spring MVC - View para as visualizações home e hello.

Para isso, crie um arquivo de configuração MVC que estenda WebMvcConfigurerAdapter.

package com.tutorialspoint.websecuritydemo;

import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.ViewControllerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;

@Configuration
public class MvcConfig extends WebMvcConfigurerAdapter {
   @Override
   public void addViewControllers(ViewControllerRegistry registry) {
      registry.addViewController("/home").setViewName("home");
      registry.addViewController("/").setViewName("home");
      registry.addViewController("/hello").setViewName("hello");
      registry.addViewController("/login").setViewName("login");
   }
}

Agora, adicione a dependência de segurança Spring Boot Starter ao seu arquivo de configuração de compilação.

Os usuários do Maven podem adicionar a seguinte dependência em seu arquivo pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

Os usuários do Gradle podem adicionar a seguinte dependência no arquivo build.gradle.

compile("org.springframework.boot:spring-boot-starter-security")

Agora, crie um arquivo de configuração de segurança da Web, que é usado para proteger seu aplicativo para acessar os pontos de extremidade HTTP usando autenticação básica.

package com.tutorialspoint.websecuritydemo;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;

@Configuration
@EnableWebSecurity
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http
         .authorizeRequests()
            .antMatchers("/", "/home").permitAll()
            .anyRequest().authenticated()
            .and()
         .formLogin()
            .loginPage("/login")
            .permitAll()
            .and()
            .logout()
            .permitAll();
   }
   @Autowired
   public void configureGlobal(AuthenticationManagerBuilder auth) throws Exception {
      auth
         .inMemoryAuthentication()
         .withUser("user").password("password").roles("USER");
   }
}

Agora, crie um arquivo login.html sob o src/main/resources diretório para permitir que o usuário acesse o ponto de extremidade HTTP por meio da tela de login.

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org"
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Spring Security Example </title>
   </head>
   <body>
      <div th:if = "${param.error}">
         Invalid username and password.
      </div>
      <div th:if = "${param.logout}">
         You have been logged out.
      </div>
      
      <form th:action = "@{/login}" method = "post">
         <div>
            <label> User Name : <input type = "text" name = "username"/> </label>
         </div>
         <div>
            <label> Password: <input type = "password" name = "password"/> </label>
         </div>
         <div>
            <input type = "submit" value = "Sign In"/>
         </div>
      </form>
      
   </body>
</html>

Finalmente, atualize o arquivo hello.html - para permitir que o usuário saia do aplicativo e exiba o nome de usuário atual, conforme mostrado abaixo -

<!DOCTYPE html>
<html xmlns = "http://www.w3.org/1999/xhtml" xmlns:th = "http://www.thymeleaf.org" 
   xmlns:sec = "http://www.thymeleaf.org/thymeleaf-extras-springsecurity3">
   
   <head>
      <title>Hello World!</title>
   </head>
   <body>
      <h1 th:inline = "text">Hello [[${#httpServletRequest.remoteUser}]]!</h1>
      <form th:action = "@{/logout}" method = "post">
         <input type = "submit" value = "Sign Out"/>
      </form>
   </body>
   
</html>

O código para o aplicativo Spring Boot principal é fornecido abaixo -

package com.tutorialspoint.websecuritydemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

O código completo para o arquivo de configuração do build é fornecido abaixo.

Maven – 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 
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
   
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.tutorialspoint</groupId>
   <artifactId>websecurity-demo</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websecurity-demo</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath/> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-security</artifactId>
      </dependency>
      
      <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>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-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>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-security')
   compile('org.springframework.boot:spring-boot-starter-thymeleaf')
   compile('org.springframework.boot:spring-boot-starter-web')
   
   testCompile('org.springframework.boot:spring-boot-starter-test')
   testCompile('org.springframework.security:spring-security-test')
}

Agora, crie um arquivo JAR executável e execute o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Os usuários Maven podem usar o comando conforme fornecido abaixo -

mvn clean install

Depois de “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Os usuários do Gradle podem usar o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando mostrado abaixo -

java –jar <JARFILE>

Acesse o URL http://localhost:8080/no seu navegador. Você pode ver a saída conforme mostrado.

Neste capítulo, você aprenderá em detalhes sobre os mecanismos do Spring Boot Security e OAuth2 com JWT.

Servidor de Autorização

O Authorization Server é um componente arquitetônico supremo para Web API Security. O Authorization Server atua como um ponto de autorização de centralização que permite que seus aplicativos e endpoints HTTP identifiquem os recursos de seu aplicativo.

Servidor de Recursos

O Resource Server é um aplicativo que fornece o token de acesso aos clientes para acessar os pontos de extremidade HTTP do Resource Server. É uma coleção de bibliotecas que contém os pontos de extremidade HTTP, recursos estáticos e páginas da web dinâmicas.

OAuth2

OAuth2 é uma estrutura de autorização que permite ao aplicativo Web Security acessar os recursos do cliente. Para construir um aplicativo OAuth2, precisamos nos concentrar no tipo de concessão (código de autorização), ID do cliente e segredo do cliente.

Token JWT

O token JWT é um token da Web JSON, usado para representar as reivindicações protegidas entre duas partes. Você pode aprender mais sobre o token JWT em www.jwt.io/ .

Agora, vamos construir um aplicativo OAuth2 que permite o uso do Authorization Server, Resource Server com a ajuda de um token JWT.

Você pode usar as seguintes etapas para implementar o Spring Boot Security com o token JWT acessando o banco de dados.

Primeiro, precisamos adicionar as seguintes dependências em nosso arquivo de configuração de construção.

Os usuários do Maven podem adicionar as seguintes dependências em seu arquivo pom.xml.

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-security</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-web</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.security.oauth</groupId>
   <artifactId>spring-security-oauth2</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-jwt</artifactId>
</dependency>

<dependency>
   <groupId>com.h2database</groupId>
   <artifactId>h2</artifactId>
</dependency>

<dependency>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-test</artifactId>
   <scope>test</scope>
</dependency>

<dependency>
   <groupId>org.springframework.security</groupId>
   <artifactId>spring-security-test</artifactId>
   <scope>test</scope>
</dependency>

Os usuários do Gradle podem adicionar as seguintes dependências no arquivo build.gradle.

compile('org.springframework.boot:spring-boot-starter-security')
compile('org.springframework.boot:spring-boot-starter-web')
testCompile('org.springframework.boot:spring-boot-starter-test')
testCompile('org.springframework.security:spring-security-test')

compile("org.springframework.security.oauth:spring-security-oauth2")
compile('org.springframework.security:spring-security-jwt')
compile("org.springframework.boot:spring-boot-starter-jdbc")
compile("com.h2database:h2:1.4.191")

Onde,

• Spring Boot Starter Security - Implementa o Spring Security

• Spring Security OAuth2 - Implementa a estrutura OAUTH2 para habilitar o Authorization Server e o Resource Server.

• Spring Security JWT - Gera o token JWT para segurança da Web

• Spring Boot Starter JDBC - Acessa o banco de dados para garantir que o usuário esteja disponível ou não.

• Spring Boot Starter Web - Grava endpoints HTTP.

• H2 Database - Armazena as informações do usuário para autenticação e autorização.

O arquivo de configuração de compilação completo é fornecido abaixo.

<?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>com.tutorialspoint</groupId>
   <artifactId>websecurityapp</artifactId>
   <version>0.0.1-SNAPSHOT</version>
   <packaging>jar</packaging>
   <name>websecurityapp</name>
   <description>Demo project for Spring Boot</description>

   <parent>
      <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-parent</artifactId>
      <version>1.5.9.RELEASE</version>
      <relativePath /> <!-- lookup parent from repository -->
   </parent>

   <properties>
      <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
      <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
      <java.version>1.8</java.version>
   </properties>

   <dependencies>
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-jdbc</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-security</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-web</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security.oauth</groupId>
         <artifactId>spring-security-oauth2</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-jwt</artifactId>
      </dependency>
      
      <dependency>
         <groupId>com.h2database</groupId>
         <artifactId>h2</artifactId>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-test</artifactId>
         <scope>test</scope>
      </dependency>
      
      <dependency>
         <groupId>org.springframework.security</groupId>
         <artifactId>spring-security-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>

Gradle – build.gradle

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}

dependencies {
   compile('org.springframework.boot:spring-boot-starter-security')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   testCompile('org.springframework.security:spring-security-test')
   compile("org.springframework.security.oauth:spring-security-oauth2")
   compile('org.springframework.security:spring-security-jwt')
   compile("org.springframework.boot:spring-boot-starter-jdbc")
   compile("com.h2database:h2:1.4.191")  
}

Agora, no aplicativo Spring Boot principal, adicione as anotações @EnableAuthorizationServer e @EnableResourceServer para atuar como um servidor Auth e um servidor de recursos no mesmo aplicativo.

Além disso, você pode usar o código a seguir para escrever um ponto de extremidade HTTP simples para acessar a API com Spring Security usando o token JWT.

package com.tutorialspoint.websecurityapp;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableAuthorizationServer;
import org.springframework.security.oauth2.config.annotation.web.configuration.EnableResourceServer;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@EnableAuthorizationServer
@EnableResourceServer
@RestController
public class WebsecurityappApplication {
   public static void main(String[] args) {
      SpringApplication.run(WebsecurityappApplication.class, args);
   }
   @RequestMapping(value = "/products")
   public String getProductName() {
      return "Honey";   
   }
}

Use o código a seguir para definir a classe POJO para armazenar as informações do usuário para autenticação.

package com.tutorialspoint.websecurityapp;

import java.util.ArrayList;
import java.util.Collection;
import org.springframework.security.core.GrantedAuthority;

public class UserEntity {
   private String username;
   private String password;
   private Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
   
   public String getPassword() {
      return password;
   }
   public void setPassword(String password) {
      this.password = password;
   }
   public Collection<GrantedAuthority> getGrantedAuthoritiesList() {
      return grantedAuthoritiesList;
   }
   public void setGrantedAuthoritiesList(Collection<GrantedAuthority> grantedAuthoritiesList) {
      this.grantedAuthoritiesList = grantedAuthoritiesList;
   }
   public String getUsername() {
      return username;
   }
   public void setUsername(String username) {
      this.username = username;
   }
}

Agora, use o código a seguir e defina a classe CustomUser que estende a classe org.springframework.security.core.userdetails.User para autenticação Spring Boot.

package com.tutorialspoint.websecurityapp;

import org.springframework.security.core.userdetails.User;

public class CustomUser extends User {
   private static final long serialVersionUID = 1L;
   public CustomUser(UserEntity user) {
      super(user.getUsername(), user.getPassword(), user.getGrantedAuthoritiesList());
   }
}

Você pode criar a classe @Repository para ler as informações do usuário do banco de dados e enviá-las para o serviço de usuário personalizado e também adicionar a autoridade concedida “ROLE_SYSTEMADMIN”.

package com.tutorialspoint.websecurityapp;

import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.authority.SimpleGrantedAuthority;
import org.springframework.stereotype.Repository;

@Repository
public class OAuthDao {
   @Autowired
   private JdbcTemplate jdbcTemplate;

   public UserEntity getUserDetails(String username) {
      Collection<GrantedAuthority> grantedAuthoritiesList = new ArrayList<>();
      String userSQLQuery = "SELECT * FROM USERS WHERE USERNAME=?";
      List<UserEntity> list = jdbcTemplate.query(userSQLQuery, new String[] { username },
         (ResultSet rs, int rowNum) -> {
         
         UserEntity user = new UserEntity();
         user.setUsername(username);
         user.setPassword(rs.getString("PASSWORD"));
         return user;
      });
      if (list.size() > 0) {
         GrantedAuthority grantedAuthority = new SimpleGrantedAuthority("ROLE_SYSTEMADMIN");
         grantedAuthoritiesList.add(grantedAuthority);
         list.get(0).setGrantedAuthoritiesList(grantedAuthoritiesList);
         return list.get(0);
      }
      return null;
   }
}

Você pode criar uma classe de serviço de detalhes de usuário personalizado que estenda org.springframework.security.core.userdetails.UserDetailsService para chamar a classe de repositório DAO conforme mostrado.

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.core.userdetails.UsernameNotFoundException;
import org.springframework.stereotype.Service;

@Service
public class CustomDetailsService implements UserDetailsService {
   @Autowired
   OAuthDao oauthDao;

   @Override
   public CustomUser loadUserByUsername(final String username) throws UsernameNotFoundException {
      UserEntity userEntity = null;
      try {
         userEntity = oauthDao.getUserDetails(username);
         CustomUser customUser = new CustomUser(userEntity);
         return customUser;
      } catch (Exception e) {
         e.printStackTrace();
         throw new UsernameNotFoundException("User " + username + " was not found in the database");
      }
   }
}

Em seguida, crie uma classe @configuration para habilitar o Web Security, definindo o codificador de Senha (BCryptPasswordEncoder) e definindo o bean AuthenticationManager. A classe de configuração de segurança deve estender a classe WebSecurityConfigurerAdapter.

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.config.annotation.authentication.builders.AuthenticationManagerBuilder;
import org.springframework.security.config.annotation.method.configuration.EnableGlobalMethodSecurity;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.builders.WebSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.security.crypto.password.PasswordEncoder;

@Configuration
@EnableWebSecurity
@EnableGlobalMethodSecurity(prePostEnabled = true)
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
   @Autowired
   private CustomDetailsService customDetailsService;

   @Bean
   public PasswordEncoder encoder() {
      return new BCryptPasswordEncoder();
   }
   @Override
   @Autowired
   protected void configure(AuthenticationManagerBuilder auth) throws Exception {
      auth.userDetailsService(customDetailsService).passwordEncoder(encoder());
   }
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http.authorizeRequests().anyRequest().authenticated().and().sessionManagement()
         .sessionCreationPolicy(SessionCreationPolicy.NEVER);
   }
   @Override
   public void configure(WebSecurity web) throws Exception {
      web.ignoring();
   }
   @Override
   @Bean
   public AuthenticationManager authenticationManagerBean() throws Exception {
      return super.authenticationManagerBean();
   }
}

Agora, defina a classe de configuração OAuth2 para adicionar o ID do cliente, o segredo do cliente, defina o JwtAccessTokenConverter, a chave privada e a chave pública para a chave do assinante do token e a chave do verificador e configure o ClientDetailsServiceConfigurer para a validade do token com escopos.

package com.tutorialspoint.websecurityapp;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import org.springframework.security.authentication.AuthenticationManager;
import org.springframework.security.oauth2.config.annotation.configurers.ClientDetailsServiceConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configuration.AuthorizationServerConfigurerAdapter;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerEndpointsConfigurer;
import org.springframework.security.oauth2.config.annotation.web.configurers.AuthorizationServerSecurityConfigurer;
import org.springframework.security.oauth2.provider.token.store.JwtAccessTokenConverter;
import org.springframework.security.oauth2.provider.token.store.JwtTokenStore;

@Configuration
public class OAuth2Config extends AuthorizationServerConfigurerAdapter {
   private String clientid = "tutorialspoint";
   private String clientSecret = "my-secret-key";
   private String privateKey = "private key";
   private String publicKey = "public key";

   @Autowired
   @Qualifier("authenticationManagerBean")
   private AuthenticationManager authenticationManager;
   
   @Bean
   public JwtAccessTokenConverter tokenEnhancer() {
      JwtAccessTokenConverter converter = new JwtAccessTokenConverter();
      converter.setSigningKey(privateKey);
      converter.setVerifierKey(publicKey);
      return converter;
   }
   @Bean
   public JwtTokenStore tokenStore() {
      return new JwtTokenStore(tokenEnhancer());
   }
   @Override
   public void configure(AuthorizationServerEndpointsConfigurer endpoints) throws Exception {
      endpoints.authenticationManager(authenticationManager).tokenStore(tokenStore())
      .accessTokenConverter(tokenEnhancer());
   }
   @Override
   public void configure(AuthorizationServerSecurityConfigurer security) throws Exception {
      security.tokenKeyAccess("permitAll()").checkTokenAccess("isAuthenticated()");
   }
   @Override
   public void configure(ClientDetailsServiceConfigurer clients) throws Exception {
      clients.inMemory().withClient(clientid).secret(clientSecret).scopes("read", "write")
         .authorizedGrantTypes("password", "refresh_token").accessTokenValiditySeconds(20000)
         .refreshTokenValiditySeconds(20000);

   }
}

Agora, crie uma chave privada e uma chave pública usando o openssl.

Você pode usar os seguintes comandos para gerar a chave privada.

openssl genrsa -out jwt.pem 2048
openssl rsa -in jwt.pem

Você pode usar Para geração de chave pública, use os comandos abaixo.

openssl rsa -in jwt.pem -pubout

Para a versão do Spring Boot posterior a 1.5, adicione a propriedade abaixo em seu arquivo application.properties para definir a ordem do filtro de recursos OAuth2.

security.oauth2.resource.filter-order=3

Os usuários do arquivo YAML podem adicionar a propriedade abaixo no arquivo YAML.

security:
   oauth2:
      resource:
         filter-order: 3

Agora, crie o arquivo schema.sql e data.sql nos recursos do classpath src/main/resources/directory para conectar o aplicativo ao banco de dados H2.

O arquivo schema.sql é mostrado -

CREATE TABLE USERS (ID INT PRIMARY KEY, USERNAME VARCHAR(45), PASSWORD VARCHAR(60));

O arquivo data.sql é mostrado -

INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES (
   1, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG'); INSERT INTO USERS (ID, USERNAME,PASSWORD) VALUES ( 2, '[email protected]','$2a$08$fL7u5xcvsZl78su29x1ti.dxI.9rYO8t0q5wk2ROJ.1cdR53bmaVG');

Note - A senha deve ser armazenada no formato do codificador Bcrypt na tabela do banco de dados.

Você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando os seguintes comandos Maven ou Gradle.

Para Maven, você pode usar o comando fornecido abaixo -

mvn clean install

Após “BUILD SUCCESS”, você pode encontrar o arquivo JAR no diretório de destino.

Para Gradle, você pode usar o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Agora, execute o arquivo JAR usando o comando mostrado aqui -

java –jar <JARFILE>

O aplicativo é iniciado na porta 8080 do Tomcat.

Agora acesse a URL do método POST via POSTMAN para obter o token OAUTH2.

http://localhost:8080/oauth/token

Agora, adicione os cabeçalhos de solicitação da seguinte forma -

• Authorization - Autenticação básica com seu ID de cliente e segredo do cliente.

• Content Type - application / x-www-form-urlencoded

Agora, adicione os parâmetros de solicitação da seguinte forma -

• grant_type = senha
• nome de usuário = seu nome de usuário
• senha = sua senha

Agora, acesse a API e obtenha o access_token conforme mostrado -

Agora, acesse a API do servidor de recursos com token de acesso do portador no cabeçalho da solicitação, conforme mostrado.

Então você pode ver a saída conforme mostrado abaixo -

O Google Cloud Platform fornece serviços de computação em nuvem que executam o aplicativo Spring Boot no ambiente de nuvem. Neste capítulo, veremos como implantar o aplicativo Spring Boot na plataforma do GCP app engine.

Primeiro, baixe o aplicativo Gradle build Spring Boot na página do Spring Initializer www.start.spring.io . Observe a seguinte captura de tela.

Agora, no arquivo build.gradle, adicione o plug-in appengine do Google Cloud e a dependência do classpath do appengine.

O código para o arquivo build.gradle é fornecido abaixo -

buildscript {
   ext {
      springBootVersion = '1.5.9.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
      classpath 'com.google.cloud.tools:appengine-gradle-plugin:1.3.3'
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'
apply plugin: 'com.google.cloud.tools.appengine'

group = 'com.tutorialspoint'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Agora, escreva um ponto de extremidade HTTP simples e ele retornará o sucesso da string como mostrado -

package com.tutorialspoint.appenginedemo;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class AppengineDemoApplication {
   public static void main(String[] args) {
      SpringApplication.run(AppengineDemoApplication.class, args);
   }
   @RequestMapping(value = "/")
   public String success() {
      return "APP Engine deployment success";
   }
}

Em seguida, adicione o arquivo app.yml no diretório src / main / appengine conforme mostrado -

runtime: java
env: flex

handlers:
- url: /.*
   script: this field is required, but ignored

Agora, vá para o console do Google Cloud e clique em Ativar Google Cloud shell na parte superior da página.

Agora, mova seus arquivos de origem e o arquivo Gradle para o diretório inicial de sua máquina em nuvem do google usando o shell em nuvem do google.

Agora, execute o comando gradle appengineDeploy e ele implantará seu aplicativo no Google Cloud appengine.

Note - O GCP deve estar habilitado para faturamento e antes de implantar seu aplicativo no appengine, você deve criar a plataforma appengine no GCP.

Levará alguns minutos para implantar seu aplicativo na plataforma appengine do GCP.

Depois de construir com sucesso, você pode ver a URL do serviço na janela do console.

Agora, acesse a URL do serviço e veja o resultado.

Google Cloud SQL

Para conectar o Google Cloud SQL em seu aplicativo Spring Boot, você deve adicionar as seguintes propriedades em seu arquivo application.properties.

Formato de URL JDBC

jdbc:mysql://google/<DATABASE-NAME>?cloudSqlInstance = <GOOGLE_CLOUD_SQL_INSTANCE_NAME> &socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = <USERNAME>&password = <PASSWORD>

Note - O aplicativo Spring Boot e o Google Cloud SQL devem estar no mesmo projeto do GCP.

O arquivo application.properties é fornecido abaixo.

spring.dbProductService.driverClassName = com.mysql.jdbc.Driver
spring.dbProductService.url = jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance = springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory = com.google.cloud.sql.mysql.SocketFactory&user = root&password = rootspring.dbProductService.username = root

spring.dbProductService.password = root
spring.dbProductService.testOnBorrow = true
spring.dbProductService.testWhileIdle = true
spring.dbProductService.timeBetweenEvictionRunsMillis = 60000
spring.dbProductService.minEvictableIdleTimeMillis = 30000
spring.dbProductService.validationQuery = SELECT 1
spring.dbProductService.max-active = 15
spring.dbProductService.max-idle = 10
spring.dbProductService.max-wait = 8000

Os usuários do arquivo YAML podem adicionar as propriedades abaixo ao seu arquivo application.yml.

spring:
   datasource: 
      driverClassName: com.mysql.jdbc.Driver
      url: "jdbc:mysql://google/PRODUCTSERVICE?cloudSqlInstance=springboot-gcp-cloudsql:asia-northeast1:springboot-gcp-cloudsql-instance&socketFactory=com.google.cloud.sql.mysql.SocketFactory&user=root&password=root"
      password: "root"
      username: "root"
      testOnBorrow: true
      testWhileIdle: true
      validationQuery: SELECT 1
      
      max-active: 15
      max-idle: 10
      max-wait: 8000

Neste capítulo, veremos como adicionar o Google OAuth2 Sign-In usando o aplicativo Spring Boot com o Gradle build.

Primeiro, adicione a dependência de segurança Spring Boot OAuth2 em seu arquivo de configuração de compilação e seu arquivo de configuração de compilação é fornecido abaixo.

buildscript {
   ext {
      springBootVersion = '1.5.8.RELEASE'
   }
   repositories {
      mavenCentral()
   }
   dependencies {
      classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
   }
}

apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

group = 'com.tutorialspoint.projects'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

repositories {
   mavenCentral()
}
dependencies {
   compile('org.springframework.boot:spring-boot-starter')
   testCompile('org.springframework.boot:spring-boot-starter-test')
   compile('org.springframework.security.oauth:spring-security-oauth2')
   compile('org.springframework.boot:spring-boot-starter-web')
   testCompile('org.springframework.boot:spring-boot-starter-test')
}

Agora, adicione o ponto de extremidade HTTP para ler o principal do usuário do Google após a autenticação via Spring Boot no arquivo de classe do aplicativo Spring Boot principal, conforme fornecido abaixo -

package com.tutorialspoint.projects.googleservice;

import java.security.Principal;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@SpringBootApplication
@RestController
public class GoogleserviceApplication {
   public static void main(String[] args) {
      SpringApplication.run(GoogleserviceApplication.class, args);
   }
   @RequestMapping(value = "/user")
   public Principal user(Principal principal) {
      return principal;
   }
}

Agora, escreva um arquivo de configuração para habilitar o OAuth2SSO para segurança da web e remova a autenticação do arquivo index.html conforme mostrado -

package com.tutorialspoint.projects.googleservice;

import org.springframework.boot.autoconfigure.security.oauth2.client.EnableOAuth2Sso;
import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;

@Configuration
@EnableOAuth2Sso
public class WebSecurityConfiguration extends WebSecurityConfigurerAdapter {
   @Override
   protected void configure(HttpSecurity http) throws Exception {
      http
         .csrf()
         .disable()
         .antMatcher("/**")
         .authorizeRequests()
         .antMatchers("/", "/index.html")
         .permitAll()
         .anyRequest()
         .authenticated();
   }
}

Em seguida, adicione o arquivo index.html em recursos estáticos e adicione o link para redirecionar ao usuário HTTP Endpoint para ler o usuário principal do Google, conforme mostrado abaixo -

<!DOCTYPE html>
<html>
   <head>
      <meta charset = "ISO-8859-1">
      <title>Insert title here</title>
   </head>
   <body>
      <a href = "user">Click here to Google Login</a>
   </body>
</html>

Note - No console do Google Cloud - Ative os serviços do Gmail, serviços de análise e API (s) de serviço do Google+.

Em seguida, vá para a seção Credenciais, crie uma credencial e escolha ID do cliente OAuth.

Em seguida, forneça um nome de produto na tela de consentimento OAuth2.

Em seguida, escolha o tipo de aplicativo como “aplicativo da Web”, forneça as origens JavaScript autorizadas e URIs de redirecionamento autorizados.

Agora, seu ID do cliente OAuth2 e a chave secreta do cliente foram criados.

Em seguida, inclua o ID do cliente e o Segredo do cliente no arquivo de propriedades do aplicativo.

security.oauth2.client.clientId = <CLIENT_ID>
security.oauth2.client.clientSecret = <CLIENT_SECRET>
security.oauth2.client.accessTokenUri  =  https://www.googleapis.com/oauth2/v3/token
security.oauth2.client.userAuthorizationUri  =  https://accounts.google.com/o/oauth2/auth
security.oauth2.client.tokenName = oauth_token
security.oauth2.client.authenticationScheme = query
security.oauth2.client.clientAuthenticationScheme = form
security.oauth2.client.scope = profile email

security.oauth2.resource.userInfoUri  =  https://www.googleapis.com/userinfo/v2/me
security.oauth2.resource.preferTokenInfo = false

Agora, você pode criar um arquivo JAR executável e executar o aplicativo Spring Boot usando o seguinte comando Gradle.

Para Gradle, você pode usar o comando conforme mostrado -

gradle clean build

Depois de “BUILD SUCCESSFUL”, você pode encontrar o arquivo JAR no diretório build / libs.

Execute o arquivo JAR usando o comando java –jar <JARFILE> e o aplicativo é iniciado na porta 8080 do Tomcat.

Agora acesse o URL http://localhost:8080/ e clique no link de login do Google.

Ele irá redirecionar para a tela de login do Google e fornecer os detalhes de login do Gmail.

Se o login for bem-sucedido, receberemos o objeto Principal do usuário do Gmail.