Gradle - Guia rápido

"Gradle is an open source build automation system"

Ant e Maven compartilharam um sucesso considerável no mercado JAVA. Ant foi a primeira ferramenta de construção lançada em 2000 e é desenvolvida com base na ideia de programação procedural. Posteriormente, ele foi aprimorado com a capacidade de aceitar plug-ins e gerenciamento de dependências pela rede com a ajuda do Apache-IVY. A principal desvantagem é o XML como um formato para escrever scripts de construção; ser hierárquico não é bom para a programação procedural e o XML tende a se tornar excessivamente grande.

O Maven foi lançado em 2004. Ele vem com muitas melhorias em relação ao ANT. Ele muda sua estrutura e continua usando XML para escrever especificações de construção. O Maven depende das convenções e é capaz de fazer download das dependências pela rede. Os principais benefícios do maven é seu ciclo de vida. Enquanto segue o mesmo ciclo de vida para vários projetos continuamente. Isso tem um custo de flexibilidade. O Maven também enfrenta alguns problemas no gerenciamento de dependências. Ele não lida bem com conflitos entre versões da mesma biblioteca e scripts de construção personalizados complexos são realmente mais difíceis de escrever no maven do que no ANT.

Finalmente, o Gradle entrou em cena em 2012. O Gradle traz alguns recursos eficientes de ambas as ferramentas.

Características do Gradle

A seguir está a lista de recursos que o Gradle oferece.

• Declarative builds and build-by-convention- O Gradle está disponível com uma linguagem específica de domínio (DSL) separada com base na linguagem Groovy. O Gradle fornece elementos de linguagem declarativos. Esses elementos também fornecem suporte de construção por convenção para Java, Groovy, OSGI, Web e Scala.

• Language for dependency based programming - A linguagem declarativa está no topo de um gráfico de tarefa de propósito geral, que você pode aproveitar totalmente em sua construção.

• Structure your build- O Gradle finalmente permite que você aplique princípios de design comuns à sua construção. Isso lhe dará uma estrutura perfeita para a construção, de modo que você possa projetar uma construção bem estruturada e de fácil manutenção, compreensível.

• Deep API - O uso desta API permite monitorar e personalizar sua configuração e comportamento de execução em seu núcleo.

• Gradle scales - O Gradle pode aumentar facilmente sua produtividade, desde compilações de projeto simples e únicas até compilações de multiprojetos corporativos enormes.

• Multi-project builds- O Gradle oferece suporte para compilações de vários projetos e para compilações parciais. Se você criar um subprojeto, o Gradle se encarregará de criar todos os subprojetos dos quais ele depende.

• Different ways to manage your builds - Gradle oferece suporte a diferentes estratégias para gerenciar suas dependências.

• Gradle is the first build integration tool- Gradle totalmente compatível com suas tarefas ANT, infraestrutura de repositório Maven e lvy para publicação e recuperação de dependências. O Gradle também fornece um conversor para transformar um Maven pom.xml em script Gradle.

• Ease of migration- O Gradle pode se adaptar facilmente a qualquer estrutura que você tenha. Portanto, você sempre pode desenvolver sua compilação do Gradle no mesmo branch em que pode criar o script ativo.

• Gradle Wrapper- O Gradle Wrapper permite que você execute compilações do Gradle em máquinas nas quais o Gradle não está instalado. Isso é útil para integração contínua de servidores.

• Free open source - Gradle é um projeto de código aberto e licenciado pela Apache Software License (ASL).

• Groovy- O script de construção do Gradle é escrito em Groovy. Todo o design do Gradle é orientado para ser usado como uma linguagem, não como uma estrutura rígida. E o Groovy permite que você escreva seu próprio script com algumas abstrações. Toda a API Gradle é totalmente projetada na linguagem Groovy.

Por que Groovy?

A API Gradle completa é projetada usando a linguagem Groovy. Esta é uma vantagem de uma DSL interna sobre XML. O Gradle é uma ferramenta de criação de uso geral em sua essência; seu foco principal são projetos Java. Em tais projetos, os membros da equipe estarão muito familiarizados com Java e é melhor que uma construção seja o mais transparente possível para todos os membros da equipe.

Linguagens como Python, Groovy ou Ruby são melhores para construir frameworks. O motivo da escolha do Groovy é que ele oferece, de longe, a maior transparência para quem usa Java. A sintaxe base do Groovy é a mesma do Java. O Groovy oferece muito mais além disso.

Gradle é uma ferramenta de construção baseada em java. Existem alguns pré-requisitos que devem ser instalados antes de instalar a estrutura do Gradle.

Pré-requisitos

JDK e Groovy são os pré-requisitos para a instalação do Gradle.

• O Gradle requer o JDK versão 6 ou posterior para ser instalado em seu sistema. Ele usa as bibliotecas JDK que são instaladas e configuradas para a variável de ambiente JAVA_HOME.

• O Gradle tem sua própria biblioteca Groovy, portanto, não precisamos instalar o Groovy explicitamente. Se estiver instalado, será ignorado pelo Gradle.

A seguir estão as etapas para instalar o Gradle em seu sistema.

Etapa 1 - Verificar a instalação JAVA

Em primeiro lugar, você precisa ter o Java Software Development Kit (SDK) instalado em seu sistema. Para verificar isso, executeJava –version comando em qualquer plataforma em que você está trabalhando.

No Windows -

Execute o seguinte comando para verificar a instalação do Java. Eu instalei o JDK 1.8 em meu sistema.

C:\> java -version

Produto -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

No Linux -

Execute o seguinte comando para verificar a instalação do Java. Eu instalei o JDK 1.8 em meu sistema.

$ java - version

Produto -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

Presumimos que os leitores deste tutorial tenham o Java SDK versão 1.8.0_66 instalado em seus sistemas.

Etapa 2 - Baixe o arquivo de compilação do Gradle

Baixe a versão mais recente do Gradle no link Baixar Gradle . Na página de referência, clique noComplete Distributionligação. Esta etapa é comum para qualquer plataforma. Para isso, você receberá o arquivo de distribuição completo na pasta Downloads.

Etapa 3 - Configurar ambiente para Gradle

Configurar o ambiente significa que temos que extrair o arquivo de distribuição, copiar os arquivos da biblioteca no local adequado. ConfigurandoGRADLE_HOME e PATH variáveis ​​ambientais.

Esta etapa depende da plataforma.

No Windows -

Extraia o arquivo zip baixado chamado gradle-2.11-all.zip e copie os arquivos de distribuição de Downloads\gradle-2.11\ para C:\gradle\ localização.

Depois disso, adicione o C:\gradle e C:\gradle\bin diretórios para o GRADLE_HOME e PATHvariáveis ​​do sistema. Siga a instrução dada que éright click on my computers -> click on properties -> advanced system settings -> click on environmental variables. Lá você encontrará uma caixa de diálogo para criar e editar variáveis ​​de sistema. Clique no novo botão para criar a variável GRADLE_HOME (siga a imagem do lado esquerdo). Clique em Editar para editar a variável de sistema Path existente (siga a captura de tela do lado direito). Siga as imagens abaixo fornecidas.

No Linux -

Extraia o arquivo zip baixado chamado gradle-2.11-all.zip então você encontrará um arquivo extraído chamado gradle-2.11.

Você pode usar o seguinte para mover os arquivos de distribuição de Downloads/gradle-2.11/ para /opt/gradle/localização. Execute esta operação a partir do diretório Downloads.

