Spring Boot Gradle Plugin

1. Visão geral

O plugin Spring Boot Gradle nos ajuda a gerenciar dependências do Spring Boot, bem como empacotar e executar nosso aplicativo ao usar Gradle como uma ferramenta de compilação.

Neste tutorial, discutiremos como podemos adicionar e configurar o plug-in e, em seguida, veremos como construir e executar um projeto Spring Boot.

2. Configuração de arquivo de compilação

Primeiro, o arquivowe need to add the Spring Boot plugin to our build.gradle incluindo-o em nossa seçãoplugins:

plugins {
    id "org.springframework.boot" version "2.0.1.RELEASE"
}

Se estivermos usando uma versão do Gradle anterior à 2.1 ou precisarmos de configuração dinâmica, podemos adicioná-la assim:

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

apply plugin: 'org.springframework.boot'

3. Empacotando nosso aplicativo

Podemos empacotar nosso aplicativo em um arquivo executável (jar ou arquivo war) construindo-o usando o comandobuild:

./gradlew build

Como resultado, o arquivo executável gerado será colocado no diretóriobuild/libs.

Se quisermos gerar um arquivo executáveljar, também precisamos aplicar o pluginjava:

apply plugin: 'java'

Por outro lado, se precisarmos de um arquivowar, aplicaremos o pluginwar:

apply plugin: 'war'

A criação do aplicativo irá gerar arquivos executáveis para o Spring Boot 1.xe 2.x. No entanto, para cada versão, o Gradle aciona tarefas diferentes.

A seguir, vamos dar uma olhada no processo de construção de cada versão do Boot.

3.1. Spring Boot 2.x

No Boot 2.x, as tarefasbootJarebootWar são responsáveis por empacotar o aplicativo.

A tarefabootJar é responsável por criar o arquivo executáveljar. Isso é criado automaticamente quando o pluginjava é aplicado.

Vamos ver como podemos executar a tarefabootJar diretamente:

./gradlew bootJar

Da mesma forma,bootWar gera um arquivo war executável e é criado assim que o pluginwar é aplicado.

Podemos executar a tarefabootWar usando:

./gradlew bootWar

Observe que, para Spring Boot 2.x, precisamos usar Gradle 4.0 ou posterior.

Também podemos configurar as duas tarefas. Por exemplo, vamos definir a classe principal usando a propriedademainClassName:

bootJar {
    mainClassName = 'com.example.Application'
}

Como alternativa, podemos usar a mesma propriedade do DSL Spring Boot:

springBoot {
    mainClassName = 'com.example.Application'
}

3.2. Spring Boot 1.x

With Spring Boot 1.x, bootRepackage is responsible for creating the executable archive Arquivo(jar ouwar dependendo da configuração.

Podemos executar a tarefabootRepackage diretamente usando:

./gradlew bootRepackage

Semelhante à versão 2.x do Boot, podemos adicionar configurações à tarefabootRepackage em nossobuild.gradle:

bootRepackage {
    mainClass = 'com.example.demo.Application'
}

Também podemos desativar a tarefabootRepackage definindo a opçãoenabled parafalse:

bootRepackage {
    enabled = false
}

4. Executando nosso aplicativo

Depois de construir o aplicativo,we can just run it by using the java -jar command no arquivo jar executável gerado:

java -jar build/libs/demo.jar

Spring Boot Gradle plugin also provides us with the bootRun task que nos permite executar o aplicativo sem a necessidade de criá-lo primeiro:

./gradlew bootRun

A tarefabootRun pode ser simplesmente configurada embuild.gradle.

Por exemplo, podemos definir a classe principal:

bootRun {
    main = 'com.example.demo.Application'
}

5. Relação com Outros Plugins

5.1. Plugin de gerenciamento de dependência

Para o Spring Boot 1.x, ele costumava aplicar o plug-in de gerenciamento de dependência automaticamente. Isso importaria a lista técnica das dependências do Spring Boot e agiria de maneira semelhante ao gerenciamento de dependências do Maven.

Mas desde Spring Boot 2.x, precisamos aplicá-lo explicitamente em nossobuild.gradle se precisarmos desta funcionalidade:

apply plugin: 'io.spring.dependency-management'

5.2. Plugin Java

Quando aplicamos o plug-injava, o plug-in Spring Boot Gradle executa várias ações como:

criando tarefaa bootJar, que podemos usar para gerar um arquivo jar executável
criando a tarefaa bootRun, que podemos usar para executar nosso aplicativo diretamente
desabilitandojar tarefa

5.3. Plugin de Guerra

Da mesma forma, quando aplicamos o pluginwar, isso resulta em:

criando a tarefabootWar, que podemos usar para gerar um arquivo war executável
desabilitando a tarefawar

6. Conclusão

Neste tutorial rápido, aprendemos sobre o Spring Boot Gradle Plugin e suas diferentes tarefas.

Além disso, discutimos como ele interage com outros plugins.

TOC

Spring Boot Gradle Plugin