$ sudo mv gradle-2.11 /opt/gradle

Edite o arquivo ~ / .bashrc, cole o seguinte conteúdo nele e salve-o.

export ORIENT_HOME = /opt/gradle
export PATH = $PATH:

Execute o seguinte comando para executar ~/.bashrc Arquivo.

$ source ~/.bashrc

Etapa 4: verifique a instalação do Gradle

No Windows:

Você pode executar o seguinte comando no prompt de comando.

C:\> gradle –v

Saída: lá você encontrará a versão do Gradle.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978
Groovy: 2.4.4

Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Windows 8.1 6.3 amd64

No Linux:

Você pode executar o seguinte comando no terminal.

$ gradle –v

Saída: lá você encontrará a versão do Gradle.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978

Groovy: 2.4.4
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Linux 3.13.0-74-generic amd64

O Gradle cria um arquivo de script para lidar com duas coisas; um éprojects e outro é tasks. Cada compilação do Gradle representa um ou mais projetos. Um projeto representa um JAR de biblioteca ou um aplicativo da web ou pode representar um ZIP montado a partir dos JARs produzidos por outros projetos. Em palavras simples, um projeto é composto por diferentes tarefas. Uma tarefa significa uma parte do trabalho que uma construção executa. Uma tarefa pode ser compilar algumas classes, criar um JAR, gerar Javadoc ou publicar alguns arquivos em um repositório.

Gradle usa Groovy language para escrever scripts.

Escrevendo script de construção

O Gradle fornece uma linguagem específica de domínio (DSL) para descrever compilações. Isso usa a linguagem Groovy para facilitar a descrição de uma construção. Cada script de construção do Gradle é codificado usando UTF-8, salvo offline e nomeado como build.gradle.

build.gradle

Estamos descrevendo tarefas e projetos usando um script Groovy. Você pode executar uma compilação do Gradle usando o comando Gradle. Este comando procura por um arquivo chamadobuild.gradle. Dê uma olhada no exemplo a seguir, que representa um pequeno script que imprimetutorialspoint. Copie e salve o seguinte script em um arquivo chamadobuild.gradle. Este script de construção define um nome de tarefa hello, que é usado para imprimir a string tutorialspoint.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Execute o seguinte comando no prompt de comando. Ele executa o script acima. Você deve executar isso, onde o arquivo build.gradle está armazenado.

C:\> gradle –q hello

Resultado:

tutorialspoint

Se você acha que a tarefa funciona de forma semelhante ao alvo ANT, então isso é certo - a tarefa Gradle é equivalente ao alvo ANT.

Você pode simplificar esta tarefa de olá especificando um atalho (representa um símbolo <<) ao doLastdeclaração. Se você adicionar este atalho à tarefa acimahello será semelhante ao seguinte script.

task hello << {
   println 'tutorialspoint'
}

Como acima, você pode executar o script acima usando gradle –q hello comando.

O script Grade usa principalmente dois objetos reais, um é o objeto de projeto e outro é o objeto de script.

Project Object- Cada script descreve sobre um ou vários projetos. Enquanto na execução, este script configura o objeto do projeto. Você pode chamar alguns métodos e usar propriedades em seu script de construção que são delegados ao Objeto do Projeto.

Script Object- O Gradle leva o código do script para classes que implementam a Interface do Script e, em seguida, executa. Isso significa que todas as propriedades e métodos declarados pela interface do script estão disponíveis em seu script.

A tabela a seguir define a lista de standard project properties. Todas essas propriedades estão disponíveis em seu script de construção.

Noções básicas do Groovy

Os scripts de compilação do Gradle usam a API Groovy completa. Como uma inicialização, dê uma olhada nos exemplos a seguir.

O exemplo a seguir explica como converter uma string em maiúsculas.

Copie e salve o código fornecido abaixo em build.gradle Arquivo.

task upper << {
   String expString = 'TUTORIALS point'
   println "Original: " + expString
   println "Upper case: " + expString.toUpperCase()
}

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde o arquivo build.gradle está armazenado.

C:\> gradle –q upper

Resultado:

Original: TUTORIALS point
Upper case: TUTORIALS POINT

O exemplo a seguir explica como imprimir o valor de um parâmetro implícito ($ it) por 4 vezes.

Copie e salve o seguinte código em build.gradle Arquivo.

task count << {
   4.times { 
      print "$it " 
   }
}

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde o arquivo build.gradle está armazenado.

$ gradle –q count

Resultado:

0 1 2 3

A linguagem Groovy oferece muitos recursos; alguns recursos importantes são discutidos a seguir.

Métodos JDK Groovy

O Groovy adiciona muitos métodos úteis às classes Java padrão. Por exemplo, a API Iterable do JDK implementa umeach() método que itera sobre os elementos da Interface Iterável.

Copie e salve o seguinte código em build.gradle Arquivo.

task groovyJDK << {
   String myName = "Marc";
   myName.each() { 
      println "${it}" 
   };
}

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde o arquivo build.gradle é armazenado.

C:\> gradle –q groovyJDK

Resultado:

M
a
r
c

Acessores de propriedade

Você pode acessar automaticamente os métodos getter e setter apropriados de uma propriedade específica, especificando sua referência.

O snippet a seguir define as sintaxes dos métodos getter e setter de uma propriedade buildDir.

// Using a getter method
println project.buildDir
println getProject().getBuildDir()

// Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')

Parênteses opcionais em chamadas de método

Groovy contém um recurso especial na chamada de métodos que é os parênteses que são opcionais para a chamada de método. Esse recurso se aplica a scripts do Gradle também.

Dê uma olhada na seguinte sintaxe. Isso define uma chamada de métodosystemProperty do test objeto.

test.systemProperty 'some.prop', 'value'
test.systemProperty('some.prop', 'value')

Fechamento como último parâmetro do método

O Gradle DSL usa fechos em muitos lugares. Onde o último parâmetro de um método é um encerramento, você pode colocar o encerramento após a chamada do método.

O fragmento a seguir define a sintaxe que Closures usa como parâmetros de método repositories ().

repositories {
   println "in a closure"
}
repositories() { 
   println "in a closure" 
}
repositories({ println "in a closure" })

Importações padrão

O Gradle adiciona automaticamente um conjunto de instruções de importação aos scripts do Gradle. A lista a seguir mostra os pacotes de importação padrão para o script Gradle.

import org.gradle.*
import org.gradle.api.*
import org.gradle.api.artifacts.*
import org.gradle.api.artifacts.cache.*
import org.gradle.api.artifacts.component.*
import org.gradle.api.artifacts.dsl.*
import org.gradle.api.artifacts.ivy.*
import org.gradle.api.artifacts.maven.*
import org.gradle.api.artifacts.query.*
import org.gradle.api.artifacts.repositories.*
import org.gradle.api.artifacts.result.*
import org.gradle.api.component.*
import org.gradle.api.credentials.*
import org.gradle.api.distribution.*
import org.gradle.api.distribution.plugins.*
import org.gradle.api.dsl.*
import org.gradle.api.execution.*
import org.gradle.api.file.*
import org.gradle.api.initialization.*
import org.gradle.api.initialization.dsl.*
import org.gradle.api.invocation.*
import org.gradle.api.java.archives.*
import org.gradle.api.logging.*
import org.gradle.api.plugins.*
import org.gradle.api.plugins.announce.*
import org.gradle.api.plugins.antlr.*
import org.gradle.api.plugins.buildcomparison.gradle.*
import org.gradle.api.plugins.jetty.*
import org.gradle.api.plugins.osgi.*
import org.gradle.api.plugins.quality.*
import org.gradle.api.plugins.scala.*
import org.gradle.api.plugins.sonar.*
import org.gradle.api.plugins.sonar.model.*
import org.gradle.api.publish.*
import org.gradle.api.publish.ivy.*
import org.gradle.api.publish.ivy.plugins.*
import org.gradle.api.publish.ivy.tasks.*
import org.gradle.api.publish.maven.*
import org.gradle.api.publish.maven.plugins.*
import org.gradle.api.publish.maven.tasks.*
import org.gradle.api.publish.plugins.*
import org.gradle.api.reporting.*
import org.gradle.api.reporting.components.*
import org.gradle.api.reporting.dependencies.*
import org.gradle.api.reporting.model.*
import org.gradle.api.reporting.plugins.*
import org.gradle.api.resources.*
import org.gradle.api.specs.*
import org.gradle.api.tasks.*
import org.gradle.api.tasks.ant.*
import org.gradle.api.tasks.application.*
import org.gradle.api.tasks.bundling.*
import org.gradle.api.tasks.compile.*
import org.gradle.api.tasks.diagnostics.*
import org.gradle.api.tasks.incremental.*
import org.gradle.api.tasks.javadoc.*
import org.gradle.api.tasks.scala.*
import org.gradle.api.tasks.testing.*
import org.gradle.api.tasks.testing.junit.*
import org.gradle.api.tasks.testing.testng.*
import org.gradle.api.tasks.util.*
import org.gradle.api.tasks.wrapper.*
import org.gradle.authentication.*
import org.gradle.authentication.http.*
import org.gradle.buildinit.plugins.*
import org.gradle.buildinit.tasks.*
import org.gradle.external.javadoc.*
import org.gradle.ide.cdt.*
import org.gradle.ide.cdt.tasks.*
import org.gradle.ide.visualstudio.*
import org.gradle.ide.visualstudio.plugins.*
import org.gradle.ide.visualstudio.tasks.*
import org.gradle.ivy.*
import org.gradle.jvm.*
import org.gradle.jvm.application.scripts.*
import org.gradle.jvm.application.tasks.*
import org.gradle.jvm.platform.*
import org.gradle.jvm.plugins.*
import org.gradle.jvm.tasks.*
import org.gradle.jvm.tasks.api.*
import org.gradle.jvm.test.*
import org.gradle.jvm.toolchain.*
import org.gradle.language.assembler.*
import org.gradle.language.assembler.plugins.*
import org.gradle.language.assembler.tasks.*
import org.gradle.language.base.*
import org.gradle.language.base.artifact.*
import org.gradle.language.base.plugins.*
import org.gradle.language.base.sources.*
import org.gradle.language.c.*
import org.gradle.language.c.plugins.*
import org.gradle.language.c.tasks.*
import org.gradle.language.coffeescript.*
import org.gradle.language.cpp.*
import org.gradle.language.cpp.plugins.*
import org.gradle.language.cpp.tasks.*
import org.gradle.language.java.*
import org.gradle.language.java.artifact.*
import org.gradle.language.java.plugins.*
import org.gradle.language.java.tasks.*
import org.gradle.language.javascript.*
import org.gradle.language.jvm.*
import org.gradle.language.jvm.plugins.*
import org.gradle.language.jvm.tasks.*
import org.gradle.language.nativeplatform.*
import org.gradle.language.nativeplatform.tasks.*
import org.gradle.language.objectivec.*
import org.gradle.language.objectivec.plugins.*
import org.gradle.language.objectivec.tasks.*
import org.gradle.language.objectivecpp.*
import org.gradle.language.objectivecpp.plugins.*
import org.gradle.language.objectivecpp.tasks.*
import org.gradle.language.rc.*
import org.gradle.language.rc.plugins.*
import org.gradle.language.rc.tasks.*
import org.gradle.language.routes.*
import org.gradle.language.scala.*
import org.gradle.language.scala.plugins.*
import org.gradle.language.scala.tasks.*
import org.gradle.language.scala.toolchain.*
import org.gradle.language.twirl.*
import org.gradle.maven.*
import org.gradle.model.*
import org.gradle.nativeplatform.*
import org.gradle.nativeplatform.platform.*
import org.gradle.nativeplatform.plugins.*
import org.gradle.nativeplatform.tasks.*
import org.gradle.nativeplatform.test.*
import org.gradle.nativeplatform.test.cunit.*
import org.gradle.nativeplatform.test.cunit.plugins.*
import org.gradle.nativeplatform.test.cunit.tasks.*
import org.gradle.nativeplatform.test.googletest.*
import org.gradle.nativeplatform.test.googletest.plugins.*
import org.gradle.nativeplatform.test.plugins.*
import org.gradle.nativeplatform.test.tasks.*
import org.gradle.nativeplatform.toolchain.*
import org.gradle.nativeplatform.toolchain.plugins.*
import org.gradle.platform.base.*
import org.gradle.platform.base.binary
import org.gradle.platform.base.component.*
import org.gradle.platform.base.plugins.*
import org.gradle.platform.base.test.*
import org.gradle.play.*
import org.gradle.play.distribution.*
import org.gradle.play.platform.*
import org.gradle.play.plugins.*
import org.gradle.play.tasks.*
import org.gradle.play.toolchain.*
import org.gradle.plugin.use.*
import org.gradle.plugins.ear.*
import org.gradle.plugins.ear.descriptor.*
import org.gradle.plugins.ide.api.*
import org.gradle.plugins.ide.eclipse.*
import org.gradle.plugins.ide.idea.*
import org.gradle.plugins.javascript.base.*
import org.gradle.plugins.javascript.coffeescript.*
import org.gradle.plugins.javascript.envjs.*
import org.gradle.plugins.javascript.envjs.browser.*
import org.gradle.plugins.javascript.envjs.http.*
import org.gradle.plugins.javascript.envjs.http.simple.*
import org.gradle.plugins.javascript.jshint.*
import org.gradle.plugins.javascript.rhino.*
import org.gradle.plugins.javascript.rhino.worker.*
import org.gradle.plugins.signing.*
import org.gradle.plugins.signing.signatory.*
import org.gradle.plugins.signing.signatory.pgp.*
import org.gradle.plugins.signing.type.*
import org.gradle.plugins.signing.type.pgp.*
import org.gradle.process.*
import org.gradle.sonar.runner.*
import org.gradle.sonar.runner.plugins.*
import org.gradle.sonar.runner.tasks.*
import org.gradle.testing.jacoco.plugins.*
import org.gradle.testing.jacoco.tasks.*
import org.gradle.testkit.runner.*
import org.gradle.util.*

O script de compilação do Gradle descreve sobre um ou mais projetos. Cada projeto é composto de tarefas diferentes. Uma tarefa é uma parte do trabalho que uma construção executa. A tarefa pode ser compilar algumas classes, armazenar arquivos de classe em uma pasta de destino separada, criar JAR, gerar Javadoc ou publicar algumas conquistas em repositórios.

Este capítulo explica sobre o que é tarefa e como gerar e executar uma tarefa.

Definindo Tarefas

Tarefa é uma palavra-chave usada para definir uma tarefa no script de construção. Dê uma olhada no exemplo a seguir, que representa uma tarefa chamadahello que imprime tutorialspoint. Copie e salve o seguinte script em um arquivo chamadobuild.gradle. Este script de construção define um nome de tarefa hello que é usado para imprimir a string tutorialspoint.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Execute o seguinte comando no prompt de comando. Ele executa o script acima. Você deve executar isso onde o arquivo build.gradle está armazenado.

C:\> gradle –q hello

Resultado:

tutorialspoint

Você pode simplificar esta tarefa de olá especificando um atalho (representa um símbolo <<) ao doLastdeclaração. Se você adicionar este atalho à tarefa acimahello será semelhante ao seguinte script.

task hello << {
   println 'tutorialspoint'
}

Você pode executar o script acima usando gradle –q hello comando.

Aqui estão algumas variações na definição de uma tarefa, dê uma olhada nelas. O exemplo a seguir define uma tarefahello.

Copie e salve o seguinte código em build.gradle Arquivo.

task (hello) << {
   println "tutorialspoint"
}

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde o arquivo build.gradle é armazenado.

C:\> gradle –q hello

Resultado:

tutorialspoint

Você também pode usar strings para os nomes das tarefas. Dê uma olhada no mesmo exemplo hello. Aqui, usaremos String como tarefa.

Copie e salve o seguinte código em build.gradle Arquivo.

task('hello') << {
   println "tutorialspoint"
}

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde o arquivo build.gradle é armazenado.

C:\> gradle –q hello

Resultado:

tutorialspoint

Você também pode usar uma sintaxe alternativa para definir uma tarefa. Isso é usar o método create () para definir uma tarefa. Dê uma olhada no mesmo exemplo hello fornecido abaixo.

Copie e salve o código fornecido abaixo em build.gradle Arquivo.

tasks.create(name: 'hello') << {
   println "tutorialspoint"
}

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde o arquivo build.gradle é armazenado.

C:\> gradle –q hello

Resultado:

tutorialspoint

Localizando Tarefas

Se você deseja localizar as tarefas definidas no arquivo de construção, deve usar as respectivas propriedades padrão do projeto. Isso significa que cada tarefa está disponível como uma propriedade do projeto, usando o nome da tarefa como o nome da propriedade.

Dê uma olhada no código a seguir que acessa tarefas como propriedades.

Copie e salve o código fornecido abaixo em build.gradle Arquivo.

task hello

println hello.name
println project.hello.name

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde o arquivo build.gradle é armazenado.

C:\> gradle –q hello

Resultado:

hello
hello

Você também pode usar todas as propriedades por meio da coleção de tarefas.

Copie e salve o seguinte código em build.gradle Arquivo.

task hello

println tasks.hello.name
println tasks['hello'].name

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde o arquivo build.gradle é armazenado.

C:\> gradle –q hello

Resultado:

hello
hello

Você também pode acessar o caminho da tarefa usando as tarefas. Para isso, você pode chamar o método getByPath () com um nome de tarefa, ou um caminho relativo, ou um caminho absoluto.

Copie e salve o código fornecido abaixo em build.gradle Arquivo.

project(':projectA') {
   task hello
}
task hello

println tasks.getByPath('hello').path
println tasks.getByPath(':hello').path
println tasks.getByPath('projectA:hello').path
println tasks.getByPath(':projectA:hello').path

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde o arquivo build.gradle é armazenado.

C:\> gradle –q hello

Resultado:

:hello
:hello
:projectA:hello
:projectA:hello

Adicionando Dependências às Tarefas

Você pode fazer com que uma tarefa dependa de outra, o que significa que quando uma tarefa for concluída, apenas outra tarefa será iniciada. Cada tarefa é diferenciada com o nome da tarefa. A coleção de nomes de tarefas é referida por sua coleção de tarefas. Para se referir a uma tarefa em outro projeto, você deve usar o caminho do projeto como um prefixo para o respectivo nome da tarefa.

O exemplo a seguir que adiciona uma dependência de taskX para taskY.

Copie e salve o código fornecido abaixo em build.gradleArquivo. Dê uma olhada no código a seguir.

task taskX << {
   println 'taskX'
}
task taskY(dependsOn: 'taskX') << {
   println "taskY"
}

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde obuild.gradle armazenamentos de arquivos.

C:\> gradle –q taskY

Resultado:

taskX
taskY

O exemplo acima está adicionando dependência na tarefa usando seus nomes. Há outra maneira de obter dependência de tarefa que é definir a dependência usando um objeto Task.

Tomemos o mesmo exemplo de taskY sendo dependente de taskX, mas estamos usando objetos de tarefa em vez de nomes de referência de tarefa.

Copie e salve o seguinte código em build.gradle Arquivo.

task taskY << {
   println 'taskY'
}
task taskX << {
   println 'taskX'
}
taskY.dependsOn taskX

Execute o seguinte comando no prompt de comando. Você deve executar isso onde o arquivo build.gradle está armazenado.

C:\> gradle –q taskY

Resultado:

taskX
taskY

O exemplo acima está adicionando dependência na tarefa usando seus nomes. Existe outra maneira de obter dependência de tarefa que é definir a dependência usando um objeto Task.

Aqui, pegamos o mesmo exemplo de que taskY depende de taskX, mas estamos usando objetos de tarefa em vez de nomes de referência de tarefa. Dê uma olhada nisso.

Copie e salve o código fornecido abaixo em build.gradleArquivo. Dê uma olhada no código a seguir.

task taskX << {
   println 'taskX'
}
taskX.dependsOn {
   tasks.findAll { 
      task → task.name.startsWith('lib') 
   }
}
task lib1 << {
   println 'lib1'
}
task lib2 << {
   println 'lib2'
}
task notALib << {
   println 'notALib'
}

Execute o seguinte comando no prompt de comando. Ele executa o script fornecido acima. Você deve executar isso, onde obuild.gradle armazenamentos de arquivos.

C:\> gradle –q taskX

Resultado:

lib1
lib2
taskX

Adicionar uma descrição a uma tarefa

Você pode adicionar uma descrição à sua tarefa. Esta descrição é exibida durante a execuçãoGradle tasks. Isso é possível usando a palavra-chave de descrição.

Copie e salve o seguinte código em build.gradleArquivo. Dê uma olhada no código a seguir.

task copy(type: Copy) {
   description 'Copies the resource directory to the target directory.'
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
   println("description applied")
}

Execute o seguinte comando no prompt de comando. Você deve executar isso onde o arquivo build.gradle está armazenado.

C:\> gradle –q copy

Se o comando for executado com sucesso, você obterá a seguinte saída.

description applied

Ignorando Tarefas

Ignorar tarefas pode ser feito passando um fechamento de predicado. Isso só é possível se o método de uma tarefa ou um encerramento lançando umStopExecutionException antes que o trabalho real de uma tarefa seja executado.

Copie e salve o seguinte código em build.gradle Arquivo.

task eclipse << {
   println 'Hello Eclipse'
}

// #1st approach - closure returning true, if the task should be executed, false if not.
eclipse.onlyIf {
   project.hasProperty('usingEclipse')
}

// #2nd approach - alternatively throw an StopExecutionException() like this
eclipse.doFirst {
   if(!usingEclipse) {
      throw new StopExecutionException()
   }
}

Execute o seguinte comando no prompt de comando. Você deve executar isso onde o arquivo build.gradle está armazenado.

C:\> gradle –q eclipse

Estrutura da Tarefa

O Gradle tem diferentes fases, ao trabalhar com tarefas. Em primeiro lugar, existe uma fase de configuração, onde o código, que é especificado diretamente no encerramento de uma tarefa, é executado. O bloco de configuração é executado para todas as tarefas disponíveis e não apenas para aquelas tarefas que posteriormente são realmente executadas.

Após a fase de configuração, a fase de execução executa o código dentro do doFirst ou doLast encerramentos dessas tarefas, que são realmente executados.

O script de construção do Gradle define um processo para construir projetos; cada projeto contém algumas dependências e algumas publicações. Dependências significam as coisas que suportam a construção de seu projeto, como o arquivo JAR necessário de outros projetos e JARs externos como JDBC JAR ou Eh-cache JAR no caminho da classe. Publicações significam os resultados do projeto, como arquivos de classe de teste e arquivos de construção, como arquivos war.

Quase todos os projetos não são independentes. Eles precisam de arquivos criados por outros projetos para compilar e testar os arquivos de origem. Por exemplo, para usar o Hibernate no projeto, você precisa incluir alguns JARs do Hibernate no classpath. O Gradle usa algum script especial para definir as dependências, que precisam ser baixadas.

O Gradle se encarrega de criar e publicar os resultados em algum lugar. A publicação é baseada na tarefa que você define. Ele pode querer copiar os arquivos para o diretório local, ou carregá-los para um repositório Maven ou lvy remoto ou você pode usar os arquivos de outro projeto na mesma compilação de multiprojeto. Podemos chamar o processo de publicação de uma tarefa de publicação.

Declarando suas dependências

A configuração de dependência nada mais é que define um conjunto de dependências. Você pode usar este recurso para declarar dependências externas dos meios que deseja baixar da web. Isso define diferentes padrões, como a seguir.

apply plugin: 'java'

repositories {
   mavenCentral()
}

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

Configurações de Dependência

A configuração de dependências nada mais é do que define um conjunto de dependências. Você pode usar este recurso para declarar dependências externas, as quais deseja baixar da web. Isso define as seguintes configurações padrão diferentes.

• Compile - As dependências necessárias para compilar a fonte de produção do projeto.

• Runtime- As dependências exigidas pelas classes de produção em tempo de execução. Por padrão, também inclui as dependências de tempo de compilação.

• Test Compile- As dependências necessárias para compilar a fonte de teste do projeto. Por padrão, inclui classes de produção compiladas e dependências de tempo de compilação.

• Test Runtime- As dependências necessárias para executar os testes. Por padrão, inclui dependências de tempo de execução e de compilação de teste.

Dependências Externas

Dependências externas são aquelas do tipo de dependências. Esta é uma dependência de alguns arquivos construídos externamente na construção atual e armazenados em um repositório de algum tipo, como Maven central, ou um Maven corporativo ou repositório lvy, ou um diretório no sistema de arquivos local.

O seguinte fragmento de código é para definir a dependência externa. Use este código embuild.gradle Arquivo.

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
}

Uma dependência externa está declarando dependências externas e o formulário de atalho se parece com "grupo: nome: versão".

Repositórios

Ao adicionar dependências externas. O Gradle procura por eles em um repositório. Um repositório é apenas uma coleção de arquivos, organizados por grupo, nome e versão. Por padrão, o Gradle não define nenhum repositório. Temos que definir pelo menos um repositório explicitamente. O fragmento de código a seguir define como definir o repositório maven. Use este código embuild.gradle Arquivo.

repositories {
   mavenCentral()
}

O código a seguir é para definir maven remoto. Use este código embuild.gradle Arquivo.

repositories {
   maven {
      url "http://repo.mycompany.com/maven2"
   }
}

Publicação de artefatos

As configurações de dependência também são usadas para publicar arquivos. Esses arquivos publicados são chamados de artefatos. Normalmente, usamos plug-ins para definir artefatos. No entanto, você precisa informar ao Gradle onde publicar os artefatos. Você pode fazer isso anexando repositórios à tarefa de upload de arquivos. Dê uma olhada na seguinte sintaxe para publicar o repositório Maven. Durante a execução, o Gradle irá gerar e carregar um Pom.xml de acordo com os requisitos do projeto. Use este código embuild.gradle Arquivo.

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://localhost/tmp/myRepo/")
      }
   }
}

Plugin nada mais é do que um conjunto de tarefas, quase todas as tarefas úteis, como compilar tarefas, definir objetos de domínio, configurar arquivos de origem, etc., são gerenciadas por plug-ins. Aplicar um plugin a um projeto significa que permite que o plugin estenda as capacidades do projeto. Os plug-ins podem fazer coisas como -

• Estenda o modelo básico do Gradle (por exemplo, adicione novos elementos DSL que podem ser configurados).
• Configure o projeto de acordo com as conversões (por exemplo, adicione novas tarefas ou configure padrões razoáveis).
• Aplicar configuração específica (por exemplo, adicionar repositórios organizacionais ou impor padrões).

Tipos de Plugins

Existem dois tipos de plug-ins no Gradle, plug-ins de script e plug-ins binários. Os plug-ins de script são um script de construção adicional que fornece uma abordagem declarativa para manipular a construção. Isso normalmente é usado em uma construção. Plug-ins binários são as classes que implementam a interface do plug-in e adotam uma abordagem programática para manipular a construção. Plug-ins binários podem residir com um script de construção, com a hierarquia do projeto ou externamente em um JAR de plug-in.

Aplicando Plugins

Project.apply()O método API é usado para aplicar o plugin específico. Você pode usar o mesmo plugin várias vezes. Existem dois tipos de plug-ins, um é o plug-in de script e o segundo é o plug-in binário.

Plugins de script

Os plug-ins de script podem ser aplicados a partir de um script no sistema de arquivos local ou em um local remoto. As localizações do sistema de arquivos são relativas ao diretório do projeto, enquanto as localizações remotas do script especificam o URL HTTP. Dê uma olhada no seguinte trecho de código. É usado para aplicar oother.gradleplugin para o script de construção. Use este código embuild.gradle Arquivo.

apply from: 'other.gradle'

Plugins Binários

Cada plug-in é identificado pelo id do plug-in, alguns plug-ins principais usam nomes curtos para aplicá-lo e alguns plug-ins da comunidade usam um nome totalmente qualificado para o id do plug-in. Algum tempo permite especificar a classe do plugin.

Dê uma olhada no seguinte trecho de código. Mostra como aplicar o plugin java usando seu tipo. Use este código embuild.gradle Arquivo.

apply plugin: JavaPlugin

Dê uma olhada no código a seguir para aplicar o plugin principal usando um nome curto. Use este código embuild.gradle Arquivo.

plugins {
   id 'java'
}

Dê uma olhada no código a seguir para aplicar o plugin da comunidade usando um nome curto. Use este código embuild.gradle Arquivo.

plugins {
   id "com.jfrog.bintray" version "0.4.1"
}

Escrevendo plug-ins personalizados

Ao criar um plugin customizado, você precisa escrever uma implementação do plugin. O Gradle instancia o plug-in e chama a instância do plug-in usando o método Plugin.apply (). O exemplo a seguir contém um plug-in de saudação, que adiciona uma tarefa hello ao projeto. Dê uma olhada no código a seguir. Use este código embuild.gradle Arquivo.

apply plugin: GreetingPlugin

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.task('hello') << {
         println "Hello from the GreetingPlugin"
      }
   }
}

Use o seguinte código para executar o script acima.

C:\> gradle -q hello

Resultado:

Hello from the GreetingPlugin

Obtendo informações do Build

A maioria dos plug-ins precisa do suporte de configuração do script de construção. O projeto Gradle tem um objeto ExtensionContainer associado que ajuda a rastrear todas as configurações e propriedades transmitidas aos plug-ins.

Vamos adicionar um objeto de extensão simples ao projeto. Aqui, adicionamos um objeto de extensão de saudação ao projeto, o que permite configurar a saudação. Use este código embuild.gradle Arquivo.

apply plugin: GreetingPlugin

greeting.message = 'Hi from Gradle'

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      // Add the 'greeting' extension object
      project.extensions.create("greeting", GreetingPluginExtension)
		
      // Add a task that uses the configuration
      project.task('hello') << {
         println project.greeting.message
      }
   }
}

class GreetingPluginExtension {
   def String message = 'Hello from GreetingPlugin'
}

Use o seguinte código para executar o script acima.

C:\> gradle -q hello

Resultado:

Hi from Gradle

Neste exemplo, GreetingPlugin é um objeto Groovy antigo e simples com um campo chamado mensagem. O objeto de extensão é adicionado à lista de plug-ins com o nome saudação. Este objeto então se torna disponível como uma propriedade do projeto com o mesmo nome do objeto de extensão.

O Gradle adiciona um fechamento de configuração para cada objeto de extensão, para que você possa agrupar as configurações. Dê uma olhada no código a seguir. Use este código embuild.gradle Arquivo.

apply plugin: GreetingPlugin

greeting {
   message = 'Hi'
   greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.extensions.create("greeting", GreetingPluginExtension)
		
      project.task('hello') << {
         println "${project.greeting.message} from ${project.greeting.greeter}"
      }
   }
}

class GreetingPluginExtension {
   String message
   String greeter
}

Use o seguinte código para executar o script acima.

C:\> gradle -q hello

Resultado:

Hello from Gradle

Plug-ins Gradle padrão

Existem diferentes plug-ins incluídos na distribuição do Gradle.

Plugins de linguagem

Esses plug-ins adicionam suporte para várias linguagens que podem ser compiladas e executadas na JVM.

Incubando Plugins de Linguagem

Esses plug-ins adicionam suporte para vários idiomas.

O Gradle fornece uma linha de comando para executar o script de compilação. Ele pode executar mais de uma tarefa por vez. Este capítulo explica como executar várias tarefas usando opções diferentes.

Execução de várias tarefas

Você pode executar várias tarefas a partir de um único arquivo de construção. O Gradle pode lidar com esse arquivo de compilação usandogradle command. Este comando compilará cada tarefa na ordem em que são listadas e executará cada tarefa junto com as dependências usando opções diferentes.

Example- Existem quatro tarefas - tarefa1, tarefa2, tarefa3 e tarefa4. A tarefa 3 e a tarefa 4 dependem da tarefa 1 e da tarefa 2. Dê uma olhada no diagrama a seguir.

Nas 4 tarefas acima são dependentes umas das outras representadas por um símbolo de seta. Dê uma olhada no código a seguir. Copiar pode colá-lo embuild.gradle Arquivo.

task task1 << {
   println 'compiling source'
}

task task2(dependsOn: task1) << {
   println 'compiling unit tests'
}

task task3(dependsOn: [task1, task2]) << {
   println 'running unit tests'
}

task task4(dependsOn: [task1, task3]) << {
   println 'building the distribution'
}

Você pode usar o código a seguir para compilar e executar a tarefa acima.

C:\> gradle task4 test

Resultado:

:task1
compiling source
:task2
compiling unit tests
:task3
running unit tests
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Excluindo Tarefas

Ao excluir uma tarefa da execução, você pode usar a opção –x junto com o comando gradle e mencionar o nome da tarefa que deseja excluir.

Use o seguinte comando para excluir task4 do script acima.

C:\> gradle task4 -x test

Resultado:

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Continuando a construção quando ocorre uma falha

O Gradle abortará a execução e falhará na compilação assim que qualquer tarefa falhar. Você pode continuar a execução mesmo quando ocorre uma falha. Para isso, você deve usar a opção –continue com o comando gradle. Ele lida com cada tarefa separadamente, juntamente com suas dependências. E o principal ponto importante é que ele irá capturar cada falha encontrada e relatar no final da execução da construção. Suponha que se uma tarefa falhar, as tarefas subsequentes dependentes também não serão executadas.

Selecionando qual compilação executar

Quando você executa o comando gradle, ele procura um arquivo de compilação no diretório atual. Você pode usar a opção –b para selecionar um arquivo de construção específico junto com o caminho absoluto. O exemplo a seguir selecionando um projeto hello demyproject.gradle arquivo que está localizado no subdir/ dê uma olhada nisso.

task hello << {
   println "using build file '$buildFile.name' in '$buildFile.parentFile.name'."
}

Você pode usar o seguinte comando para executar o script acima.

C:\> gradle -q -b subdir/myproject.gradle hello

Resultado:

using build file 'myproject.gradle' in 'subdir'.

Obtendo Informações do Build

O Gradle fornece várias tarefas integradas para recuperar os detalhes das informações sobre a tarefa e o projeto. Isso pode ser útil para entender a estrutura e as dependências de sua compilação e para depurar problemas. Você pode usar o plugin de relatório de projeto para adicionar tarefas ao seu projeto, o que irá gerar esses relatórios.

Listagem de projetos

Você pode listar a hierarquia do projeto selecionado e seus subprojetos usando gradle –q projectscomando. Aqui está o exemplo, use o seguinte comando para listar todos os projetos no arquivo de construção.

C:\> gradle -q projects

Resultado:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

O relatório mostra a descrição de cada projeto, se especificado. Você pode usar o seguinte comando para especificar a descrição. Cole nobuild.gradle Arquivo.

description = 'The shared API for the application'

Tarefas de listagem

Você pode listar todas as tarefas que pertencem aos vários projetos usando o seguinte comando.

C:\> gradle -q tasks

Resultado:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
dists - Builds the distribution
libs - Builds the JAR

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
components - Displays the components produced by root project 'projectReports'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
properties - Displays the properties of root project 'projectReports'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).

To see all tasks and more detail, run gradle tasks --all

To see more detail about a task, run gradle help --task <task>

Você pode usar o seguinte comando para exibir as informações de todas as tarefas.

C:\> gradle -q tasks --all

Resultado:

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
api:clean - Deletes the build directory (build)
webapp:clean - Deletes the build directory (build)
dists - Builds the distribution [api:libs, webapp:libs]
   docs - Builds the documentation
api:libs - Builds the JAR
   api:compile - Compiles the source files
webapp:libs - Builds the JAR [api:libs]
   webapp:compile - Compiles the source files

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
api:buildEnvironment - Displays all buildscript dependencies declared in project ':api'.
webapp:buildEnvironment - Displays all buildscript dependencies declared in project ':webapp'.
components - Displays the components produced by root project 'projectReports'. [incubating]
api:components - Displays the components produced by project ':api'. [incubating]
webapp:components - Displays the components produced by project ':webapp'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
api:dependencies - Displays all dependencies declared in project ':api'.
webapp:dependencies - Displays all dependencies declared in project ':webapp'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
api:dependencyInsight - Displays the insight into a specific dependency in project ':api'.
webapp:dependencyInsight - Displays the insight into a specific dependency in project ':webapp'.
help - Displays a help message.
api:help - Displays a help message.
webapp:help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
api:model - Displays the configuration model of project ':api'. [incubating]
webapp:model - Displays the configuration model of project ':webapp'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
api:projects - Displays the sub-projects of project ':api'.
webapp:projects - Displays the sub-projects of project ':webapp'.
properties - Displays the properties of root project 'projectReports'.
api:properties - Displays the properties of project ':api'.
webapp:properties - Displays the properties of project ':webapp'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).
api:tasks - Displays the tasks runnable from project ':api'.
webapp:tasks - Displays the tasks runnable from project ':webapp'.

Aqui estão algumas listas de comandos em uma descrição de tabela de diferentes opções.

Este capítulo explica como construir um projeto java usando o arquivo de construção do Gradle.

Em primeiro lugar, temos que adicionar o plugin java ao script de construção porque ele fornece tarefas para compilar o código-fonte Java, executar testes de unidade, criar Javadoc e criar um arquivo JAR. Use a seguinte linha embuild.gradle Arquivo.

apply plugin: 'java'

Layout de projeto padrão Java

Sempre que você adiciona um plugin à sua construção, ele assume uma determinada configuração do seu projeto Java (semelhante ao Maven). dê uma olhada na seguinte estrutura de diretório.

• src / main / java contém o código-fonte Java
• src / test / java contém os testes Java

Se você seguir esta configuração, o seguinte arquivo de construção é suficiente para compilar, testar e empacotar um projeto Java.

Para iniciar a construção, digite o seguinte comando na linha de comando.

C:\> gradle build

SourceSetspode ser usado para especificar uma estrutura de projeto diferente. Por exemplo, as fontes são armazenadas em umsrc pasta em vez de em src/main/java. Dê uma olhada na seguinte estrutura de diretório.

apply plugin: 'java'
sourceSets {
   main {
      java {
         srcDir 'src'
      }
   }
	
   test {
      java {
         srcDir 'test'
      }
   }
}

Execução de Tarefa init

O Gradle ainda não oferece suporte a vários modelos de projeto. Mas oferece uminittarefa de criar a estrutura de um novo projeto Gradle. Sem parâmetros adicionais, esta tarefa cria um projeto Gradle, que contém os arquivos gradle wrapper, umbuild.gradle e settings.gradle Arquivo.

Ao adicionar o --type parâmetro com java-library como valor, uma estrutura de projeto java é criada e o build.gradlearquivo contém um determinado modelo Java com Junit. Dê uma olhada no seguinte código parabuild.gradle Arquivo.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

Na seção de repositórios, ele define onde encontrar as dependências. Jcenteré para resolver suas dependências. A seção Dependências fornece informações sobre dependências externas.

Especificando a versão Java

Normalmente, um projeto Java possui uma versão e um JRE de destino no qual é compilado. oversion e sourceCompatibility propriedade pode ser definida no build.gradle Arquivo.

version = 0.1.0
sourceCompatibility = 1.8

Se o artefato for um aplicativo Java executável, o MANIFEST.MF arquivo deve estar ciente da classe com o método principal.

apply plugin: 'java'

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Example:

Crie uma estrutura de diretório como mostrado na imagem abaixo.

Copie o código java fornecido abaixo no arquivo App.java e armazene em consumerbanking\src\main\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Copie o código java fornecido abaixo no arquivo AppTset.java e armazene em consumerbanking\src\test\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App{
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Copie o código fornecido abaixo no arquivo build.gradle e coloque-o em consumerbanking\ diretório.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Para compilar e executar o script acima, use os comandos fornecidos abaixo.

consumerbanking\> gradle tasks
consumerbanking\> gradle assemble
consumerbanking\> gradle build

Verifique todos os arquivos de classe nos respectivos diretórios e verifique consumerbanking\build\lib pasta para consumerbanking.jar Arquivo.

Este capítulo explica como compilar e executar um projeto Groovy usando build.gradle Arquivo.

O plug-in Groovy

O plug-in Groovy para Gradle estende o plug-in Java e fornece tarefas para programas Groovy. Você pode usar a seguinte linha para aplicar o plugin groovy.

apply plugin: 'groovy'

O arquivo de script de construção completo é o seguinte. Copie o seguinte código embuild.gradle Arquivo.

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

dependencies {
   compile 'org.codehaus.groovy:groovy-all:2.4.5'
   testCompile 'junit:junit:4.12'
}

Você pode usar o seguinte comando para executar o script de construção.

gradle build

Layout de projeto padrão de projetos Groovy

O plug-in Groovy assume uma determinada configuração de seu projeto Groovy.

• src / main / groovy contém o código-fonte do Groovy
• src / test / groovy contém os testes Groovy
• src / main / java contém o código-fonte Java
• src / test / java contém os testes Java

Verifique o respectivo diretório onde build.gradle locais de arquivo para a pasta de construção.

A tarefa de teste detecta e executa automaticamente todos os testes de unidade no conjunto de origem de teste. Ele também gera um relatório quando a execução do teste é concluída. JUnit e TestNG são as APIs com suporte.

A tarefa de teste fornece um Test.getDebug()método que pode ser configurado para iniciar para fazer a JVM esperar por um depurador. Antes de prosseguir com a execução, ele define a postagem do depurador para5005.

Detecção de Teste

o Test Taskdetecta quais classes são classes de teste inspecionando as classes de teste compiladas. Por padrão, ele verifica todos os arquivos .class. Você pode definir inclusões / exclusões personalizadas, apenas essas classes serão verificadas. Dependendo da estrutura de teste usada (JUnit / TestNG), a detecção da classe de teste usa critérios diferentes.

Ao usar o JUnit, procuramos as classes de teste JUnit 3 e 4. Se algum dos critérios a seguir corresponder, a classe é considerada uma classe de teste JUnit -

• Classe ou superclasse estende TestCase ou GroovyTestCase
• Classe ou superclasse é anotada com @RunWith
• Classe ou superclasse contém um método anotado com @Test
• Ao usar TestNG, verificamos métodos anotados com @Test

Note- As classes abstratas não são executadas. O Gradle também verifica a árvore de herança em arquivos jar no classpath de teste.

Se você não quiser usar a detecção de classe de teste, pode desativá-la definindo scanForTestClasses para falso.

Agrupamento de Teste

JUnit e TestNG permitem agrupamentos sofisticados de métodos de teste. Para agrupamento, classes e métodos de teste JUnit JUnit 4.8 introduz o conceito de categorias. A tarefa de teste permite a especificação das categorias JUnit que você deseja incluir e excluir.

Você pode usar o seguinte fragmento de código no arquivo build.gradle para agrupar métodos de teste.

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

Incluir e Excluir Testes Particulares

o Test classe tem um include e excludemétodo. Esses métodos podem ser usados ​​para especificar quais testes realmente devem ser executados.

Execute apenas os testes incluídos -

test {
   include '**my.package.name/*'
}

Pular testes excluídos -

test {
   exclude '**my.package.name/*'
}

A amostra build.gradle como mostrado abaixo, ele mostra diferentes opções de configuração.

apply plugin: 'java' // adds 'test' task

test {
   // enable TestNG support (default is JUnit)
   useTestNG()

   // set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

   // explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

   // show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

   // set heap size for the test JVM(s)
   minHeapSize = "128m"
   maxHeapSize = "512m"

   // set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'
   
   // listen to events in the test execution lifecycle
   beforeTest { 
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

   // listen to standard out and standard error of the test JVM(s)
   onOutput { 
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: " 
         + event.message )
   }
}

Você pode usar a seguinte sintaxe de comando para executar algumas tarefas de teste.

gradle <someTestTask> --debug-jvm

O Gradle pode gerenciar projetos menores e maiores com facilidade. Projetos pequenos têm um único arquivo de construção e uma árvore de origem. É muito fácil digerir e entender um projeto que foi dividido em módulos menores e interdependentes. O Gradle oferece suporte perfeito para esse cenário de criação de vários projetos.

Estrutura para construção de vários projetos

Essas construções vêm em todas as formas e tamanhos, mas eles têm algumas características comuns -

• UMA settings.gradle arquivo no diretório raiz ou mestre do projeto.

• UMA build.gradle arquivo no diretório raiz ou mestre.

• Diretórios filho que têm seus próprios *.gradle arquivos de construção (algumas construções de vários projetos podem omitir scripts de construção de projetos filho).

Para listar todos os projetos no arquivo de construção, você pode usar o seguinte comando.

C:\> gradle -q projects

Resultado:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

O relatório mostra a descrição de cada projeto, se especificado. Você pode usar o seguinte comando para especificar a descrição. Cole nobuild.gradle Arquivo.

description = 'The shared API for the application'

Especificando uma configuração geral de construção

Em um build.gradle no root_project, as configurações gerais podem ser aplicadas a todos os projetos ou apenas aos subprojetos.

allprojects {
   group = 'com.example.gradle'
   version = '0.1.0'
}

subprojects {
   apply plugin: 'java'
   apply plugin: 'eclipse'
}

Isso especifica um comum com.example.gradle grupo e o 0.1.0versão para todos os projetos. osubprojects encerramento aplica configurações comuns para todos os subprojetos, mas não para o projeto raiz, como o allprojects o fechamento sim.

Configurações e dependências específicas do projeto

O nucleo ui e util subprojetos também podem ter seus próprios build.gradle arquivo, se eles tiverem necessidades específicas, que ainda não são aplicadas pela configuração geral do projeto raiz.

Por exemplo, o projeto da interface do usuário geralmente tem uma dependência do projeto principal. Portanto, o projeto de interface do usuário precisa de seubuild.gradle arquivo para especificar esta dependência.

dependencies {
   compile project(':core')
   compile 'log4j:log4j:1.2.17'
}

As dependências do projeto são especificadas com o método do projeto.

O Gradle oferece várias maneiras de implantar repositórios de artefatos de construção. Ao implementar assinaturas para seus artefatos em um repositório Maven, você também desejará assinar o arquivo POM publicado.

Usando o plug-in Maven-publish

maven-publishplugin, que é fornecido pelo Gradle por padrão. Usado para publicar o script do Gradle. Dê uma olhada no código a seguir.

apply plugin: 'java'
apply plugin: 'maven-publish'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
         url "$buildDir/repo"
      }
   }
}

Existem várias opções de publicação, quando o Java e a maven-publishplugin é aplicado. Dê uma olhada no código a seguir, ele implantará o projeto em um repositório remoto.

apply plugin: 'groovy'
apply plugin: 'maven-publish'

group 'workshop'
version = '1.0.0'

publishing {
   publications {
      mavenJava(MavenPublication) { 
         from components.java 
      }
   }
	
   repositories {
      maven {
          default credentials for a nexus repository manager
         credentials {
            username 'admin'
            password 'admin123'
         }
         // url to the releases maven repository
            url "http://localhost:8081/nexus/content/repositories/releases/"
      }
   }
}

Convertendo um projeto de Maven para Gradle

Existe um comando especial para converter o Apache Maven pom.xml para arquivos de compilação do Gradle, se todos os plug-ins Maven usados ​​forem conhecidos para esta tarefa.

Nesta seção, o seguinte pom.xmlA configuração do maven será convertida em um projeto Gradle. Dê uma olhada nisso.

<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.example.app</groupId>
   <artifactId>example-app</artifactId>
   <packaging>jar</packaging>
   
   <version>1.0.0-SNAPSHOT</version>
	
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>

         <version>4.11</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
	
</project>

Você pode usar o seguinte comando na linha de comando que resulta na seguinte configuração do Gradle.

C:\> gradle init --type pom

o init a tarefa depende da tarefa do wrapper para que um wrapper do Gradle seja criado.

O resultado build.gradle arquivo é semelhante a este -

apply plugin: 'java'
apply plugin: 'maven'

group = 'com.example.app'
version = '1.0.0-SNAPSHOT'

description = """"""

sourceCompatibility = 1.5
targetCompatibility = 1.5

repositories {
   maven { url "http://repo.maven.apache.org/maven2" }
}

dependencies {
   testCompile group: 'junit', name: 'junit', version:'4.11'
}

Este capítulo explica sobre a integração do eclipse e do Gradle. Siga as etapas fornecidas abaixo para adicionar o plug-in Gradle ao eclipse.

Etapa 1 - Abra o Eclipse Marketplace

Em primeiro lugar, abra o eclipse que está instalado em seu sistema. Vá para ajuda -> clique em EclipseMarketplace. Dê uma olhada na imagem a seguir.

Etapa 2 - Instale o Plug-in Buildship

Após clicar em Eclipse Marketplace, você encontrará a seguinte captura de tela. Aqui na barra de pesquisa do lado esquerdo digitebuildship. Buildship é um plugin de integração do Gradle. Quando você encontrar o buildship na tela, clique em instalar no lado direito. Dê uma olhada na imagem a seguir.

Depois disso, você encontrará a seguinte captura de tela, você precisa confirmar a instalação do software clicando no botão confirmar. Dê uma olhada na imagem a seguir.

Depois disso, você precisa clicar em aceitar o contrato de licença na tela a seguir e clicar em Concluir. Dê uma olhada na imagem a seguir.

A instalação levará algum tempo. Dê uma olhada na imagem a seguir.

Depois disso, ele pedirá para reiniciar o Eclipse. Lá você irá selecionarYes.

Etapa 3 - Verificando o plug-in do Gradle

Durante a verificação, criaremos um novo projeto seguindo o procedimento dado. No eclipse, vá para o arquivo -> clique em novo-> clique em outros projetos. Lá você encontrará a seguinte tela. Selecione o projeto Gradle e clique em Avançar. Dê uma olhada na captura de tela a seguir.

Após clicar no botão seguinte, você encontrará a tela a seguir. Lá, você fornecerá o caminho do diretório inicial do Gradle do sistema de arquivos local e clicar no botão Avançar. Dê uma olhada na imagem a seguir.

Dê uma olhada na captura de tela a seguir aqui, você fornecerá o nome do projeto Gradle. Neste tutorial, estamos usandodemoproject e clique no botão Concluir.

Dê uma olhada na imagem a seguir, precisamos confirmar o projeto. Para isso, clique no botão Concluir na tela a seguir.

Etapa 4 - Verificação da estrutura do diretório

Após a instalação bem-sucedida do plug-in Gradle, verifique a estrutura de diretório do projeto de demonstração para os arquivos e pastas padrão, conforme mostrado na imagem a seguir.